←2011-02-08 2011-02-09 2011-02-10→ ↑2011 ↑all
00:00:17 <Deewiant> Well done
00:02:08 -!- impomatic has quit (Quit: ChatZilla 0.9.86 [Firefox 3.5.16/20101130074636]).
00:02:26 <elliott__> $ ./shiro forks.b98
00:02:26 <elliott__> Hello, from Concurrent Befunge!
00:02:27 <elliott__> shiro: Shiro/Monad.hs:82:35-63: Non-exhaustive patterns in lambda
00:02:31 <elliott__> Deewiant: No comment.
00:02:35 <Deewiant> :-D
00:02:54 <elliott__> modifyCurrentIP :: (IP -> IP) -> Shiro ()
00:02:54 <elliott__> modifyCurrentIP f = modifyIPList $ \(ip:xs, r) -> (f ip : xs, r)
00:02:58 <elliott__> Ah.
00:03:16 <elliott__> (ips,_) <- gets ipList
00:03:16 <elliott__> when (null ips) $ io exitSuccess
00:03:21 <elliott__> Deewiant: Does any fingerprint kill an IP?
00:03:24 <elliott__> Or can I put that into the @ code?
00:03:56 <Deewiant> I don't think any can kill them as such, but TRDS and IIPC do things that you might want to implement by moving IPs out of the list
00:04:08 <elliott__> Mmm. Well, whatever.
00:04:10 <elliott__> elliott@elliott-MacBookAir:~/Code/shiro$ ./shiro forks.b98
00:04:10 <elliott__> Hello, from Concurrent Befunge!
00:04:10 <elliott__> elliott@elliott-MacBookAir:~/Code/shiro$
00:04:12 <elliott__> Deewiant: Yep.
00:04:19 <Deewiant> Aye.
00:04:56 <elliott__> Nice, GHC's compiles are nondeterministic.
00:04:59 <elliott__> i.e. recompiling == different hash.
00:05:42 <elliott__> elliott@elliott-MacBookAir:~/Code/shiro$ ./shiro shiro
00:05:42 <elliott__> Stack space overflow: current size 8388608 bytes.
00:05:42 <elliott__> Use `+RTS -Ksize -RTS' to increase it.
00:05:47 <elliott__> That's not good. :p
00:06:03 <Deewiant> Memory use profiling time
00:06:50 <elliott__> Deewiant: Naw.
00:06:55 <elliott__> I'll wait until that happens on an actual program.
00:07:04 <elliott__> COST CENTRE MODULE %time %alloc
00:07:04 <elliott__> doNextIns Shiro.Interpreter 100.0 7.3
00:07:04 <elliott__> --trace of forks.b98.
00:07:09 <elliott__> Strangely even coreIns is 0%.
00:08:39 <elliott__> Deewiant: Oh, and on Mycology:
00:08:43 <elliott__> COST CENTRE MODULE %time %alloc
00:08:43 <elliott__> insertFS Shiro.FungeSpace 85.8 91.5
00:08:43 <elliott__> modifyIPList Shiro.Monad 3.1 3.5
00:08:44 <elliott__> !@ Shiro.FungeSpace 3.1 0.1
00:08:44 <elliott__> coreIns Shiro.Interpreter 3.1 1.2
00:08:44 <elliott__> doNextIns Shiro.Interpreter 1.1 0.8
00:08:50 <elliott__> tl;dr if I didn't recalculate bounds, I would be a freaking speed demon.
00:08:55 <Deewiant> heh
00:09:45 <elliott__> mergeByteString Shiro.FungeSpace 367 685207 0.6 1.0 9.2 5.0
00:09:46 <elliott__> insertFS Shiro.FungeSpace 374 75489 8.7 4.0 8.7 4.0
00:10:37 <elliott__> Deewiant: OK, time to start implementing fingerprints.
00:10:54 <elliott__> Deewiant: I did _not_ expect to get this far. Especially not in three days.
00:10:55 -!- elliott__ has changed nick to elliott.
00:10:59 -!- elliott has quit (Changing host).
00:10:59 -!- elliott has joined.
00:12:14 <elliott> Time to integrate fptest.hs.
00:12:23 <elliott> Deewiant: Say, would you like a file that causes an internal error in GHC 6.12.3?
00:12:34 <Deewiant> Not in particular, but the GHC devs probably would
00:12:34 <elliott> It's a very short file.
00:12:47 <elliott> Deewiant: I'd have to test it with 7.0 to make a bug report and that sounds like a pain :P
00:13:04 <Deewiant> No you wouldn't :-P
00:13:12 <Deewiant> You can just report it against 6.12.3 and somebody else will
00:13:15 <elliott> [1 of 1] Compiling Main ( fptest.hs.ghcinternalerror.hs, interpreted )
00:13:15 <elliott> ghc: panic! (the 'impossible' happened)
00:13:15 <elliott> (GHC version 6.12.3 for x86_64-unknown-linux):
00:13:15 <elliott> TcTyFuns.flattenType: synonym family in a rank-n type
00:13:15 <elliott> Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug
00:13:16 <elliott> >
00:13:25 <Deewiant> "Impossible happened" bugs tend to get attention anyway
00:13:33 <elliott> That's a rather odd definition of impossible, since you can just code that directly :-)
00:13:35 -!- BeholdMyGlory has quit (Remote host closed the connection).
00:13:40 <Deewiant> Although given that description, it's probably just unimplemented and thus known
00:13:46 <elliott> Yeah.
00:13:58 <elliott> It was a pretty crazy thing to do, anyway :P
00:13:59 <Deewiant> Still, there might not be a ticket tracking it
00:14:04 <elliott> Yeah, yeah, I'll do it later :P
00:15:18 <elliott> {-# LANGUAGE TypeFamilies, ExistentialQuantification, FlexibleContexts, DeriveDataTypeable, StandaloneDeriving #-}
00:15:21 * elliott cracks knuckles
00:16:31 <elliott> type FPIPState fp
00:16:32 <elliott> fpInitialIPState :: fp -> FPIPState fp
00:16:36 <elliott> I'm just going to clone all fingerprint state for now :-P
00:17:16 <elliott> fpHandles :: fp -> [FPIns]
00:17:18 <elliott> Augh, that name irks me.
00:21:34 <elliott> Deewiant: What do you call it when one module is more elegant than the rest of your program?
00:23:13 <Deewiant> I don't call it anything
00:23:25 <elliott> You call it "oh yeah, this is the one I drafted up separately".
00:25:42 <joo> racism
00:26:12 <Deewiant> Bedtime
00:26:18 -!- cheater- has joined.
00:29:19 -!- cheater00 has quit (Ping timeout: 240 seconds).
00:32:16 -!- myndzi has changed nick to myndzi\.
00:32:28 -!- myndzi\ has changed nick to myndzi.
00:33:12 <myndzi> think i broke bfjoust again? :|
00:33:41 <myndzi> nm
00:33:44 <myndzi> it just caught up
00:34:56 <myndzi> !bfjoust careless >+++++>+++++>----->----->+>->>>((>[(-)*126(-.)*3)*22(])*22)*22
00:35:33 <EgoBot> Score for myndzi_careless: 59.1
00:39:08 <elliott> joo: indeed
00:43:49 -!- Mathnerd314 has quit (Ping timeout: 250 seconds).
00:46:10 <quintopia> holy crap
00:46:12 <quintopia> nice score
00:46:16 -!- cal153 has quit (Ping timeout: 265 seconds).
00:46:24 * myndzi bows
00:46:25 <myndzi> :P
00:46:32 <myndzi> straight to the ... TOP
00:47:06 <quintopia> !bfjoust juggernaut_bitch (.)*48(>[-[++[>>>[>(+)*20[[-]]+]]]](+)*13>[-[++[>>>>>[>(+)*20[[-]]+]]]](-)*13)*11
00:47:19 <quintopia> owait
00:47:28 <EgoBot> Score for quintopia_juggernaut_bitch: 12.9
00:47:29 <quintopia> that's wrong >_>
00:47:37 <quintopia> !bfjoust juggernaut_bitch (.)*48(>[-[++[>>>[>(+)*20[[-]]+]]]](+)*13>[-[++[>>>[>(+)*20[[-]]+]]]](-)*13)*11
00:48:02 <EgoBot> Score for quintopia_juggernaut_bitch: 12.7
00:48:08 <quintopia> lul
00:48:27 <quintopia> !bfjoust juggernaut_bitch (.)*48(>[-[++[>>>>>[>(+)*20[[-]]+]]]](+)*13>[-[++[>>>>>[>(+)*20[[-]]+]]]](-)*13)*11
00:48:46 <EgoBot> Score for quintopia_juggernaut_bitch: 14.2
00:50:40 <myndzi> i have a fun idea but i don't really want to flesh it out
00:52:02 <quintopia> which is
00:52:13 <Gregor> Observation: pizzicato and harpsichord are not the same.
00:52:21 <elliott> orly
00:52:35 <quintopia> Gregor: wat. vivaldi could have told you that :P
00:53:18 <quintopia> next thing you're gonna tell me harps and pizzicato don't sound the same! and banjos and pizzicato!
00:53:52 <Gregor> I'm trying to recover a passage that I added insufficient tension to by adding a harpsichord, which worked well but I'm kind of against because it would be a 30-second harpsichord solo inexplicably, so I was hoping I could "port" it to pizzicato (which I do have, but isn't playing there) and although it obviously wouldn't be the same, it would have sufficient effect.
00:53:53 <myndzi> !bfjoust tag http://24.19.39.178/tag
00:53:54 <Gregor> It did not.
00:54:37 <elliott> Gregor: 30-second harpischord solo... come on. Yes.
00:54:42 <EgoBot> Score for myndzi_tag: 3.6
00:54:45 <elliott> Do it.
00:54:46 <myndzi> lol
00:54:51 <myndzi> i must have done something terribly wrong
00:55:04 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
00:55:14 <Gregor> elliott: By "solo" I do not mean "playing alone", I mean "primary instrument" :P
00:55:26 <Gregor> elliott: And my concerns with the solo was that the instrument appears nowhere else :P
00:56:41 <myndzi> i have no idea what is wrong with it though, and that's why i didn't want to flesh it out :P
00:56:43 <myndzi> confusing!
00:56:56 <myndzi> lol it beats two of impomatic's though
00:57:33 <myndzi> i should have used a simpler/better attack perhaps, but since it's supposed to set off the tripwire on defend-style programs that wouldn't work well
00:57:35 <myndzi> o well
00:57:38 <myndzi> !bfjoust tag <
00:57:47 <EgoBot> Score for myndzi_tag: 0.0
00:58:37 <elliott> Gregor: Just make it go completely harpischord out of nowhere for 30 seconds with nothing else.
00:58:42 <elliott> And then back to normal like nothing happened.
00:58:57 <quintopia> yes
00:59:06 <quintopia> and the harpsichord should be played ragtime
00:59:18 <quintopia> ragtime is VERY TENSION
00:59:23 <myndzi> talk about spam, he's got like 7 programs on there that are almost the same damn thing D:
00:59:29 <elliott> myndzi: he
00:59:31 <Gregor> elliott: 'snot happening :P
00:59:31 <elliott> ?
00:59:35 <myndzi> impomatic
00:59:38 <elliott> quintopia: It is, yes.
01:00:09 <quintopia> elliott: you share knowledge tension gregor and then
01:00:20 <quintopia> elliott: VERY TENSION
01:00:47 <elliott> Gregor: Ha ha your language sucks
01:01:06 -!- nescience has quit (Quit: -a-).
01:01:15 -!- myndzi has changed nick to nescience.
01:01:32 -!- hagb4rd has quit (Quit: hagb4rd).
01:01:43 -!- sixdej has left (?).
01:05:20 <elliott> You know what's awesome?
01:05:28 -!- Mathnerd314 has joined.
01:05:57 <quintopia> sex
01:06:54 <elliott> Module imports form a cycle for modules:
01:06:54 <elliott> Shiro.Fingerprint (Shiro/Fingerprint.hs)
01:06:54 <elliott> imports: Shiro.Monad Shiro.FungeSpace Shiro.IP
01:06:54 <elliott> Shiro.Monad (./Shiro/Monad.hs)
01:06:55 <elliott> imports: Shiro.Fingerprint[boot]
01:06:57 <elliott> Shiro.IP Shiro.FungeSpace
01:06:58 <elliott> Shiro.IP (./Shiro/IP.hs)
01:07:01 <elliott> imports: Shiro.Fingerprint
01:07:03 <elliott> Shiro.FungeSpace (./Shiro/FungeSpace.hs)
01:07:05 <elliott> imports: Shiro.IP
01:07:06 <elliott> Failed, modules loaded: Shiro.Value, Shiro.Stack.
01:07:09 <elliott> quintopia: Mutually recursive modules despite just writing an hs-boot file to stop that.
01:07:39 <quintopia> !bfjoust slowermonorail (>+>-)*2(+)*20>(-)*20>+>->++>([(..-)*20[+]]>)*20
01:08:01 <EgoBot> Score for quintopia_slowermonorail: 25.4
01:08:13 <quintopia> a slight improvement i think...
01:08:32 <quintopia> oh, no, my mistake.
01:08:58 <elliott> I'd just like to share this compiler error with you all: http://hpaste.org/43798/aaaargh
01:09:32 <quintopia> !bfjoust slowermonorail (>+>-)*2(+)*20>>+>->++>([(..-)*20[+]]>)*20
01:10:02 <EgoBot> Score for quintopia_slowermonorail: 22.8
01:10:02 <quintopia> !bfjoust slowermonorail (>+>-)*2>(+)*20>>+>->++>([(..-)*20[+]]>)*20
01:11:18 <EgoBot> Score for quintopia_slowermonorail: 24.5
01:13:50 <quintopia> !bfjoust slowermonorail (>+>-)*2>>>+>->++>([(..-)*20[+]]>)*20
01:14:22 <EgoBot> Score for quintopia_slowermonorail: 26.2
01:14:34 <quintopia> huh
01:15:08 <quintopia> !bfjoust slowermonorail (>+>-)*2>(+)*39>(-)*39>+>->++>([(..-)*20[+]]>)*20
01:16:44 <EgoBot> Score for quintopia_slowermonorail: 24.3
01:18:49 <quintopia> !bfjoust slowermonorail (>+>-)*2>>>>>++<-<+<(+)*39<(-)*39>>>>([(..-)*20[+]]>)*20
01:19:31 -!- nescience has changed nick to myndzi.
01:19:40 <EgoBot> Score for quintopia_slowermonorail: 20.2
01:21:29 -!- cal153 has joined.
01:21:43 <quintopia> !bfjoust slowermonorail >>>>>>>>++++>---->([(..-)*20[+]]>)*20
01:22:15 <EgoBot> Score for quintopia_slowermonorail: 16.8
01:22:53 <quintopia> !bfjoust slowermonorail >->+>>>>>>++++>---->([(..-)*20[+]]>)*20
01:23:37 <EgoBot> Score for quintopia_slowermonorail: 22.8
01:24:55 <quintopia> !bfjoust slowermonorail (>->+)*2>>>>++++>---->([(..-)*20[+]]>)*20
01:25:23 <EgoBot> Score for quintopia_slowermonorail: 26.0
01:25:43 <myndzi> !bfjoust slowrush >(+)*19>(-)*19(>++++++>------)*1>+>->->+(>[[-(+)*22[-]]+>[+(-)*22[+]]->]+)*21
01:25:58 <quintopia> !bfjoust slowermonorail (>->+)*3>>++++>---->([(..-)*20[+]]>)*20
01:26:27 <Sgeo> Maybe I should try making some that target specific programs
01:26:33 <Sgeo> What's the linky?
01:26:48 <quintopia> http://codu.org/eso/bfjoust/in_egobot/
01:27:03 <EgoBot> Score for quintopia_slowermonorail: 28.2
01:27:03 <EgoBot> Score for myndzi_slowrush: 47.9
01:27:12 <quintopia> hmmm
01:27:20 <quintopia> apparently more decoys = higher score
01:27:21 <myndzi> huh, it put them both in the breakdown,txt
01:27:23 <quintopia> soooooo
01:27:28 <quintopia> yeah it does that
01:27:36 <myndzi> confusing, i wanted a report of that program
01:27:37 <myndzi> :|
01:27:51 <quintopia> !bfjoust slowermonorail (>->+)*3>>++++>---->([(..-)*20[+]]+>)*20
01:28:01 <Sgeo> Bleh, I'd have to actually read the code for this
01:28:05 <quintopia> all programs currently available go in the breakdown.txt
01:28:17 <quintopia> the entire tournament
01:28:20 <myndzi> i mean, it was processing both our programs at once
01:28:25 <EgoBot> Score for quintopia_slowermonorail: 27.8
01:28:27 <myndzi> and making breakdown.txt for both of them at the same time
01:28:31 <quintopia> because both were currently available
01:28:33 <myndzi> instead of only one of them vs everything on the hill
01:29:03 <quintopia> it would have to run two separate reports then!
01:29:27 <myndzi> eh, i know WHY i was just complaining that you ruined my report ;)
01:29:37 <Gregor> The harpsichord solo is in fact 38 seconds long :P
01:29:44 <quintopia> no i didn't! you get to see how we compare!
01:30:42 <quintopia> !bfjoust slowermonorail (>->+)*3>>++++>---->([(..-)*20[+]]+>[(..-)*20[+]]->)*10
01:31:19 <elliott> Gregor: Now remove other instruments
01:31:26 <Gregor> elliott: NEVER
01:31:37 <quintopia> myndzi: is it unwise to leave a gap in the decoy chain like that?
01:31:37 <Gregor> elliott: This is dirge-for-accordion-plus-harpsichord-now btw :P
01:31:47 <elliott> Gregor: You forgot the organ.
01:31:51 <myndzi> doesn't really matter
01:31:57 <Gregor> elliott: Organs can suck my organ
01:31:58 <EgoBot> Score for quintopia_slowermonorail: 25.6
01:32:01 <myndzi> it was to throw something off surely
01:32:04 <elliott> I'll suck YO-- wait.
01:32:10 <myndzi> lol
01:32:26 <myndzi> slowrush beats wiggle now
01:32:45 <myndzi> i didn't want to get in an optimize war with him so i let him have #1 way back
01:32:51 <myndzi> but now there's no excuse to let him keep beating me
01:32:51 <myndzi> ;p
01:32:59 <quintopia> !bfjoust slowermonorail (>->+)*3>->++++>---->([(..-)*20[+]]+>[(..-)*20[+]]->)*10
01:33:05 <quintopia> we'll find out....
01:33:43 <EgoBot> Score for quintopia_slowermonorail: 26.2
01:33:56 -!- copumpkin has joined.
01:34:00 <quintopia> score improves slightly!
01:34:16 <quintopia> myndzi: answer: leave no gaps near homebase
01:34:28 <myndzi> that's not really true necessarily
01:34:49 <quintopia> it's true for the current hill
01:35:03 <myndzi> you don't know why your score improved, it likely has very little to do with decoys
01:35:06 <elliott> !bfjoust >>>(-)*10000
01:35:06 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
01:35:14 <elliott> !bfjoust i_will_defend_not_my_flag_to_the_death >>>(-)*10000
01:35:32 <myndzi> it's as likely to be a timing difference as anything else
01:35:35 <myndzi> for such a small increase
01:35:39 <quintopia> ah
01:35:41 <myndzi> also i've been testing programs in private
01:35:48 <myndzi> so as not to spam the channel
01:35:50 <elliott> This is actually the start of a good strategy :P
01:35:53 <elliott> myndzi: no do it in-channel
01:35:55 <elliott> we like to see
01:36:05 <myndzi> decoys have never really made a huge difference in score
01:36:07 <EgoBot> Score for elliott_i_will_defend_not_my_flag_to_the_death: 2.9
01:36:09 <quintopia> yeah, i don't want to do that because then no one knows whena program is currently running
01:36:11 <myndzi> i mean, tweaking the decoys
01:36:28 <myndzi> unless you are doing it specifically to target some program and it nets you a win over that program that is worth it
01:36:50 <quintopia> well, i wouldn't know
01:36:56 <quintopia> i'm new to this form of procrastination
01:36:57 <myndzi> having a gap in the middle of the decoys is pretty meaningless, it's about the same as having one less decoy at the end
01:36:57 <elliott> @hoogle (k,a) -> Map k a -> Map k a
01:36:57 <lambdabot> Data.Graph.Inductive.Graph delEdge :: DynGraph gr => Edge -> gr a b -> gr a b
01:36:57 <lambdabot> Data.Array.IArray (//) :: (IArray a e, Ix i) => a i e -> [(i, e)] -> a i e
01:36:58 <lambdabot> Data.Graph.Inductive.Graph insNode :: DynGraph gr => LNode a -> gr a b -> gr a b
01:37:06 <quintopia> it's as deadly as any other procrastination
01:37:19 <myndzi> since most programs will either not care about the placement of the decoys or they'll just skip blank places fairly quickly
01:37:55 <elliott> You know what's awesome?
01:37:56 <elliott> Bricks.
01:37:59 <elliott> Bricks are awesome.
01:38:15 <Gregor> They taste EXACTLY LIKE BRICKS.
01:39:05 <quintopia> anyway, i was gonna put slowermonorail back like i had it...
01:39:33 <quintopia> !bfjoust slowermonorail (>->+)*3>->++++>---->([(..-)*20[+]]>)*20
01:39:46 <quintopia> or close to, anyways
01:40:07 <EgoBot> Score for quintopia_slowermonorail: 25.4
01:40:16 <quintopia> bah
01:40:45 <quintopia> oh
01:40:50 <quintopia> that wasn't the right one
01:41:03 <quintopia> !bfjoust slowermonorail (>->+)*3>->++++>---->([(..-)*20[+]]+>)*20
01:41:33 <EgoBot> Score for quintopia_slowermonorail: 26.3
01:41:50 <quintopia> better
01:41:56 <quintopia> CARRY ON
01:41:59 <Gregor> http://codu.org/tmp/dirge-for-you.ogg EPIC HARPSICHORD SOLO
01:42:32 <quintopia> myndzi: shudder still does far better than it has a right to :/
01:43:26 <quintopia> Gregor: you said it was a solo! :P
01:43:43 <Gregor> <Gregor> elliott: By "solo" I do not mean "playing alone", I mean "primary instrument" :P
01:45:03 <quintopia> this is...not really what solo means? solo means ... a cadenza :P (it may also mean a single instrument from a given section playing, ya, but...not as commonly)
01:45:22 <elliott> Gregor: make it a solo.
01:45:31 <quintopia> elliott: shh.
01:45:35 <elliott> quintopia: I dunno, guitar solos usually have other instruments too :P
01:45:41 <elliott> But this ... is not a solo, yeah.
01:45:55 <Gregor> I will kill you both.
01:45:56 <Gregor> With fire.
01:46:25 <quintopia> i will kill you back with SAX AND VIOLINS
01:47:58 <elliott> Holy shit, this might actually work.
01:48:02 <elliott> SEXYMAXIMUM
01:48:06 <elliott> Aww man, and it might not.
01:48:45 <Gregor> ?
01:49:05 <myndzi> !bfjoust butter (>[(-.)*500-(-.)*500(+.)*500+(+.)*500])*30
01:49:39 <Gregor> I predict low score.
01:49:48 <myndzi> it only has one purpose ;)
01:49:48 <EgoBot> Score for myndzi_butter: 19.7
01:50:13 <myndzi> i didn't expect it to score that high, but it did what it was supposed to!
01:50:23 <quintopia> Gregor: thanks for augmenting the hill. it seems to encourage variety and multilateral strategies.
01:50:35 <quintopia> what was it supposed to do?
01:50:49 <Gregor> quintopia: No, I think that the fact that people suddenly started paying attention encourages variety and multilateral strategies.
01:50:50 <myndzi> myndzi_butter.bfjoust vs quintopia_one_o_them_shudder_thangs.bfjoust:
01:50:51 <myndzi> <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<<
01:50:51 <myndzi> myndzi_butter.bfjoust wins
01:51:04 <myndzi> myndzi_butter.bfjoust vs quintopia_one_o_them_shudder_thangs.bfjoust:
01:51:04 <myndzi> <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<<
01:51:04 <myndzi> myndzi_butter.bfjoust wins
01:51:10 <myndzi> eh, the other one too
01:51:12 <myndzi> didn't copy to clipboard
01:51:19 <myndzi> anyway, i didn't bother to think about the timing
01:51:23 <myndzi> maybe i'll make it a little more robust
01:51:26 <quintopia> Gregor: of course. and people care more because the hill is bigger >_>
01:51:31 <quintopia> myndzi: the other one is identical
01:51:43 <myndzi> i meant to copy its name though
01:51:52 <myndzi> it's not identical in appearance, but identical in functionality, yeah
01:52:05 <elliott> Vorpal: ping
01:52:35 <elliott> argh
01:52:53 <quintopia> the only difference iirc, is he used "1000000" while I used "384000"...but any constant over 384000/3 results in a program behaving identically
01:53:16 <Gregor> !bfjoust turtle_rescue_squad (.)*1000(>)*9(>[[-]..>>[-]..])
01:53:16 <myndzi> like i said
01:53:23 <myndzi> different in appearance but not function
01:53:30 <Gregor> Errr, that's borked X-D
01:53:39 <EgoBot> Score for Gregor_turtle_rescue_squad: 0.0
01:53:44 <myndzi> haha
01:53:47 <myndzi> !bfjoust butter (>[(-.)*128-(-.)*128(+.)*128+(+.)*128>])*30
01:53:51 <Gregor> !bfjoust turtle_rescue_squad (.)*1000(>)*9(>[[-]..>>[-]..])*1000
01:53:53 <Gregor> Whoops
01:53:55 <quintopia> myndzi: any program that uses offset clears also beats shudders
01:54:06 <EgoBot> Score for myndzi_butter: 33.9
01:54:09 <myndzi> i almost get positive points
01:54:10 <EgoBot> Score for Gregor_turtle_rescue_squad: 21.3
01:54:18 <quintopia> myndzi: because they feature [blahblah[-]]
01:54:25 <elliott> :t readBase
01:54:26 <lambdabot> Not in scope: `readBase'
01:54:46 <elliott> :t foldl (\x y -> (x*256)+y)
01:54:48 <lambdabot> forall b. (Num b) => b -> [b] -> b
01:54:48 <myndzi> how about a decoy just for lulz
01:54:49 <elliott> :t foldl (\x y -> (x*256)+y) 0
01:54:50 <lambdabot> forall b. (Num b) => [b] -> b
01:54:54 <Gregor> !bfjoust turtle_rescue_squad (.)*1000(>)*9(>[[-]..>(>[-])*20])*21
01:55:04 <quintopia> Gregor: love the name
01:55:12 <EgoBot> Score for Gregor_turtle_rescue_squad: 18.2
01:55:18 <Gregor> Well, that's worse ...
01:55:21 <myndzi> !bfjoust butter -->+++++>+++++>----->----->+>->>(>[(-.)*128-(-.)*128(+.)*128+(+.)*128>])*30
01:55:30 -!- augur has changed nick to augur[afk].
01:55:52 <EgoBot> Score for myndzi_butter: 39.9
01:55:56 <myndzi> hoho
01:55:56 <Gregor> !bfjoust turtle_rescue_squad (>+>-<<)*250(>)*9(>[[-]..>>[-]..])*1000
01:55:57 <quintopia> wow
01:56:06 <myndzi> positive points!
01:56:08 <quintopia> who'dathunk that'd work so well
01:56:10 <Gregor> Why do I keep putting *1000 on something which by definition can't happen more than *20 ...
01:56:18 <myndzi> i woulda thunk :)
01:56:28 <EgoBot> Score for Gregor_turtle_rescue_squad: 19.0
01:56:33 <myndzi> it's not all that different in some ways from careless
01:56:35 <Gregor> Bleh, still worse X-P
01:56:52 <quintopia> yeah it's pretty much a slowrush
01:56:56 <myndzi> and i made it beat careless too
01:57:02 <quintopia> ha
01:57:02 <myndzi> nah, it doesn't really loop like slowrush does
01:57:13 <quintopia> yeah
01:57:15 <quintopia> but it's a rush
01:57:17 <quintopia> that's slow
01:57:23 <myndzi> it's not all that slow
01:57:26 <Gregor> !bfjoust turtle_rescue_squad -(>)*5(>+>-<<)*250(>)*4(>[[-]..>>[-]..])*21
01:57:31 <myndzi> it always advances
01:57:41 <myndzi> and it has a fixed loop cycle
01:57:45 <EgoBot> Score for Gregor_turtle_rescue_squad: 21.7
01:57:48 <elliott> Gregor: What's the maximum tape cell value in BF Joust?
01:57:50 <myndzi> i could probably make the loop cycle smaller too
01:57:55 <quintopia> a very long fixed loop cycle
01:58:00 <Gregor> elliott: 255, it's 8-bit
01:58:06 <myndzi> i wonder what happens if i do
01:58:07 <myndzi> !bfjoust butter -->+++++>+++++>----->----->+>->>(>[(-.)*128(+.)*128>])*30
01:58:22 <EgoBot> Score for myndzi_butter: 32.8
01:58:27 <myndzi> mk
01:58:35 <elliott> !bfjoust die_hard >>>>>((-)*127[(+)*10]<)*4(--+)*10000
01:58:45 <myndzi> fuck
01:58:49 <myndzi> just as i clicked it
01:59:05 <elliott> :D
01:59:15 <myndzi> !bfjoust butter -->+++++>+++++>----->----->+>->>(>[(-.)*128(.-)*128>])*30
02:00:16 <elliott> <interactive>:1:4:
02:00:17 <elliott> My brain just exploded.
02:00:17 <elliott> I can't handle pattern bindings for existential or GADT data constructors.
02:00:17 <elliott> Instead, use a case-expression, or do-notation, to unpack the constructor.
02:00:17 <elliott> In the binding group for
02:00:17 <elliott> FP foo
02:00:19 <elliott> In a pattern binding: FP foo = fingerprints Map.! 1314212940
02:00:21 <elliott> I'm glad I use a compiler whose brain can explode.
02:00:33 <elliott> (And that is still literate after this.)
02:00:37 <myndzi> right, well, it's going back the way it was :P
02:00:43 <EgoBot> Score for myndzi_butter: 35.6
02:00:43 <EgoBot> Score for elliott_die_hard: 1.7
02:00:47 <myndzi> i don't feel like optimizing its timing against shudder
02:00:47 <elliott> 1.7????
02:00:49 <elliott> but that was awesome
02:00:54 <elliott> why didn't that work
02:01:00 <myndzi> !bfjoust butter -->+++++>+++++>----->----->+>->>(>[(-.)*128-(-.)*128(+.)*128+(+.)*128>])*30
02:01:01 <elliott> someone link me to breakdown :P
02:01:02 <elliott> argh
02:01:03 <elliott> fuck you :D
02:01:06 <myndzi> OWNED
02:01:15 <EgoBot> Score for myndzi_butter: 38.8
02:01:16 <myndzi> got you back ;)
02:02:01 <elliott> !bfjoust die_hard >>>>>((-)*127(-)*30<)*4(--+)*10000
02:02:06 <myndzi> my damn test program is still on there haha
02:02:09 <myndzi> i have no idea why
02:02:21 <myndzi> everyone else seems to be able to nuke their programs but nooo not me
02:02:38 <Gregor> mycroftiv: Probably it has a problem with \
02:02:48 <myndzi> ahhh, maybe so
02:02:55 <myndzi> can you manually remove it?
02:03:02 <elliott> !bfjoust die\really\hard >>>>>((-)*127(-)*30<)*4(--+)*10000
02:03:04 <elliott> >:D
02:03:12 <myndzi> :rolleyes:
02:03:12 <EgoBot> Score for elliott_die_hard: 1.7
02:03:25 <elliott> !bfjoust \ <
02:03:30 <quintopia> i'm at least a bit happier now that the shudder isn't my top performer
02:03:50 <quintopia> even though i don't have any great performers :P
02:04:22 <myndzi> .. !bfjoust in_egobot/.hg/dirstate lolz<
02:04:31 <elliott> Inferred type is less polymorphic than expected
02:04:31 <elliott> Quantified type variable `fp' escapes
02:04:31 <elliott> When checking an existential match that binds
02:04:31 <elliott> x :: fp
02:04:32 <elliott> argh
02:04:37 <EgoBot> Score for elliott_die\really\hard: 1.9
02:04:37 <EgoBot> Score for elliott_\: 0.0
02:04:43 <elliott> :D
02:04:54 <elliott> !bfjoust in_egobot \\\\\\\\\\\\\\\\\\\\\\\\\\ //////////////////////////////////////////////\\\\\\\\\///////
02:04:59 <elliott> oops
02:05:00 <myndzi> at least they didn't make it on
02:05:04 <myndzi> :)
02:05:07 <elliott> darn :D
02:05:08 <myndzi> 'cause UFAIL
02:05:21 <elliott> !bfjoust \ [>[-]+]
02:05:45 <Gregor> Heh, I accidentally explicitly ALLOWED \ instead of disallowing it :P
02:05:51 <myndzi> nice.
02:05:55 <myndzi> gotta love that!
02:06:01 <myndzi> be sure about / too
02:06:08 <EgoBot> Score for elliott_in_egobot: 7.0
02:06:08 <EgoBot> Score for elliott_\: 11.6
02:06:28 <quintopia> myndzi: is it possible to make a program that never draws against itself in any configuration (although it obviously has to draw itself across all configs)?
02:06:36 <elliott> wow it works
02:06:39 <Gregor> !bfjoust test\o\rama <
02:06:40 <elliott> amazeinene
02:06:51 <elliott> quintopia: no because -- and ++ are testd
02:06:53 <elliott> *tested
02:06:55 <EgoBot> Score for Gregor_test_o_rama: 0.0
02:06:58 <myndzi> programs don't play themselves
02:07:14 <quintopia> myndzi: sure they do, if you submit them twice with different names
02:07:21 <quintopia> elliott: i don't understand your reasoning
02:07:29 <myndzi> that's not "themselves" though
02:07:35 <myndzi> that's "a copy" :P
02:07:41 <elliott> quintopia: program vs self = draw
02:07:53 <quintopia> elliott: WHY
02:07:56 <myndzi> anyway, i don't know; there isn't anything like pspace in corewars
02:08:00 <elliott> quintopia: because mathematics!
02:08:04 <myndzi> and everything executes simultaneously
02:08:14 <myndzi> so i would have to say it probably can't happen
02:08:22 <myndzi> there's no way to make program logic diverge
02:08:39 <quintopia> it seems intuitive that it shouldn't happen, but i don't know how to prove it can't happen
02:08:49 <elliott> I think ais523 sketch-proofed it at one point.
02:08:52 <myndzi> i'm not interested in proving it ;)
02:08:57 <elliott> *proved
02:09:13 <quintopia> i guess it would be something like
02:09:18 <quintopia> if they finish differently
02:09:27 <quintopia> there must be a first step where they did something different
02:09:59 <quintopia> but they are in identical states up to that point, so that can't happen
02:10:07 <myndzi> maybe you could take advantage of the fact that every other tape length they can operate on the same cell
02:10:18 <quintopia> no i don't think so
02:10:25 <myndzi> not really sure how that would make a difference though
02:10:35 <myndzi> i mean, you could have them react differently, but they'd both react differently the same
02:10:35 <myndzi> :P
02:11:38 <myndzi> couldn't you prove it by pointing out that you could swap the programs and they would have the same behavior in every configuration?
02:11:42 <quintopia> unrelatedly: is it allowed to create anagol problems where the output is not deterministically determined by the input, or does the server only allow the checker to checker "did i get exactly this output back?"
02:11:53 <myndzi> since they are the same, nothing would change, but if you could make it not a draw in any one configuration, then the side that won would change
02:12:08 <myndzi> that can't happen since because they have the same code, swapping them won't affect anything
02:13:15 <elliott> quintopia: there are no checkers
02:13:19 <elliott> only predefined input output pairs
02:13:56 <quintopia> surely there is at least a checker that checks that you got the right output from each input?
02:14:09 <quintopia> otherwise a human has to do it
02:14:32 <elliott> quintopia: it just checks that the output was the input. it's internal to the anagol code.
02:14:35 <elliott> erm.
02:14:38 <elliott> it literally just runs it with the input
02:14:41 <elliott> and checks the output
02:14:43 <elliott> what else could it do?
02:15:25 <quintopia> that's still a checker
02:15:34 <elliott> not really
02:16:16 <quintopia> if you say it's not, then you are arguing that unit tests don't check anything either...seeing as how that is how most unit tests function
02:16:47 <elliott> quintopia: Well, I don't see how it's something you can give a name other than "the only thing possible".
02:16:54 <elliott> What should it do, check that the outputs match iff one is rot13'd?
02:17:24 <quintopia> it's certainly not the only thing possible. it's just the simplest thing possible.
02:18:11 <quintopia> for instance, you could have a program that checked that a sequence of bits was highly likely to be distributed uniformly at random, but that would be a more complex checker.
02:18:25 <elliott> that wouldn't be a golf checker
02:18:39 <quintopia> that's what i was asking :P
02:18:58 <quintopia> whether anagol allowed arbitrary check algorithms or not
02:19:07 <quintopia> since they are conceivable, i had to ask
02:21:20 <elliott> Sweet, I have NO FUCKING IDEA how ( behaves in the face of multithreading.
02:29:13 <quintopia> Gregor: you see clifford stoll's ted talk?
02:29:24 <Gregor> Nope
02:30:25 <elliott> :t replicateM
02:30:25 <lambdabot> forall (m :: * -> *) a. (Monad m) => Int -> m a -> m [a]
02:34:22 <elliott> Note-to-logreading-self-to-ask-Deewiant: Does ) ever reflect? When?
02:34:28 <elliott> Ah.
02:34:29 <elliott> No, it never does.
02:35:48 -!- nddrylliog has joined.
02:35:55 <elliott> BAD: ) should have reflected trying to unload nonexistent fingerprint 0
02:35:57 <elliott> I'm not sure that's true!
02:36:01 <elliott> "The corresponding ) "Unload Semantics" instruction unloads the semantics for a given fingerprint from any or all of the instructions A to Z (even if that fingerprint had never been loaded before). It pops a count and builds a fingerprint in exactly the same way."
02:36:02 <elliott> But okay...
02:36:26 <elliott> hi nddrylliog, i'm implementing funge-98
02:36:44 <nddrylliog> elliott, ohai! I will collapse soon. but good news :D has anyone implemented it yet?
02:36:50 <elliott> collapse?
02:37:07 <Sgeo> nddrylliog is secretly a house of cards.
02:37:10 <elliott> also, yes; although, it took eight to nine years from its creation to the first time anyone implemented it correctly
02:37:12 <elliott> and that's not for lack of trying
02:37:58 <elliott> Now I don't know whether fingerprint instructions are per-IP or not. *sigh* TODO: Ask Deewiant.
02:38:21 <Sgeo> Shouldn't you be asking cpressey?
02:38:23 <elliott> Totals grouped by language (dominant language first):
02:38:23 <elliott> haskell: 762 (100.00%)
02:38:23 <elliott> Man, it's grown a lot today.
02:38:26 <elliott> It was, what, 400 lines before?
02:38:38 <elliott> Sgeo: Deewiant is the one who wrote the first compliant implementation, the only comprehensive and correct test suite...
02:38:48 <elliott> and cpressey himself responds to most Funge-98 questions with "Hell if I know".
02:39:42 <Sgeo> Oh, I misread you as saying that you will be the first to make a correct implementation
02:39:53 <elliott> No. There are... four, I believe.
02:40:02 <elliott> CCBI, RC/Funge, cfunge, and efunge.
02:40:06 * Sgeo should learn to math
02:40:07 <quintopia> Gregor: http://www.youtube.com/watch?v=Gj8IA6xOpSk
02:40:11 <elliott> PyFunge isn't bad either, I think.
02:40:17 <elliott> Oh, wait.
02:40:18 <nddrylliog> Sgeo, "collapse" is just today's pretty word for "pass out"
02:40:19 <elliott> HsFunge.
02:40:21 <elliott> Is compliant.
02:40:37 <elliott> nddrylliog: Surprisingly literate for someone on the verge of passing out.
02:41:35 <nddrylliog> elliott, surprisingly, and according to my various sleep schedules fuckedupery experiments, literacy isn't the first thing that goes out
02:41:50 <elliott> nddrylliog: Maybe you should stop fuckeduperying your sleep schedule :P
02:42:33 <Sgeo> nddrylliog is turning into me!
02:42:54 <elliott> No.
02:42:55 <elliott> No he isn't.
02:43:14 <nddrylliog> elliott, oh no, it's the perfect recipe to spice up an otherwise boring life - the downside is that restraint is actually the first thing to go, which means I'll have to avoid whichever friends of mine were present tonight, I think
02:43:36 <elliott> I get the feeling that you're really happy nddrylliog :P
02:43:58 * Sgeo pukes on IE
02:44:14 <elliott> ...Dude, why do you even come into contact with IE?
02:44:18 <elliott> You have absolutely no reason to.
02:44:19 <nddrylliog> elliott, I can see how one could think that. I'm surprisingly drugfree though
02:44:26 <Sgeo> farmingdale.edu doesn't work in Chrome
02:44:28 <elliott> nddrylliog: It was what some of us call sarcasm.
02:44:35 <Sgeo> And I have no idea why
02:44:42 <elliott> Sgeo: If you transferred to a real university that problem would disappear :P
02:44:50 <elliott> Sgeo: http://www.farmingdale.edu/ works for me.
02:44:55 <Sgeo> Also, Cybertown, when I want to visit
02:45:06 <elliott> Fails without www. because, you know, your college sucks.
02:45:18 <elliott> "FARMINGDALE STATE NAMED FIFTH MOST SAFE COLLEGE IN THE UNITED STATES BY THE DAILY BEAST" ;; well that's an achievement.
02:45:21 <elliott> FIFTH safest!
02:45:59 <Sgeo> Even www.farmingdale.edu doesn't work for me in Chrome
02:46:15 <nddrylliog> Sgeo, failed to load the first time (blank page) in chrome, reloaded, now everything's fine
02:46:17 <Sgeo> Ctrl-Shift-R made it work
02:46:27 <Sgeo> Bizarre
02:46:41 <nddrylliog> well apart from the fact that some people actually put the idea of naming a school with an anagram of "farming deal" into practice
02:46:58 <Sgeo> nddrylliog, it's the name of the area
02:47:03 <elliott> nddrylliog: writing this has made me reach a stunning conclusion.
02:47:06 <elliott> Haskell is awesome.
02:47:09 <elliott> I know: i'm shocked too.
02:47:19 <Sgeo> elliott, Atomo is written in Haskell
02:47:31 <elliott> Starting to regret taking Sgeo off ignore.
02:47:53 <Sgeo> eeep
02:48:29 <nddrylliog> elliott, if Haskell is the only mainstream language that has learned *anything* from dependent types it's well enough to qualify for "awesome" as far as I'm concerned
02:49:22 <elliott> nddrylliog: Haha, I have some Dynamic in this (basically opaque runtime values that you can cast to another type and if the type is the type they started with, it succeeds, otherwise it fails and you get to handle that) because the type system wasn't quite enough to encode what I wanted
02:49:39 <elliott> (For fingerprints, the Funge-98 library/language-extension mechanism. And yes, there are many.)
02:49:43 <elliott> (Possibly dozens.)
02:49:53 <elliott> ^source
02:49:53 <fungot> http://git.zem.fi/fungot/blob/HEAD:/fungot.b98
02:49:56 <elliott> End goal is to be able to run ^ :P
02:51:01 -!- augur[afk] has quit (Remote host closed the connection).
02:52:02 <nddrylliog> ah, Dynamic typing in Haskell, wonderful
02:52:07 <nddrylliog> what will be your next goal? static typing in Ruby?
02:52:31 <elliott> nddrylliog: :-D
02:52:42 <elliott> nddrylliog: The great thing about Haskell is that it subsumes things like dynamic typing and imperative programming.
02:53:11 <elliott> And it can even "embed" them: although my implementation uses Data.Dynamic, outside of the internals, everything else sees it as strongly typed.
02:53:30 <nddrylliog> man, it's a felony to use words such as "subsume" at 4:13 in the "morning"
02:53:55 <elliott> *3:13
02:53:57 <elliott> Darn Swiss.
02:54:05 <nddrylliog> oh my god, "subsumer" is actually a french verb as well
02:54:11 <elliott> :-D
02:54:13 <elliott> Darn French.
02:54:15 <nddrylliog> "to take as a premise"
02:54:19 <nddrylliog> awww.
02:54:36 <nddrylliog> I just saw Primer. Anyone *hasn't* seen it yet?
02:55:13 <elliott> I haven't! But it's on my Fiction Backlog.
02:55:24 <Sgeo> nddrylliog, I haven't
02:56:31 <nddrylliog> ha! I would've thought that there would be a cult devoted to it on #esoteric
02:56:38 <nddrylliog> Sons, I'm disappoint
02:57:08 <elliott> I doubt I will ever beat CCBI2 on Fungicide...
02:57:21 <zzo38> Have any of you people in here played Yomi card game?
02:57:26 <elliott> Mostly because wrapping in axis-aligned bounding boxes by solving Diophantines doesn't sound like my idea of fun.
02:57:33 <elliott> OK, it does, but it doesn't sound like my idea of something I could actually implement.
03:00:38 <elliott> Gregor: http://www.phlamethrower.co.uk/riscos/sdcreate.php Dude, run RISC OS on your Pandora.
03:00:42 <elliott> ANYWAY
03:00:44 <elliott> I'm sleeping now. ->
03:00:47 -!- elliott has quit (Quit: Leaving).
03:08:29 -!- amca has quit (Quit: Farewell).
03:10:48 -!- augur[afk] has joined.
03:14:50 <Gregor> http://lonelydino.com/cache/347.png The real subtext behind all Dinosaur Comics.
03:16:26 -!- nddrylliog has quit (Ping timeout: 240 seconds).
03:20:07 -!- ndd has joined.
03:20:25 -!- ndd has changed nick to nddrylliog.
03:27:51 <quintopia> Gregor: hey, instead of always putting the last bfj breakdown in a single file, can you generate a breakdown digest for each program? and you could still cache them and update only the lines that need updating and this is way too much to ask of you innit?
03:28:19 <Gregor> It's doable, I just don't want to :P
03:28:25 <Gregor> The difficulty is just that it's all cached.
03:30:38 <quintopia> okay fine, how about at least making it output to PROGNAME_brkdn.txt and don't worry about updating them when they get out of date? is that easy?
03:31:05 -!- azaq23 has quit (Quit: Leaving.).
03:31:15 <quintopia> that would at least get rid of the issue of having your program results disappearing as soon as someone else adds another program
03:32:49 <Gregor> I'll do that ... uhh, tomorrow? Doing something else right now and don't want to context switch :P
04:04:23 <quintopia> in the future you can add more cache to your working memory, and be able to do context switches without invalidating and mental cache lines
04:04:23 <quintopia> *any
04:04:52 -!- myndzi has quit (*.net *.split).
04:04:53 -!- Mannerisky has quit (*.net *.split).
04:04:53 -!- miekko has quit (*.net *.split).
04:04:53 -!- Herobrine has quit (*.net *.split).
04:04:54 -!- dbc has quit (*.net *.split).
04:04:55 -!- aloril has quit (*.net *.split).
04:04:55 -!- coppro has quit (*.net *.split).
04:04:56 -!- SimonRC has quit (*.net *.split).
04:04:56 -!- rodgort has quit (*.net *.split).
04:04:56 -!- mtve has quit (*.net *.split).
04:04:57 -!- cal153 has quit (*.net *.split).
04:04:57 -!- poiuy_qwert has quit (*.net *.split).
04:04:57 -!- pikhq has quit (*.net *.split).
04:04:57 -!- tswett has quit (*.net *.split).
04:04:58 -!- olsner has quit (*.net *.split).
04:04:58 -!- lifthrasiir has quit (*.net *.split).
04:04:58 -!- shachaf has quit (*.net *.split).
04:04:58 -!- Gregor has quit (*.net *.split).
04:04:58 -!- Ilari_antrcomp has quit (*.net *.split).
04:04:58 -!- Zuu has quit (*.net *.split).
04:04:58 -!- variable has quit (*.net *.split).
04:04:58 -!- Slereah has quit (*.net *.split).
04:05:45 -!- cal153 has joined.
04:05:45 -!- Ilari_antrcomp has joined.
04:05:45 -!- poiuy_qwert has joined.
04:05:45 -!- pikhq has joined.
04:05:45 -!- aloril has joined.
04:05:45 -!- myndzi has joined.
04:05:45 -!- Zuu has joined.
04:05:45 -!- variable has joined.
04:05:45 -!- Slereah has joined.
04:05:45 -!- Mannerisky has joined.
04:05:45 -!- tswett has joined.
04:05:45 -!- SimonRC has joined.
04:05:45 -!- rodgort has joined.
04:05:45 -!- coppro has joined.
04:05:45 -!- miekko has joined.
04:05:45 -!- dbc has joined.
04:05:45 -!- olsner has joined.
04:05:45 -!- mtve has joined.
04:05:45 -!- Gregor has joined.
04:05:45 -!- shachaf has joined.
04:05:45 -!- Herobrine has joined.
04:05:45 -!- lifthrasiir has joined.
04:05:45 -!- Ilari has quit (*.net *.split).
04:05:45 -!- Wamanuz5 has quit (*.net *.split).
04:05:45 -!- Vorpal has quit (*.net *.split).
04:05:45 -!- fungot has quit (*.net *.split).
04:08:17 <zzo38> Is this working?
04:08:31 <zzo38> [message test]
04:09:09 -!- pikhq has quit (Write error: Broken pipe).
04:09:10 -!- pikhq_ has joined.
04:09:14 -!- augur[afk] has quit (Ping timeout: 250 seconds).
04:09:22 -!- Ilari has joined.
04:09:22 -!- Wamanuz5 has joined.
04:09:22 -!- Vorpal has joined.
04:09:22 -!- fungot has joined.
04:09:41 <zzo38> ^source
04:09:56 <fungot> http://git.zem.fi/fungot/blob/HEAD:/fungot.b98
04:15:39 <quintopia> zzo38:
04:15:59 <quintopia> i got split onto the smaller half i think
04:16:41 <zzo38> quintopia: You did? What do you have to do about it?
04:18:38 <quintopia> oh nothing
04:18:40 <zzo38> For your information, I have received TIME responses from the following: nddylliog,fizzie,Sgeo,joo,sebbu,Zuu,clog,taotree,pingveno,copumpkin,Slereah,Leonidas,ineiros,variable,quintopia,Mannerisky,aloril,dbc,Deewiant,jix,poiuy_qwert,cal153,fizzie,SimonRC,olsner,miekko,mycroftiv,pikhq_,shachaf,tswett,Gregor,Gregor,lifthrasiir
04:18:48 <quintopia> the split ended pretty much instantly
04:18:52 <zzo38> (I did get two responses from Gregor)
04:23:02 <quintopia> wat
04:23:31 <quintopia> are you gonna kick everyone that doesn't? :P
04:23:37 <zzo38> No.
04:24:10 <zzo38> I am just wondering why there isn't many message in here at this time??
04:24:15 -!- pikhq_ has changed nick to pikhq.
04:24:26 <zzo38> O, that's why.
04:24:42 <pikhq> quintopia: The split lagged me out somehow.
04:25:30 <quintopia> okay
04:26:07 <quintopia> zzo38: because no one is chatting. elliott left, gregor is busy, and the others haven't said anything in an hour anyway
04:26:13 <zzo38> OK
04:26:36 <quintopia> pikhq: is one beer past the ballmer peak?
04:26:40 <quintopia> or not enough?
04:26:45 <pikhq> quintopia: Probably not.
04:29:07 <zzo38> Do you think what I have in TeXnicard so far is good? Any suggestion?
04:29:28 <quintopia> tbh, i haven't tried to use it
04:29:46 <quintopia> i could try to find someone who would want to...
04:29:54 <zzo38> quintopia: Have you looked at any of the source files though?
04:30:32 <quintopia> nope
04:30:37 <zzo38> (Without that, you probably will not be able to use it, since there is no user documentation yet) (But if you can help with making user documentation and those things, that would help good)
04:30:39 <quintopia> it's not really my bag
04:32:42 <zzo38> Do you try to find someone who knows how to (and want to) help with these things?
04:35:35 <zzo38> Also tell me if you have any feature suggestions, in case I might not put it in the first version I will list them in the chapter titled "The Future". (I put a few things there already?)
04:37:15 <quintopia> 'kay
04:37:41 <quintopia> btw, GTAIV minus car tire friction is the MOST HILARIOUS THING I'VE SEEN ALL DAY
04:37:56 -!- augur[afk] has joined.
04:39:00 <zzo38> quintopia: GTAIV? Is that Grand Theft Auto? Is it more difficult when friction is adjusted or removed?
04:39:27 <zzo38> Or is it easier to drive your car since you can do it in any way without resistance?
04:41:39 -!- augur[afk] has changed nick to augur.
04:51:27 <quintopia> zzo38: imagine walking up to a parked car, shooting at it, and having it go flying into the nearest building, bouncing off, and flying back at you
04:52:40 <zzo38> O, so that's what it does.
04:54:03 <quintopia> zzo38: http://www.geek.com/articles/games/grand-theft-auto-iv-without-friction-becomes-carmageddon-20110113/
04:54:25 -!- Sgeo_ has joined.
04:55:21 -!- Sgeo_ has quit (Client Quit).
04:57:02 <zzo38> I made a game once, I put in an option, that if selected, makes it the balls won't stay still! And this makes it more difficult.
04:58:42 <zzo38> quintopia: If there is no friction, can you drive without gasoline in the car?
04:59:50 <Sgeo> This Nickleback song is distinct from the other Nickleback song I know
05:00:06 <pikhq> How improbable.
05:00:14 <zzo38> Sgeo: I never heard of it.
05:00:56 <Sgeo> Photograph and Figured You Out
05:01:56 <quintopia> zzo38: no, you can move without gas yes, but you can't drive, as that implies the ability to steer or control the car
05:02:42 <zzo38> quintopia: Can you save fuel by only turning it on when you want to change direction?
05:03:05 <Ilari> You can't turn without friction. :-)
05:03:15 <quintopia> ...the only way you can change direction is by bouncing off of buildings
05:03:28 <quintopia> and you don't exactly get to decide where you bounce
05:03:49 <zzo38> In that case why do you need fuel?
05:04:14 <quintopia> Sgeo: nickelback had a couple of good songs. I am eternally amused by Animals.
05:04:40 <Sgeo> According to pikhq, they only have one song
05:05:02 <pikhq> Sgeo: s/pikhq/most people/
05:05:04 <zzo38> Can you do some things illegal by purpose to make the police car push your car in the direction you want to move?
05:05:18 <pikhq> Seriously, it's what they're known for.
05:05:35 <quintopia> pikhq: interestingly, Sgeo did not name that song
05:06:12 <quintopia> zzo38: the police car is also a car. it also has no ability to control. did you watch the video i linked?
05:07:03 <zzo38> quintopia: No I watched no video. But of course I know the police car is also a car. But I thought somehow the computer would make it start moving the right way.
05:07:20 <zzo38> If you can use a gun, then can you also use the gun to shoot other cars to make them hit your car to move it in the direction you want?
05:07:21 * Sgeo now hears a nostalgia-inducing Eminem song
05:07:28 <Sgeo> Well, not nostalgia
05:07:32 <Sgeo> Just... memory-inducing
05:07:44 <zzo38> Or can you only use the gun when not in the car?
05:07:46 <Sgeo> I'm pretty glad I'm past that point in my life
05:07:48 <quintopia> yes you can control the cars via shooting at them just right, but it's very difficult.
05:08:06 <quintopia> esp. since once you are in a car you can only shoot one direction
05:08:22 <quintopia> and the car you are in will quickly be flying through the air upside-down
05:08:24 <zzo38> And you have to not run out of ammunition, I guess.
05:08:33 <Sgeo> I'm sure it was an Eminem song that sounded as though it was related to getting banned from Cybertown
05:08:56 <Sgeo> At any rate, this song is surely from a point in my life where I.. might not have been such a good person
05:09:17 <quintopia> now this looks like a job for me
05:09:21 <Sgeo> And I'm shutting up now. This is getting close to things I will not talk about.
05:09:23 <quintopia> so everybody just follow me
05:09:34 <quintopia> cause we need a little controversy
05:09:40 <Sgeo> quintopia, oh, that's the one that sounded like a Cybertown ban
05:09:43 <quintopia> cause it feels so *empty* without me
05:09:58 <Sgeo> Or.. not?
05:10:17 <quintopia> eminem was someone
05:10:21 <quintopia> who made more than 3 songs
05:15:18 -!- calamari has joined.
05:15:28 -!- asiekierka has joined.
05:20:29 -!- calamari has quit (Ping timeout: 276 seconds).
05:33:43 -!- calamari has joined.
05:46:09 -!- calamari has quit (Quit: Leaving).
05:49:27 -!- asiekierka has quit (Read error: Operation timed out).
05:51:36 <zzo38> Can we make Binary Modular SNUSP Golf? If we use four bits for each command, there are 12 commands so we can have 4 metacommands that tell it to skip a number of spaces and go to the next row.
05:52:21 <quintopia> we could. would you want to?
05:53:39 <zzo38> Maybe I might, at some time
06:18:30 <zzo38> ...is that right? *pic|=(0xFF>>b)&~(0xFF>>(b+c));
06:30:25 <quintopia> wat
06:32:41 <zzo38> quintopia: ?
06:35:16 <zzo38> It is a C code, is it not?
06:36:07 <fizzie> From a quick glance, it looks like setting c consecutive bits in a byte, starting from the b'th, counted from MSB.
06:36:58 <zzo38> fizzie: Yes. I am making GF->PBM?
06:39:08 -!- FireFly has joined.
06:42:38 -!- augur has quit (Remote host closed the connection).
06:45:22 <quintopia> oh
06:45:29 <quintopia> so its a bitmask
06:45:38 <quintopia> that selects the bth through b+cth bits
06:45:41 <quintopia> got it
06:45:43 <quintopia> erm
06:45:49 <quintopia> b+c-1th
06:51:54 <Vorpal> <elliott> Vorpal: ping <-- pong
06:58:05 <quintopia> slooooooow
07:00:44 <Vorpal> bbl university
07:04:33 <quintopia> \m/ \m/
07:04:33 <myndzi> `\o/´
07:04:33 <myndzi> |
07:04:33 <myndzi> /`\
07:04:34 <myndzi> (_| |_)
07:05:25 -!- augur has joined.
07:07:49 -!- GreaseMonkey has joined.
07:08:50 <zzo38> I now have sent the changes I made (which includes the C codes I posted here). Is it good?
07:26:42 -!- quintopia has quit (Ping timeout: 240 seconds).
07:37:04 -!- quintopia has joined.
07:37:04 -!- quintopia has quit (Changing host).
07:37:04 -!- quintopia has joined.
07:47:47 -!- FireFly has quit (Quit: swatted to death).
07:48:33 -!- oerjan has joined.
07:48:55 <quintopia> :/
07:50:11 <quintopia> egobot!!!!! :(
07:50:32 <quintopia> `run ps -e | grep report
07:51:35 <quintopia> the world is broken
07:52:18 -!- Mathnerd314 has quit (Ping timeout: 240 seconds).
07:53:02 <HackEgo> 11864 ? 00:00:00 report
07:55:40 <quintopia> wooo!
07:57:18 <oerjan> <elliott__> I blame oerjan for this
07:57:44 <oerjan> wait, you say it put the new IP in the wrong place in the queue? :(
07:57:59 <oerjan> well it _should_ be trivial to fix.
07:59:01 <quintopia> what is the syntax in a regex for "not this string"
07:59:12 <quintopia> aka, match "david" but not "david bowie"
07:59:31 <GreaseMonkey> there's [^t] for "not t"
07:59:35 <oerjan> negative lookahead?
07:59:41 <quintopia> yeah oerjan
07:59:47 <oerjan> well look it up
07:59:52 <quintopia> hmm
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:00:40 * oerjan doesn't remember that stuff
08:04:06 -!- Sgeo has quit (Read error: Connection reset by peer).
08:05:48 <quintopia> (?!) apparently
08:09:13 -!- oerjan has quit (Quit: Reboot).
08:14:58 -!- oerjan has joined.
08:29:06 -!- oerjan has quit (Quit: Dammit now _adobe_ wants a reboot too...).
08:31:15 -!- GreaseMonkey has quit (Quit: ilua).
08:31:56 -!- oerjan has joined.
08:33:23 -!- poiuy_qwert has quit (Ping timeout: 240 seconds).
08:34:18 -!- poiuy_qwert has joined.
08:35:34 <oerjan> !help
08:35:36 <EgoBot> help: General commands: !help, !info, !bf_txtgen. See also !help languages, !help userinterps. You can get help on some commands by typing !help <command>.
08:35:41 <oerjan> !info
08:35:41 <EgoBot> EgoBot is a bot for running programs in esoteric programming languages. If you'd like to add support for your language to EgoBot, check out the source via mercurial at https://codu.org/projects/egobot/hg/ . Cheers and patches (preferably hg bundles) can be sent to Richards@codu.org , PayPal donations can be sent to AKAQuinn@hotmail.com , complaints can be sent to /dev/null
08:41:40 <oerjan> bf joust is written in _perl_? 8D
08:41:49 -!- joo has quit.
08:44:16 -!- cheater- has quit (Ping timeout: 240 seconds).
08:45:27 -!- cheater- has joined.
08:45:51 <quintopia> oerjan: no
08:46:13 <quintopia> it's an amalgam of c, perl, and shell script :P
09:17:14 <zzo38> !help languages
09:17:14 <EgoBot> languages: Esoteric: 1l 2l adjust asm axo bch befunge befunge98 bf bf8 bf16 bf32 boolfuck cintercal clcintercal dimensifuck glass glypho haskell kipple lambda lazyk linguine malbolge pbrain perl qbf rail rhotor sadol sceql trigger udage01 underload unlambda whirl. Competitive: bfjoust fyb. Other: asm c cxx forth sh.
09:17:18 <zzo38> !help userinterps
09:17:18 <EgoBot> userinterps: Users can add interpreters written in any of the languages in !help languages. See !help addinterp, delinterp, show | !userinterps. List interpreters added with !addinterp.
09:18:52 <zzo38> !userinterps
09:18:52 <EgoBot> Installed user interpreters: aol austro b1ff bc bct bfbignum brit brooklyn bypass_ignore bytes chaos chef chiqrsx9p choo cockney ctcp dc decisionengine drawl drome dubya echo eehird ehird fudd funetak google graph gregor he hello id jethro kraut num ook pansy pi pirate plot postmodern postmodern_aoler redneck reverse rimshot rot13 sadbf sfedeesh sffedeesh sffffedeesh sffffffffedeesh simpleacro slashes svedeesh swedish valspeak warez yodawg
09:32:42 <oerjan> quintopia: well i meant the program that actually runs a single duel
09:36:38 <oerjan> now the other repository files aren't loading :(
09:37:53 <oerjan> i cannot say i understand the program, but what is that my $tapemaxel = int(rand(20))+10;
09:38:22 <oerjan> Gregor: ^ ? i thought bfjoust ran duels with all the tape lengths.
09:38:39 <oerjan> !help
09:38:39 <EgoBot> help: General commands: !help, !info, !bf_txtgen. See also !help languages, !help userinterps. You can get help on some commands by typing !help <command>.
09:39:05 <oerjan> hm EgoBot is alive but the repository is not responding.
09:39:17 <oerjan> i guess this is an unlikely time for Gregor to be awake
09:40:35 <oerjan> i had this great idea for an algorithm to parse bfjoust programs efficiently even if the contents of ()* and ({})% don't match... but there is no way i'm trying to write it in perl :D
09:41:06 <zzo38> oerjan: Why?
09:42:20 <oerjan> zzo38: because it involves adding mismatching annotations to the data, and also because it is much easier if i can use laziness from haskell
09:43:05 <oerjan> i.e. it would not be nice to do it with pure string matching, and i'm not proficient enought with the rest of perl.
09:43:16 <oerjan> *enough
09:43:44 <oerjan> oh and of course this is also inspired by this egodeath thing
09:46:48 <oerjan> hm that's funny...
09:48:02 <zzo38> OK
09:48:08 <zzo38> What is this egodeath thing?
09:48:35 <zzo38> And what are the numbers you sent to me?
09:49:04 <oerjan> zzo38: someone made a bf joust program that expands to such size that egobot's interpreter cannot handle it
09:49:10 <oerjan> or only barely
09:49:46 <oerjan> i sent you a ping request, it's for checking irc connectivity. i seem to have a problem reaching the web just now, but irc is fine...
09:50:20 <zzo38> Is it a DNS problem?
09:50:30 <oerjan> hm i also cannot open a new connection to nvg (which i'm irc'ing through)
09:50:47 <oerjan> i guess a DNS problem would be a likely cause...
09:50:49 <zzo38> What is nvg?
09:51:31 <oerjan> zzo38: my old computer club from university, i'm still a member and use it for email, irc, my web page and stuff
09:52:14 <oerjan> (it's a shell account)
09:52:55 <zzo38> Can you connect if you know its IP address?
09:53:23 <oerjan> interesting question. let me try elliott's logs
09:53:47 <oerjan> yes, you are correct. must be DNS then.
09:55:09 <zzo38> Is it 129.241.210.70
09:55:37 <zzo38> (That is the address you are connecting from)
09:56:00 <zzo38> (If the "tyrell." is removed the last octet is 67)
09:56:19 <oerjan> zzo38: that's the right subnet, i recall the 129.241.*. however i don't need a new connection to that right now.
09:56:37 <oerjan> i was more trying to browse the web in general.
09:57:01 <oerjan> you cannot connect to https: via ip, can you? egobot's repository is https.
09:57:13 <oerjan> or maybe i could try.
09:57:28 <oerjan> zzo38: what is the ip for codu.org?
09:57:45 <zzo38> 64.62.173.65
09:58:43 <oerjan> zzo38: ah using the ip and changing https to http worked. thank you!
10:05:04 -!- cheater- has quit (Ping timeout: 240 seconds).
10:11:17 -!- copumpkin has quit (Ping timeout: 240 seconds).
10:11:43 -!- copumpkin has joined.
10:16:08 -!- oerjan has quit (Quit: Trying a rehibernation).
10:19:11 -!- cheater- has joined.
10:19:40 -!- oerjan has joined.
10:20:58 <oerjan> well that didn't help any, had to use that ip to get back on irc
10:23:22 <oerjan> ah the repair option in the control panel worked
10:26:24 <zzo38> Features for future versions of TeXnicard (not any time soon) might be: a database to keep track of cards sold, a full text search for all card sets in the game, and to be able to play the cards on the computer (in rule-enforcing programs).
10:27:49 <zzo38> My idea for making it to playing the cards on the computer, is something like Inform7 and then have it to compile into C codes, or something like that?
10:28:31 <zzo38> Do you know anything of these kind of things?
10:29:29 <oerjan> nope
10:29:59 <zzo38> OK
10:30:52 <zzo38> But do you think these might be good ideas?
10:32:28 <oerjan> sounds good in principle
10:33:00 <oerjan> but i'm not a very practical programmer to be asking
10:33:17 <zzo38> Well, I won't do anything like this quite yet, so it doesn't really matter at this time.
10:44:08 <zzo38> Did you know that Hercule Poirot is mentioned in the index of TeX: The Program?
10:45:58 -!- pingveno has quit (Ping timeout: 276 seconds).
10:47:09 -!- pingveno has joined.
10:49:16 <oerjan> recent xkcd blag might suggest that a Raptor Hobo Badger Narwhal Doctor would be a rare thing.
10:49:56 * oerjan couldn't fit in both Doctor and Zombie without repeating Narwhal
10:51:48 -!- iconmaster has joined.
10:52:53 -!- iconmaster has quit (Client Quit).
11:10:11 <sebbu> zzo38, I was sleeping, thank's for the highlight ;)
11:10:28 <sebbu> (yeah, i just woke up moments ago, and it's 12:30)
11:15:22 -!- aloril has quit (Ping timeout: 265 seconds).
11:27:14 -!- aloril has joined.
11:32:09 <zzo38> sebbu: What highlight?
11:35:14 <sebbu> 7h20 ago
11:36:06 <zzo38> I still don't know what highlight.
11:36:17 <fizzie> Perhaps the CTCP TIME?
11:36:46 <fizzie> That was about 7 hours, 20 minutes ago.
11:37:04 <zzo38> fizzie: I typed that just to see if the net split was causing any problems.
11:39:12 <oerjan> zzo38: it's usually CTCP PING that is used for that (like i did) although that requires some client support to get accurate timing
11:40:42 <oerjan> basically you let the message with the PING be the time it was sent, then the message is sent back and you can subtract the times of return and sending
11:41:01 <fizzie> CTCP DING, says the microwave oven.
11:48:04 <zzo38> (I sent the command to the channel, to ensure that everyone can still receive messages from the channel.)
11:53:57 <sebbu> i often get ? sec from ctcp ping
12:04:25 <oerjan> sebbu: maybe your client is confused about the time format it puts in the ping message? (i don't know if it's standardized across clients; i see no reason why it should be)
12:04:55 <sebbu> no, he highlighted AFTER, for saying the people who answered
12:05:19 <oerjan> sebbu: um i was referring to <sebbu> i often get ? sec from ctcp ping
12:05:30 <sebbu> [13:23:11] * Received a CTCP PING 1297254214 984196 from oerjan
12:06:08 <oerjan> sebbu: yeah and that came back alright giving a result of 0.350 seconds
12:06:58 <sebbu> that's high, i got a third of that on google
12:07:40 <oerjan> ...you don't ping google via irc do you...
12:08:05 <oerjan> ctcp pings presumably have to pass through all the immediate irc servers
12:09:03 <oerjan> and i'd imagine google has servers in france or something
12:09:32 <oerjan> hm...
12:11:54 <oerjan> hm tracerouting www.google.no from here gives quite a number of hops _inside_ google's network
12:16:13 <fizzie> The PING format isn't very standard, no; I've seen at least both "[seconds after 1970]" and "[seconds after 1970] [microseconds]" formats.
12:16:54 <oerjan> i guess that's the latter in mine above
12:17:21 <fizzie> XChat sent "1297205009020833" while irssi did "1297255033 498239" now.
12:17:52 <oerjan> well that looks just like a spacing difference
12:18:05 <fizzie> The one with space doesn't necessarily 0-pad.
12:18:10 <oerjan> anyway, only the client that sent it needs to understand its format
12:18:14 <fizzie> Also since the bouncer sends distributes the replies to both connections, I have:
12:18:17 <fizzie> 14:36 [freenode] CTCP PING reply from : -1297203852425989.-91 seconds
12:18:22 <fizzie> * Ping reply from fizzie: 1297203738.89 second(s)
12:19:02 <oerjan> ...what.
12:20:38 <fizzie> The replies are just messages, so they go to both (simultaneously connected) clients of the bouncer; it doesn't bother tracking which one sent the actual request. (And that'd be a bit brittle too, since you can't really tell which response corresponds to which request.)
12:20:56 <fizzie> (In general, I mean. For PING you sort-of could guess.)
12:21:16 <oerjan> hm.
12:21:42 <zzo38> Is that why I got two responses from Gregor?
12:22:01 <fizzie> It could well be.
12:25:05 <fizzie> The multi-client thing is a bit corner-casey. If I /whois someone in one client, there's a spurious whois-reply in the other; and XChat's periodic NAMES #channel polls (presumably for the away/not-away nick coloring of the nicklist) show up in irssi too.
12:25:14 <oerjan> Gregor: dammit hg repository and it's horizontal scrollbar placement...
12:25:27 <oerjan> *repository browser
12:26:06 <oerjan> utterly useless
12:38:07 -!- BeholdMyGlory has joined.
12:50:12 -!- oerjan has quit (Quit: leaving).
12:56:27 -!- augur has quit (Remote host closed the connection).
13:22:52 <Gregor> 6 °F
13:22:53 <Gregor> Feels Like -1 °F
13:23:29 <Gregor> The HIGH today is 11 X_X
13:25:10 <Gregor> (That's -14, -18 and -12 centigrade, btw)
13:27:38 -!- copumpkin has quit (Ping timeout: 255 seconds).
13:28:03 -!- copumpkin has joined.
13:35:20 <fizzie> -8.5 °C here now; the five-day forecast is claiming -20 °C for Monday morning, though.
13:37:28 <fizzie> They have a "feels like" number of -18 °C for today, too; I don't really know how that gets computed.
13:39:31 <fizzie> A weather station in Resolute, Nunavut, Canada is saying -42 °C now, so I guess we don't have anything to complain about. (The page lists high/low numbers from around the world.)
13:46:55 <zzo38> I also don't know how you would compute "feels like" temperature; I don't know if Wikipedia has any information about that, either.
13:46:56 -!- nddrylliog has quit (Read error: Connection reset by peer).
13:47:37 <fizzie> Wind speed and relative humidity might be what it uses as inputs, but I'm sure it's rather unscientific.
13:49:57 <fizzie> There's a couple of related equations at http://en.wikipedia.org/wiki/Heat_index and http://en.wikipedia.org/wiki/Wind_chill
13:50:03 <fizzie> They look pretty empirical.
13:52:58 <fizzie> Not quite sure how those two would be sensibly combined.
13:59:09 <fizzie> "The thermometer outside the kitchen window may read 20, but then a voice on the radio announces that because of the wind, humidity and a fast-moving nonsense front it feels like 127,000 degrees below zero, that in fact the entire universe has ground to a halt because of the wind chill."
13:59:39 -!- FireFly has joined.
14:00:32 <fizzie> Also one weather reporting service has a proprietary "RealFeel temperature" index: "It is a unique composite of the effects of temperature, wind, humidity, sunshine intensity, cloudiness, precipitation and elevation on the human body--everything that affects how warm or cold a person feels."
14:01:31 -!- elliott has joined.
14:02:27 <fizzie> Oh, and it is also patented.
14:04:25 <elliott> 05:19:53 <Sgeo> This Nickleback song is distinct from the other Nickleback song I know
14:04:25 <elliott> A priori -- no, it isn't.
14:04:52 <elliott> 05:24:43 <Sgeo> According to pikhq, they only have one song
14:04:52 <elliott> Try 0
14:04:57 <elliott> oh wait
14:05:01 <elliott> I read that as one good song
14:05:11 <elliott> yes, it is well-known that Nickelback have one song. and it's terrible
14:05:41 <elliott> 05:28:37 <Sgeo> I'm sure it was an Eminem song that sounded as though it was related to getting banned from Cybertown
14:05:41 <elliott> I wonder if only quoting Sgeo's lines from the logs makes me the author of an unfair portrayal.
14:06:26 <elliott> 07:12:00 <Vorpal> <elliott> Vorpal: ping <-- pong
14:06:26 <elliott> 07:20:51 <Vorpal> bbl university
14:06:26 <elliott> ...
14:06:30 -!- cheater- has quit (Ping timeout: 240 seconds).
14:06:47 <elliott> 08:17:52 <oerjan> wait, you say it put the new IP in the wrong place in the queue? :(
14:06:47 <elliott> 08:18:07 <oerjan> well it _should_ be trivial to fix.
14:06:50 <elliott> lol, i fixed it
14:07:27 <elliott> 09:52:54 <oerjan> quintopia: well i meant the program that actually runs a single duel
14:07:28 <elliott> that's not perl oerjan
14:07:30 <elliott> that's the old version
14:07:33 <elliott> egojoust is in C
14:08:42 -!- cheater- has joined.
14:09:41 <zzo38> The lights on my keyboard are broken they usually don't work. All of the keys work, though.
14:13:24 <elliott> 10:13:07 <zzo38> Can you connect if you know its IP address?
14:13:24 <elliott> 10:13:35 <oerjan> interesting question. let me try elliott's logs
14:13:24 <elliott> I will refrain from buying a domain then
14:13:45 <elliott> 10:17:40 <oerjan> zzo38: what is the ip for codu.org?
14:13:49 <elliott> we need a dnsbot :D
14:13:51 <elliott> dns over irc
14:15:24 -!- augur has joined.
14:17:57 -!- ais523 has joined.
14:20:17 -!- Sgeo has joined.
14:20:39 <ais523> !bfjoust defend12 http://sprunge.us/ibGT
14:20:41 <ais523> !bfjoust defend13 http://sprunge.us/jQfB
14:20:52 <elliott> hi ais523
14:20:57 <ais523> hi elliott
14:21:14 * elliott starts finishing Fingerprint support
14:22:06 <ais523> I was working on those last night; 12 is a mix of 7, 10, and something else, using myndzi's suggestion of multiple decoys and adapting the strategy to how the opponent seems to be behaving; and 13 is 12 but detecting defence programs and using a counter-defence strategy rather than defending if they're seen (which both me and impomatic were trying to do yesterday)
14:22:08 <elliott> ais523: hmm, is there an easy way to create a bunch of code lines from a template in emacs
14:22:09 <elliott> ?
14:22:17 <elliott> I want 26 lines exactly the same except for A-Z
14:22:32 <ais523> I normally use keyboard macros for that sort of thing
14:22:39 <ais523> but have to look up the commands to do it each time
14:22:39 <elliott> you mean emacs macros?
14:22:43 <elliott> heh
14:22:44 <ais523> no, just keystroke recordings
14:22:46 -!- poiuy_qwert has quit (Quit: This computer has gone to sleep).
14:23:03 <elliott> ais523: obligatory: in amend, you can just write a program to do it
14:23:10 <elliott> (OK, you can in Emacs too, but nobody remembers how to use elisp)
14:23:12 <ais523> if it's just A-Z, I'd make a bunch of copies of the line via copy-and-paste, and then change a column by hand
14:23:21 <elliott> yeah
14:23:26 <ais523> perhaps using picture-mode to make the cursor go down the column
14:24:08 <EgoBot> Score for ais523_defend13: 59.1
14:24:08 <EgoBot> Score for ais523_defend12: 47.4
14:24:12 <ais523> not bad at all
14:24:13 <elliott> nice!
14:24:30 <elliott> amend mockup: Ctrl+E forM_ ['B'..'Z'] $ \c -> insert $ ", fpIns" ++ [c] ++ " :: Shiro ()"
14:24:58 <elliott> arguably, using a bunch of record-fields in place of a 26-long list is a microoptimisation :)
14:25:01 <ais523> I was testing on an old hill; defend13 beat all but one program (impomatic_mirage, which wins 22 out of the 42 possibilities)
14:25:17 <ais523> and that was without me tweaking constants to beat programs in particular
14:25:25 <elliott> gah, I think I might have to store the relevant fp
14:25:27 <ais523> I could have tweaked it to beat mirage, possibly, but it feals a bit like cheating
14:26:23 <elliott> *feels
14:26:36 <elliott> The corresponding ) "Unload Semantics" instruction unloads the semantics for a given fingerprint from any or all of the instructions A to Z (even if that fingerprint had never been loaded before). It pops a count and builds a fingerprint in exactly the same way.
14:26:41 <elliott> Why can't it just pop the most recently loaded one >_)<
14:26:42 <elliott> *>_<
14:27:31 <ais523> it basically pops the semantics stack for every command implemented by that fingerprint
14:27:40 <ais523> which is in a sense an even simpler operation
14:29:55 <elliott> ais523: no, it doesn't
14:30:06 <elliott> ais523: it only pops _its_ entry
14:30:09 <ais523> well, that's how Mycology/CCBI/cfunge interpret it
14:30:15 <elliott> and it only pops it if it's loaded
14:30:20 <elliott> "unloads the semantics for a given fingerprint from any or all of the instructions A to Z"
14:30:27 <elliott> unloading another fingerprint's semantics isn't unloading the semantics
14:30:39 <elliott> I can't see any way to defend that interpretation
14:31:02 <ais523> see the section below
14:31:23 <ais523> unloading the semantics is defined as popping a semantics stack
14:31:30 <elliott> ais523: possibly
14:31:39 <elliott> gah, this spec is so badly written
14:31:45 <ais523> on the other hand, it's possible from the spec that that stack is per-fingerprint
14:32:25 <ais523> wow, that's even more broken than the typical interpretation
14:32:47 <ais523> I think that spec has to be interpreted as "when a fingerprint is unloaded, each of the commands implemented by that fingerprint are set to the meanings they had immediately before it was loaded"
14:32:53 <elliott> yep
14:33:01 <elliott> ais523: indeed, as far as I can tell, the pure interpretation is that every fingerprint has 26 variables
14:33:02 <ais523> so, e.g., if you load A, load B, unload A, unload B, the common commands now have A's semantics
14:33:10 <elliott> yep, oh my
14:33:11 <elliott> Deewiant!
14:33:18 <ais523> elliott: 26 stacks, there's no ban on loading a fingerprint more than once
14:33:26 <elliott> er, right
14:33:28 <ais523> I think CCBI is wrong on this, as is Mycology
14:33:34 <elliott> ais523: unlike the "y bounds are actually useless" thing I found, this is actually a real problem :-D
14:33:39 <elliott> and not one that ruins the language, so not an ignorable one
14:33:44 <elliott> ais523: indeed, probably cfunge too then
14:33:52 <ais523> yep, it wouldn't pass mycology if it did it correctly
14:34:07 <elliott> ais523: OTOH, the actual _definition_ of the ) instruction seems marginally saner
14:34:10 <elliott> so which do we go by?
14:34:20 <elliott> (the definition doesn't _contradict_ the following, but it doesn't imply it either)
14:34:45 <ais523> I dont think they contradict each other, thus we have to take the meaning that makes them both correct
14:35:00 <ais523> which is that unloading a fingerprint restores each of its commands to what they did before the fingerprint was loaded
14:35:58 <fizzie> There is that one point of ): it unloads from the defined instructions "even if that fingerprint had never been loaded before". That doesn't really make sense if you read the first part so that a fingerprint is only capable of unloading its own semantics.
14:36:42 <ais523> wow, apparently the Java floating point infinite loop bug is not only remotely exploitable on most Java-based servers, but apparently Sun has known about it for over 10 years
14:36:46 <elliott> fizzie: arguably, it just runs the unload code anyway
14:36:50 <elliott> and the stacks are initialised with... reflects?
14:36:52 <ais523> where "apparently" means "stated without source in a Slashdot submission"
14:37:00 <fizzie> And there's the save/restore thing which explicitly says it's push/pop.
14:37:11 <elliott> fizzie: that's what we're going by
14:37:13 <ais523> fizzie: yep, the push/pop seems to be based on a per-fingerprint stack, though, not per-command
14:37:32 <Deewiant> ais523: A source that uses a broken link as a primary source: http://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/
14:37:36 <ais523> there's nothing there that suggests the stacks are INTERCAL-style stashes rather than working more like a callstack
14:37:40 <ais523> Deewiant: haha
14:37:43 <elliott> hmm
14:37:49 <fizzie> ais523: Where did you deduce the per-fingerprint stack, though?
14:37:50 <ais523> I mean, I know the bug exists, it's easy to verify
14:37:51 <Deewiant> ais523: Well, it claims it worked previously
14:37:52 <elliott> I think it's ambiguous enough that I'll do the Mycology interpretation
14:37:58 <ais523> Sun knowing about the source for over 10 years, though...
14:38:01 <elliott> but, please, argue with Deewiant and tell me the result so I can fix my code
14:38:54 <ais523> fizzie: hmm
14:38:54 <Deewiant> I'm not going to argue, at best I'll agree to disagree; Language::Befunge is the only one that ever had a different interpretation, IIRC
14:39:02 <ais523> in fact, it's potentially arguable that it's a global stack
14:39:09 <ais523> in which case you wouldn't need FING to shuffle fingerprints around
14:39:48 <ais523> actually, the literal reading implies that the fingerprint itself gets to define whether the stacks in question are per-fingerprint, per-instruction, or global
14:40:44 <ais523> so I suppose all existing fingerprints do it per-instruction because they were written for per-instruction interps, apart from the RC/Funge ones (which were global)
14:41:06 <elliott> Deewiant: Personally, I think that "ABCD"4) only pops from the fingerprint stack if ABCD is the most recently loadedfingerprint.
14:41:08 <fizzie> The fact that it does save(A); save(B); but restore(B); restore(A); does make it sound like a global single semantics stack.
14:41:09 <elliott> *loaded fingerprint.
14:41:30 <ais523> fizzie: per-fingerprint stacks would do it in that order too
14:41:33 <elliott> I don't see how "unload semantics of FP" can be interpreted as "unload semantics of different FP entirely"
14:41:35 <ais523> (per-command wouldn't)
14:41:47 <elliott> Shiro/Types.hs:42:12:
14:41:48 <elliott> No instance for (Show (StateT FungeState IO ()))
14:41:48 <elliott> arising from the 'deriving' clause of a data type declaration
14:41:48 <elliott> at Shiro/Types.hs:42:12-15
14:41:48 <elliott> heh
14:41:49 <fizzie> ais523: Well, yes, but I don't think per-fingerprint stacks are so very reasonable.
14:42:23 <Deewiant> elliott: "even if that fingerprint had never been loaded before".
14:42:27 <ais523> also, it's worth pointing out that Chris Pressey's NULL fingerprint implemented every command, and was defined as being unloadable in order to reset the semantics of every command
14:42:28 <fizzie> I still think the "unloads the semantics for a given fingerprint from any or all of the instructions A to Z (even if that fingerprint had never been loaded before)" part hints that you're supposed to be able to do that.
14:42:40 <ais523> which implies per-fingerprint stacks to me, or that wouldn't work
14:42:49 <elliott> Deewiant: Yes, and?
14:43:00 <elliott> Deewiant: It's clearly UNDEF in that case because there's no specification of what it actually means to do that.
14:43:14 <elliott> <ais523> also, it's worth pointing out that Chris Pressey's NULL fingerprint implemented every command, and was defined as being unloadable in order to reset the semantics of every command
14:43:15 <elliott> aha
14:43:16 <elliott> Deewiant: ^
14:43:24 <Deewiant> I am aware of all this, don't ping me. :-P
14:43:38 <elliott> BUT THAT'S CLINCHING EVIDENCE
14:43:57 <elliott> Bah, are we going by what the spec clearly says or by what Mycology says
14:44:39 <fizzie> ais523: Where does it say that? http://catseye.tc/projects/funge98/library/NULL.html just says "This can be loaded before loading a regular transparent fingerprint to make it act opaquely."
14:45:29 <elliott> :t maybe
14:45:30 <lambdabot> forall b a. b -> (a -> b) -> Maybe a -> b
14:47:47 -!- asiekierka has joined.
14:50:01 -!- boily has joined.
14:52:56 <elliott> fpIns :: FPIns -> Shiro ()
14:52:57 <elliott> fpIns ins = do
14:52:57 <elliott> m <- gets fpInstructions
14:52:57 <elliott> head $ Map.findWithDefault [reflect] ins m
14:53:01 <elliott> bah
14:54:36 -!- poiuy_qwert has joined.
14:56:09 -!- poiuy_qwert has quit (Client Quit).
14:56:10 <elliott> Deewiant: What does Mycology expect NULL's instructions to do :P
14:56:33 <fizzie> I have a strange urge to say "gets is unsafe and harmful!" here.
14:57:04 -!- azaq23 has joined.
14:57:12 <Deewiant> ais has already said that about elliott's getses
14:57:28 <Deewiant> elliott: And reflect, what else
14:57:37 <elliott> Deewiant: ...What?
14:57:40 <elliott> No.
14:58:05 <elliott> Oh.
14:58:13 <Deewiant> Yes.
14:58:21 <elliott> fpRun NULL _ = return ()
14:58:23 <elliott> :D
14:58:41 <Sgeo> It's... weird listening to music that might not be appropriate for public
14:58:49 <Sgeo> [aka all music]
14:59:28 <elliott> What
14:59:33 <elliott> Module imports form a cycle for modules:
14:59:33 <elliott> Shiro.Fingerprints.NULL (./Shiro/Fingerprints/NULL.hs)
14:59:34 <elliott> imports: Shiro.Utils
14:59:34 <elliott> Shiro.Utils (./Shiro/Utils.hs)
14:59:34 <elliott> imports: Shiro.Fingerprints
14:59:34 <elliott> Shiro.Fingerprints (./Shiro/Fingerprints.hs)
14:59:36 <elliott> imports: Shiro.Fingerprints.NULL
14:59:38 <elliott> FUCKING
14:59:40 <elliott> GHC
14:59:42 <elliott> ARGH
15:00:26 <Sgeo> Got new earbuds
15:00:46 <Sgeo> Cost about as much as Minecraft
15:01:06 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
15:01:40 <Sgeo> So maybe I overpayed a little
15:01:45 <Sgeo> At least I have something
15:01:51 <elliott> And you still don't own Minecraft
15:01:55 <elliott> Also, "at least I have something"?
15:01:59 <elliott> Were you previously a monk?
15:02:19 <Sgeo> It's easier for me to pay for stuff IRL than online
15:02:52 <elliott> Right. Monks can't get cards. Plastic is against their religion.
15:06:36 <elliott> Deewiant: How does Mycology decide whether ( pushes the correct fingerprint?
15:06:46 <Deewiant> What do you mean?
15:06:53 <elliott> Testing fingerprint NULL...
15:06:54 <elliott> BAD: ( did not push correct fingerprint
15:07:32 <Deewiant> That refers to the encoding of 'NULL'
15:07:43 <Deewiant> 0x4e554c4c
15:08:17 <elliott> Deewiant: ( doesn't push the fingerprint does it
15:08:32 <Deewiant> Given the error message I would venture to suggest that it does
15:08:33 <elliott> Do you mean that ( reflected?
15:08:40 <elliott> ( then uses this fingerprint to locate and load a set of semantics for the instructions A to Z. If the Funge implementation cannot find the correct library for the given fingerprint, ( acts like r. If, however, the semantic library load is successful, the new fingerprint, then a 1, are pushed onto the stack (to be accepted by a subsequent ) instruction.)
15:08:42 <elliott> Ohhhh
15:08:50 <elliott> Reading is... difficult...
15:13:12 <elliott> "If, however, the semantic library load is successful, the new fingerprint, then a 1, are pushed onto the stack (to be accepted by a subsequent ) instruction.)"
15:13:18 <elliott> Deewiant: this implies that ) will pop a 1 -- discuss
15:13:35 <Deewiant> I don't see what there is to discuss
15:13:50 <Deewiant> Yes, if you give ) a 1, it will pop it :-P
15:14:46 <elliott> Deewiant: I mean, it will pop a 1, and then the count
15:14:55 <Deewiant> No, 1 is the count
15:14:59 <elliott> Ohhh, I see how that works.
15:15:01 <elliott> That' freaky-deaky.
15:15:02 <elliott> *That's
15:16:06 <elliott> NULL WORKS
15:16:08 <elliott> WOOOOOOOOOOOOOOOOOOOOOOOOO
15:19:14 -!- zzo38 has quit (Remote host closed the connection).
15:19:38 <sebbu> fingerprint ? do you try to load WSQ files ?
15:19:55 <elliott> Funge-98 fingerprints
15:20:03 -!- elliott has left (?).
15:20:07 -!- elliott has joined.
15:20:08 <elliott> whoops
15:25:18 <elliott> Deewiant: What does "C-language integer remainder" mean, IIRC C's modulo has undefined behaviour on the relevant cases here
15:25:28 <Deewiant> Correct
15:25:28 <elliott> Is it literally the remainder of (a/b) as an int in C?
15:25:36 <elliott> Or?
15:25:54 <Deewiant> I can't remember whether I went with C99 or UNDEF
15:25:58 <elliott> :D
15:26:00 <elliott> @check \x y -> (rem x y) == (x - (x `div` y) * y)
15:26:00 <lambdabot> "*Exception: divide by zero
15:26:08 <elliott> @check \x y -> y == 0 || (rem x y) == (x - (x `div` y) * y)
15:26:09 <lambdabot> "Falsifiable, after 8 tests:\n-6\n7\n"
15:26:14 <elliott> @check \x y -> y == 0 || (mod x y) == (x - (x `div` y) * y)
15:26:15 <lambdabot> "OK, passed 500 tests."
15:26:19 <Deewiant> @check \x y -> y == 0 || (rem x y) == (x - (x `quot` y) * y)
15:26:20 <lambdabot> "OK, passed 500 tests."
15:26:31 <elliott> :t quot
15:26:32 <lambdabot> forall a. (Integral a) => a -> a -> a
15:26:34 <elliott> > quot 1 2
15:26:39 <lambdabot> 0
15:26:55 <Deewiant> @check \x y -> quot x y == div x y
15:26:56 <lambdabot> "*Exception: divide by zero
15:27:02 <Deewiant> @check \x y -> y==0 || quot x y == div x y
15:27:03 <lambdabot> "Falsifiable, after 5 tests:\n-1\n3\n"
15:27:05 -!- copumpkin has joined.
15:27:44 <elliott> Who the fuck is Sam Holden
15:27:52 <Deewiant> :-D
15:28:11 <elliott> Why are we even implementing these half-written abominations >_<
15:29:01 <Sgeo> I'm considering inviting someone to this channel
15:29:26 <elliott> Don't
15:29:40 <Sgeo> We're friends on Facebook, but I have no access to his wall :/
15:29:54 <elliott> What's that got to do with #esoteric
15:30:06 <elliott> Deewiant: But seriously, what does U do?
15:30:16 <Sgeo> There's someone else I want to introduce to this channel then
15:30:27 <Deewiant> If it's the Sam Holden positive result one, I went with "always returns a positive result"
15:30:58 <Sgeo> "In the meantime, I'm working on some ideas I've had in operating systems, networking, and embedded AI."
15:31:09 <elliott> _Embedded_ AI?
15:31:28 <elliott> > mod (-2) (-3)
15:31:29 <lambdabot> -2
15:31:36 <elliott> Deewiant: So... the same as the % instruction?
15:31:39 <elliott> > rem (-2) (-3)
15:31:40 <lambdabot> -2
15:31:45 <elliott> Wait what.
15:31:50 <elliott> OK, I'll do ceiling of mod.
15:31:53 <elliott> Erm.
15:31:54 <elliott> Abs of mod.
15:31:59 <elliott> > mod 3 0
15:32:00 <lambdabot> *Exception: divide by zero
15:32:10 <Deewiant> mod uses the sign of the divisor, rem of the dividend
15:32:20 <Deewiant> C90 is undefined, C99 % uses the dividend
15:32:22 <elliott> I know that.
15:32:58 <elliott> haskell: 2090 (100.00%)
15:32:59 <elliott> Dayum
15:33:02 <elliott> oh
15:33:05 <elliott> that's counting the old copies :D
15:33:10 <elliott> haskell: 829 (100.00%)
15:33:52 <elliott> BAD: 0a-04-R doesn't push -2
15:33:52 <elliott> BAD: 0a-04-U doesn't push 2
15:33:52 <elliott> Hooray
15:33:57 <elliott> Deewiant: You assumed C99, btw.
15:34:31 <elliott> Deewiant: So anyway... Does loading a fingerprint in one IP load its instructions in all IPs? I bet no.
15:34:40 <elliott> Which is hilarious considering fingerprints can have global state ...
15:37:31 <Deewiant> Not that hilarious; you don't have to give them all access to the state just because one requested it
15:37:50 <elliott> HILARIOUS ENOUGH.
15:38:23 -!- Sgeo_ has joined.
15:39:03 <elliott> UNDEF: IVXLCDM didn't reflect: child IP has ROMA loaded
15:39:16 <elliott> Yay, it agrees with CCBI :P
15:39:52 -!- Sgeo has quit (Ping timeout: 255 seconds).
15:42:51 -!- boily has quit (Quit: leaving).
15:43:16 <elliott> Woot
15:43:28 <elliott> Full pass on Mycology apart from text-mode o output, including MODU/ROMA test
15:43:41 <elliott> All that's left now is oh so many fingerprints. And optimisation. And things.
15:45:02 <Deewiant> Do them in the order Mycology tests them; have fun with MODE
15:46:07 <elliott> Deewiant: But TOYS is pretty high on that list :P
15:46:08 <elliott> Earlier than TURT
15:46:32 <Deewiant> I suspect MODE will be more fun for you than TOYS
15:46:49 -!- Phantom_Hoover has joined.
15:46:54 <Deewiant> cfunge does TOYS, not MODE :-P
15:47:25 <elliott> Deewiant: Yeaaah, I don't even do the other two modes in MODE yet :P
15:47:37 <Deewiant> Other two?
15:47:42 <elliott> Deewiant: Une, tre.
15:47:58 <elliott> I want to get my Template Haskell fingerprint shiznit (technical term) going before I do any more.
15:48:10 <Deewiant> MODE doesn't do anything with une/tre
15:48:30 <elliott> Deewiant: Erm, what is it then?
15:48:44 <Deewiant> http://catseye.tc/projects/funge98/library/MODE.html
15:48:49 <elliott> x_x
15:48:57 <elliott> Ah yes, _that_ thing.
15:49:03 <Deewiant> You may want to view source due to use of <p> instead of <br> and then sending everything as application/xhtml+xml
15:49:14 <elliott> Deewiant: Technical term here -- "fuck you"
15:49:18 <elliott> I'll do that one before TRDS :P
15:49:23 <Deewiant> :-P
15:49:35 <Deewiant> I pretty much did them in the order Mycology tests them
15:49:57 <elliott> You did TOYS before the easy ones? :-P
15:50:04 <Deewiant> What easy ones?
15:50:10 <elliott> Like, uh, DATE.
15:50:11 <elliott> EVAR.
15:50:16 <elliott> TIME.
15:50:21 <Deewiant> Yes, I did all of Cat's Eye before moving on
15:50:46 <elliott> Deewiant: But at what point should I do MKRY?!
15:51:00 <Deewiant> DATE is new, it wasn't around when Mycology was released
15:51:04 <elliott> You need to test it. In Mycology.
15:51:06 <elliott> Who made DATE?
15:51:08 <Deewiant> Or was that the one that was in one Rc/Funge-98 readme but not the other
15:51:14 <Deewiant> And I had missed it
15:51:16 <Deewiant> Can't remember
15:51:18 <elliott> Who made the new one?
15:51:44 <Deewiant> DATE is just an Rc/Funge-98 fingerprint
15:52:27 <Deewiant> It may've been among the first new ones from Mike
15:53:25 <elliott> Who made the new one?
15:53:27 <elliott> :p
15:53:32 <elliott> Oh.
15:53:33 <elliott> Right.
15:53:36 <Deewiant> There is no "new one" :-P
15:53:53 <elliott> I wonder if RC/Funge will get a new update since the first one Susan made.
15:58:04 <Gregor> wtf@careless
15:58:09 <elliott> Gregor: ?
15:58:20 <Gregor> http://codu.org/eso/bfjoust/in_egobot/myndzi_careless.bfjoust
15:58:24 <Gregor> #1 on the hill
15:58:29 <ais523> just observed over email: someone sent my supervisor a Haskell program, he sent back a correction, the original author quoted the correction via email
15:58:39 <ais523> and it destroyed the indentation
15:58:47 <Gregor> lol
15:58:49 <ais523> yet another reason why indentation-sensitivity is a Bad Thing
15:59:11 <elliott> ais523: you mean people doing stupid things?
15:59:20 <Gregor> <indentationophiles> Yet another reason why EMAIL is a Bad Thing
15:59:21 <elliott> ais523: what kind of email client destroys spaces?
15:59:22 <ais523> elliott: the world isn't set up to work with it
15:59:28 <ais523> and I'm not sure, I'll look at the headers
15:59:32 <elliott> ais523: Works for me
15:59:38 -!- elliott has left (?).
15:59:40 -!- elliott has joined.
15:59:48 <elliott> Sending code via email in the expectation that it be modified and sent back is just weird
15:59:55 <ais523> Thunderbird, by the look of it
15:59:58 <elliott> That's not exactly a perfect code collaboration mechanism
16:00:01 <ais523> elliott: that wasn't the expectation
16:00:02 <Gregor> Explain why http://codu.org/eso/bfjoust/in_egobot/myndzi_careless.bfjoust is so good X-P
16:00:14 <elliott> ais523: Well, you could always replace all the indentation with {} blocks.
16:00:27 <ais523> Gregor: because it's using a different strategy to everything else, which is trivially easy to counter but nobody has bothered yet
16:00:33 <elliott> I value things like more readable code over email-friendliness, though.
16:01:07 <Deewiant> monorail beats it so it can't be that good
16:01:31 <ais523> !bfjoust beats_careless +++++
16:01:33 <Gregor> defend13 is pretty friggin' clever/scary
16:01:49 <ais523> thanks
16:02:13 <elliott> wow, defend13 has comments X-D
16:02:17 <elliott> Don't comments take ticks in BF Joust?
16:02:21 <ais523> I thought people might be interested in how it works
16:02:23 <ais523> and they don't
16:02:30 <ais523> well, invalid-command comments don't
16:02:43 <ais523> header comments do, and run the risk of accidentally being executed
16:02:46 <elliott> can someone link to report.txt?
16:02:52 <Deewiant> http://codu.org/eso/bfjoust/report.txt
16:02:56 <elliott> ais523: header comments?
16:03:01 <Gregor> "is a rush-based" lol
16:03:05 <Gregor> I see a - there ;)
16:03:09 <ais523> Gregor: whoops
16:03:10 <elliott> :D
16:03:17 <ais523> I don't think it makes /much/ difference at that location
16:03:24 <elliott> try removing it, i bet it does 500 times better!
16:03:30 <Gregor> Watch him fix that and suddenly it gets negative points and 11.3 score :P
16:03:37 <ais523> ais523_beats_careless.bfjoust vs myndzi_careless.bfjoust: <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< ais523_beats_careless.bfjoust wins
16:03:40 <ais523> nah, I'll leave it as-is
16:03:47 <ais523> and just fix it for defend14, when I come up with a different strategy
16:03:48 <elliott> what's ais523_death_to_no_ops doing?
16:03:49 <EgoBot> Score for ais523_beats_careless: 13.0
16:03:52 <ais523> EgoBot: killing no-ops
16:04:01 <elliott> <EgoBot> thanks
16:04:04 <elliott> I mean strategy
16:04:33 <ais523> umm, I can't remember, it was a throwaway program
16:04:38 <ais523> just a typical stupid rush
16:04:50 <Deewiant> 2011-02-08 23:32:05 ( ais523) !bfjoust death_to_no_ops (>)*8(>(-.)*256)*21
16:04:50 <Gregor> I'm glad that aiming for ONE major opponent isn't instant-hill-permanence.
16:05:03 <Gregor> Also, wow, you broke 60
16:05:06 <elliott> !bfjoust all_credit_to_ais523_defend13_tweaked_tinily http://sprunge.us/eRdS
16:05:14 <ais523> ah, right
16:05:14 <elliott> Gregor: "Broke 60"?
16:05:17 <elliott> oh
16:05:18 <elliott> wow
16:05:22 <elliott> how did you dod that :D
16:05:23 <elliott> *do
16:05:26 <elliott> by making careless worse?
16:05:28 <ais523> it wasn't even control flow, it's basically doing a full-tape clear
16:05:31 <elliott> so it counts less against defend13?
16:05:48 <ais523> elliott: I think it's more that it pushed a bad program that beat defend13 off the hill
16:05:58 <elliott> http://codu.org/eso/bfjoust/breakdown.txt
16:05:59 <elliott> err
16:06:00 <elliott> it hasn't lost yet
16:06:02 <EgoBot> Score for elliott_all_credit_to_ais523_defend13_tweaked_tinily: 57.6
16:06:05 <elliott> oh wait
16:06:06 <elliott> it never says loss
16:06:16 <elliott> ais523: I appear to have beaten you >_>
16:06:19 <ais523> I need to get rid of Gregor's mindbogglingly slow rushes, defense programs hate them
16:06:19 <elliott> ais523: I'll make it <
16:06:22 <elliott> ais523: and you can copy it to defend13
16:06:24 <elliott> if you want
16:06:27 <elliott> I just replaced the - with a space
16:06:30 <ais523> elliott: they score completely identical points
16:06:35 <elliott> oh, indeed
16:06:37 <ais523> which is not surprising given how it works
16:06:40 <elliott> I'll get rid of it
16:06:47 <elliott> !bfjoust all_credit_to_ais523_defend13_tweaked_tinily <
16:06:57 <EgoBot> Score for elliott_all_credit_to_ais523_defend13_tweaked_tinily: 0.0
16:07:14 <ais523> anyway, that - was in a section of code that's designed to just sit back and let the opponent do their thing
16:08:07 <ais523> defend13 uses three separate tripwires, which I think is some sort of record
16:08:28 <ais523> the first two have the same purpose, the only reason that there's two of them is in case the opponent misses tripping one of them
16:09:20 <elliott> ais523: when bfjoust first came out, I didn't think complicated programs could work, because they'd be too slow
16:09:24 <elliott> you've proved me wrong :)
16:09:38 <ais523> defend13 even has a (.)*128, IIRC
16:10:04 <ais523> the other thing defend13 does is use a different strategy on the two polarities
16:10:09 <elliott> ais523: I'm tempted to write a program that targets defend13 specifically
16:10:12 <ais523> each of which works well, but has a different weakness
16:10:15 <elliott> by making it think it's a different kind of strategy than it is
16:10:19 <elliott> but it'd probably lose to everything else
16:10:31 <elliott> ais523: hmm, you can tell what polarity you have?
16:10:35 <elliott> is it because -- and ++ are tested?
16:10:37 <ais523> no, of course not
16:10:47 <ais523> but you can tell which way your opponent changed your flag
16:10:48 <ais523> via timing
16:10:54 <elliott> i just realised you meant that, yeah
16:11:04 <ais523> defend13 actually has an offset clear detector
16:11:19 <ais523> back when I wrote defend9, offset clears weren't very common, so I had to use much more complex tricks
16:11:39 <ais523> nowadays, though, they're all over the place, and they're the easiest way of detecting polarity I know, because nobody goes ------[-]
16:12:39 <ais523> hmm, decoybooster's doing surprisingly well, it uses a similar strategy to 3pass
16:12:44 <ais523> just a little more defensive
16:12:47 -!- Phantom_Hoover has set topic: Actually #bfjoust | http://208.78.103.223/esoteric/ | http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
16:13:46 <ais523> Phantom_Hoover: it's #befunge too!
16:14:01 -!- Phantom_Hoover has set topic: Actually #bfjoust crossed with #befunge | http://208.78.103.223/esoteric/ | http://tunes.org/~nef/logs/esoteric/?C=M;O=D.
16:14:07 <ais523> (actually, I think #befunge, or is it ##befunge, actually exists and was used a while ago, but ended up being merged into #esoteric; there's one for BF too, IIRC)
16:14:16 <ais523> (and one for Feather, which AFAIK Vorpal is still idling in)
16:14:31 <ais523> indeed, I just looked into #feather-lang
16:15:20 <ais523> theory: it's theoretically impossible to open-source a Feather interp, on the basis that the code would be obfuscated by definition
16:15:50 <elliott> heh
16:15:58 <Deewiant> Obfuscated open-source is still open-source
16:16:02 <elliott> Phantom_Hoover: <Whine>
16:16:06 <elliott> Deewiant: GPLv2 prohibited obfuscation
16:16:08 <ais523> not by certain definitions I've seen
16:16:19 <Phantom_Hoover> elliott, what?
16:16:23 <ais523> elliott: not directly; it requires you to use the version of the source that's most convenient to edit from
16:16:23 <elliott> Phantom_Hoover: Re topic
16:16:27 <Phantom_Hoover> Oh.
16:16:34 <ais523> so if there is non-obfuscated source, you have to provide that
16:16:49 <Phantom_Hoover> THIS CHANNEL HAS TOTALLY GONE DOWNHILL I AM LEAVING AND NEVER COMING BACK
16:16:51 -!- Phantom_Hoover has quit (Quit: Leaving).
16:16:52 <ais523> likewise, you can distribute GPLv2 binaries as the source (ditto GPLv3) if the program was originally written in machine code
16:17:17 -!- Vonlebio has joined.
16:17:25 <ais523> anyway, why is Phantom Hoover complaining about BF Joust? it's definitely an esolang
16:17:29 <Vonlebio> HEY GUYS I AM TOTALLY NEW HERE
16:18:18 <ais523> hmm, the whois doesn't match Phantom Hoover, so it must be someone new
16:18:38 <Vonlebio> YE:
16:18:41 <Vonlebio> *YEP
16:19:01 -!- azaq23 has quit (Quit: Leaving.).
16:19:14 <Vonlebio> So who is this Phantom_Hoover guy?
16:20:29 <elliott> ais523: btw, I know how to do lazy Underload really elegantly
16:20:49 <ais523> seen on reddit: someone finds that a load of businesses claim their phone number is 214-748-3647 due to trying to store it in MySQL
16:20:57 <ais523> (which saturates silently on integer overflow)
16:22:09 <Gregor> ... lolwut?
16:22:11 <elliott> ais523: INSUFFICIENT REACTION
16:22:19 <elliott> I've been thinking about it for days
16:22:28 <ais523> oh, I /cleared for reasons I can't remember
16:22:32 <ais523> and now have forgotten context
16:22:34 <elliott> <elliott> ais523: btw, I know how to do lazy Underload really elegantly
16:22:37 <ais523> oh, right
16:22:47 <ais523> I found a moderately elegant way to do it, but you might have found an even better way
16:23:00 <elliott> ais523: My way allows for output.
16:23:06 <pikhq> I'm pretty sure the only real way to handle a phone number is to normalize a string.
16:23:17 <pikhq> Especially if you want to handle international numbers.
16:23:17 <elliott> ais523: does yours?
16:23:35 <ais523> not elegantly
16:23:57 <elliott> ais523: once this implementation is semi-working, I'll fill you in on the details
16:23:59 <ais523> the inelegant way is to expand everything but : lazily (with S being semi-lazy and not executing until it reaches the front of the program)
16:24:20 <ais523> but it's not really proper laziness
16:24:23 <elliott> ais523: mine involves reversing the program, which turns Underload into a strange polish notation language
16:24:28 <elliott> which you can then evaluate normally in the normal way
16:24:29 <ais523> as you sometimes evaluate things over than S that are never used
16:24:32 <ais523> elliott: err, wow
16:24:37 <elliott> because if you see )x(, you know that the final stack starts with x, see?
16:24:44 <elliott> whereas, in unreversed underload, you can't know that
16:24:47 <elliott> because it could be popped later
16:24:51 <elliott> so this allows for greater laziness
16:24:52 <ais523> haha
16:25:00 <pikhq> Your phone system ought to be able to handle +44-0131-867-5309.
16:25:07 <elliott> ! just starts a comment or whatever, ignoring output
16:25:12 <elliott> well, comments out the next expression
16:25:13 <elliott> or rather
16:25:15 <elliott> ! takes two arguments
16:25:19 <elliott> and returns its second argument
16:25:30 <elliott> !)a()b( = b
16:25:31 <pikhq> Erm, +44-131-867-5309
16:25:47 <ais523> hmm, that would indicate the UK, but I'm not sure what 0131 would reference as an area code
16:25:57 <ais523> it's likely to be a major city, though, due to the 01x1 pattern
16:26:03 <pikhq> ais523: It's Jenny, in Edinburgh.
16:26:10 <elliott> ^ul (b)(a)*S
16:26:11 <fungot> ba
16:26:23 <ais523> pikhq: aha
16:26:28 <elliott> hmm, ^ is broken
16:26:39 <ais523> yep, the 8675309 is recognisable enough
16:26:44 <ais523> why Edinburgh, though?
16:27:03 <pikhq> Just a city that had 7 digit numbers.
16:27:23 <pikhq> And was on Wikipedia's article on phone numbers in the UK.
16:27:39 <Vonlebio> I definitely didn't tell him the number.
16:27:46 <ais523> all cities in the UK have 7 digit numbers
16:27:51 <ais523> apart from possibly London
16:28:04 <ais523> oh, or the ones with 5-digit area codes
16:28:12 <ais523> which have 6-digit numbers
16:28:28 <pikhq> ais523: Not really. Area codes, it seems, can be 3, 4, 5, or 6 digits.
16:28:39 <pikhq> (if you count the 0 trunk code)
16:28:56 <ais523> (London is large enough that it used to have two area codes, 0171 + 7 digits, 0181 + 7 digits; it was changed to 020 7 + 7 digits and 020 8 + 7 digits, respectively, with the 7 or 8 not really counting as part of the area code)
16:29:24 <elliott> ()(~(x)*~:^):^
16:29:33 <elliott> that's an underload program that ostensibly puts (xxxxxxxxx...) on the stack, yes?
16:29:35 <elliott> *no ()
16:29:49 <ais523> I think so, and it does need the ()
16:29:57 <pikhq> Cardiff also appears to have a 3-digit area code. 029-xxxx-xxxx.
16:30:01 <elliott> ais523: I mean, in my message
16:30:03 <elliott> <elliott> that's an underload program that ostensibly puts (xxxxxxxxx...) on the stack, yes?
16:30:05 <ais523> hmm, that must have changed recently
16:30:17 <elliott> *Main> prog
16:30:17 <elliott> "S^:)^:~*)x(~()("
16:30:18 <ais523> elliott: oh, stack notation is not really standardised
16:30:19 <elliott> let's see if it works
16:30:24 <ais523> I end to leave one set of parens in for stack elements
16:30:32 <elliott> *Main> next prog []
16:30:33 <elliott> ("*** Exception: rabble rabble
16:30:41 <elliott> cool, ) is broken :P
16:30:42 <ais523> also, ouch at not doing tr/()/)(/ when reversing the program
16:30:46 <ais523> it just looks ugly
16:30:47 <elliott> oh
16:30:53 <elliott> findprn "" = error "rabble rabble"
16:30:53 <elliott> findprn ('(':s) = ("",s)
16:30:54 <elliott> findprn (x:s) = (x:xs,s') where (xs,s') = findprn s
16:30:54 <elliott> spot stupid
16:31:05 <elliott> ais523: nah, I like to define ) as pushing up to the not-matching ( :-D
16:31:38 <ais523> elliott: "" is the same as [], and thus is always called as your base case
16:31:59 <ais523> err, no, you have a second base case
16:32:19 <ais523> hmm, there isn't an obvious stupid in that case
16:32:27 <elliott> ("*** Exception: beep
16:32:27 <elliott> hmm
16:32:29 <elliott> ais523: there is
16:32:31 <elliott> ais523: it doesn't handle nesting
16:32:41 <ais523> oh right, I wasn't sure if it was meant to
16:33:47 <elliott> ais523: fun fact: every Plunder (that's what I'm calling it) program starts, conceptually, with an infinite number of ()s
16:33:59 <elliott> (i.e. ends with an infinite number of )(s, when reversed)
16:34:07 <ais523> is Plunder actually a lang? or the name of an interp?
16:34:12 <elliott> ais523: a language
16:34:14 <ais523> as in, is it semantically different from Underload at all?
16:34:19 <elliott> pretty sure it is, yes
16:34:24 <elliott> I'm not sure if IO is reversed or not, but it might be
16:34:37 <elliott> actually, I think it is, in that (hello)S would produce olleh
16:34:39 <ais523> that'd be a pretty minor change
16:34:41 <elliott> becaues otherwise the infinite example wouldn't work
16:34:42 <elliott> *because
16:34:50 <elliott> ais523: yes, but the whole evaluation model is different, because:
16:34:56 <elliott> (bar)S(:^):^(foo)S
16:34:59 <elliott> ais523: this outputs oof, then hangs
16:35:21 <ais523> err, what?
16:35:29 <ais523> are programs actually evaluated back to front?
16:35:33 <elliott> ais523: yes, like I said
16:35:39 <ais523> I thought you were reversing them
16:35:45 <ais523> so the front would be evaluated first
16:35:54 <elliott> ais523: no, programs are written ()-style
16:35:56 <elliott> but evaluated )(-style
16:36:01 <ais523> ah
16:36:11 <ais523> so they're evaluated from the front, )( style
16:36:19 <elliott> yep
16:36:55 <elliott> *Main> let prog = reverse "()(~(x)*~:^):^S"
16:37:00 <elliott> *Main> next prog []
16:37:00 <elliott> ("","",["x"],["^:~*)x(~"])
16:37:00 <elliott> wait what
16:38:28 <elliott> oh, I think ^ is borkenified
16:38:47 -!- augur has quit (Remote host closed the connection).
16:39:45 <elliott> hmm, ah, umm... eh?
16:39:58 <elliott> oh
16:40:00 <elliott> ...ah
16:40:04 <elliott> ...but eh?
16:40:06 <elliott> oh!
16:40:21 <elliott> agh
16:41:17 <elliott> grr
16:41:30 <elliott> ais523: I'll fix it later, I'm going back to Shiro until I figure it out :P
16:42:06 -!- oerjan has joined.
16:42:54 <elliott> hi oerjan
16:42:59 <elliott> don't worry, the bug wasn't in your code :P
16:43:03 <oerjan> hi elliott
16:43:08 <oerjan> oh
16:43:12 -!- augur has joined.
16:43:33 <ais523> elliott: context?
16:43:38 <elliott> ais523: zipper queue
16:43:43 <ais523> aha
16:43:44 <elliott> for shiro IP list
16:43:54 <oerjan> <elliott> I will refrain from buying a domain then
16:43:56 <oerjan> heh
16:44:22 <ais523> I should have tried writing zipper lists in Mathematica when doing the Turing machine emulators
16:44:28 <oerjan> i'm not sure that's a very good reason :)
16:44:34 -!- augur has quit (Read error: Connection reset by peer).
16:44:35 <ais523> I couldn't figure out how to get it to run at a sensible speed at all, that might have helped
16:44:41 <oerjan> <elliott> we need a dnsbot :D
16:44:50 <oerjan> hm... let's check if we have one already
16:45:04 <elliott> we don't
16:45:06 <elliott> hackego's net is restricted
16:45:07 <oerjan> !sh host www.google.com
16:45:17 <elliott> egobot's is completely blocked :P
16:45:19 <EgoBot> /usr/bin/host: /usr/lib/plash/lib/libresolv.so.2: version `GLIBC_2.9' not found (required by /usr/lib64/libkrb5.so.3)
16:45:22 <oerjan> oh :(
16:45:32 -!- augur has joined.
16:45:49 <elliott> Deewiant: man, your fingerprint stuff is nicer than mine
16:45:57 <elliott> oerjan: haha, that's an egobot bug
16:46:14 <Deewiant> elliott: What do you mean
16:46:30 <elliott> Deewiant: The Fingerprint mixin
16:46:44 <Deewiant> Oh, sure, it's nice to use
16:46:55 <oerjan> elliott: we could probably get hackego to pass on the information from somewhere else
16:47:18 <oerjan> `run host www.google.com
16:47:19 <elliott> Deewiant: How do you do global/per-IP state, though? With a global and...?
16:47:43 <oerjan> hm is it slow or just not giving any output
16:47:52 <elliott> oerjan: it says No output.
16:47:54 <elliott> when there isn't any
16:47:55 <Deewiant> "Global" state is in the fingerprint's template, per-IP is just in the IP
16:47:56 <oerjan> hm right
16:48:06 <oerjan> `echo hi
16:48:11 <HackEgo> No output.
16:48:11 <HackEgo> hi
16:48:14 <elliott> Deewiant: so you can't add per-ip state without modifying core code? ha ha ha
16:48:20 <oerjan> well then
16:48:56 <Deewiant> elliott: I'd rather have a single byte than N bools for the various modes :-P
16:49:32 <elliott> Deewiant: Mr. Microoptimise
16:49:35 <elliott> Deewiant: But whaddya mean
16:49:43 <elliott> Deewiant: What if you have more than 8 IPs
16:49:45 <Vonlebio> http://www.guardian.co.uk/commentisfree/2011/feb/07/tax-city-heist-of-century
16:50:05 <oerjan> 14:27:47 <elliott> that's not perl oerjan
16:50:06 <oerjan> 14:27:50 <elliott> that's the old version
16:50:06 <oerjan> 14:27:53 <elliott> egojoust is in C
16:50:08 <Vonlebio> I haven't actually been angry about something political for quite some time, but that...
16:50:17 <oerjan> yeah i found out later once the other webpages loaded
16:50:22 <elliott> oerjan: :D
16:50:32 <elliott> Vonlebio: almost as bad as that time you stole the pope's hat
16:50:38 <Deewiant> elliott: I mean that each IP has 5 boolean modes it can be in (12 with TRDS, IIRC)
16:50:44 <Vonlebio> elliott, worse!
16:50:50 <Deewiant> And I'd rather use close to 1 bit than 1 byte for each of those
16:50:54 <oerjan> oh no, the evil Vonlebio is back!
16:51:16 <elliott> Deewiant: Right, so fingerprints can't be plugged in, they're tightly-integrated with the core.
16:51:27 <Deewiant> Most fingerprints can be, but not all can.
16:51:28 <elliott> Deewiant: Oh, what's that? Your architecture is so crap that they take up space even if the fingerprint isn't loaded?
16:51:29 <elliott> CUTE
16:51:32 <elliott> (I'm just mocking you.)
16:51:34 <Deewiant> No they don't.
16:51:43 <elliott> Eh?
16:51:52 <Deewiant> Anything that affects the core is versioned.
16:52:09 <Deewiant> You can disable any fingerprint at compile time and it'll add no overhead.
16:52:12 <elliott> Deewiant: I mean that a program which doesn't use TRDS still gets the overhead.
16:52:20 <elliott> Being able to stop that at compile-time is irrelevant :P
16:52:24 <oerjan> elliott: now you have to add _actual_ plugin support :D
16:52:39 <elliott> oerjan: like runtime-loadable fingerprints?
16:52:44 <oerjan> elliott: yeah
16:53:03 <Deewiant> Well yes, but that's because it's still less overhead than having something like a PerIPFingerprintState[] in each IP which is only filled in if needed
16:53:05 <elliott> oerjan: unfortunately I don't think GHC is very good at pluginy things, the closest you can get is an experience like using the FFI
16:53:10 <oerjan> shouldn't be too hard with what you have now + whatever people use for plugins these days
16:53:11 <elliott> if that
16:53:29 <elliott> oerjan: and my fingerprint system involves type classes, type families, and existential quantification, so that would suck
16:53:33 <Deewiant> Although I suppose it might not always be, but in any case, the overhead is negligible
16:53:40 <oerjan> elliott: um there used to be a hsplugins package or something, or the ghc api iirc, whatever lambdabot uses
16:53:45 <elliott> <Deewiant> Well yes, but that's because it's still less overhead than having something like a PerIPFingerprintState[] in each IP which is only filled in if needed
16:53:47 <elliott> Doesn't exist in mine
16:53:49 <elliott> I use a map
16:53:58 <Deewiant> Same difference
16:54:00 <elliott> (OK, so accessing fingerprint state incurs the cost of a map lookup, but come on.)
16:54:02 <elliott> Deewiant: No it's not.
16:54:04 <Deewiant> Yours just uses more memory then
16:54:06 <elliott> An empty map takes up ~no space.
16:54:11 <Deewiant> An empty array takes up no space either
16:54:21 <elliott> oerjan: i'm pretty sure it can't do what i need
16:54:35 <Deewiant> And yes, a map lookup is expensive. I'm worrying about the /array/ lookup here. :-P
16:54:42 <oerjan> elliott: iirc the hsplugins package was using Typeable to be typesafe, don't know if it supports your kind of types
16:54:50 <elliott> oerjan: looks a bit unmaintained
16:55:04 <elliott> Deewiant: "ignore AnMaster, he's a performance freak" --you, 2008
16:55:12 <elliott> literal quote
16:55:21 <oerjan> elliott: as i implied, i don't know what they use nowadays but lambdabot obviously uses _something_
16:55:25 <elliott> oerjan: well yes
16:55:42 <elliott> oerjan: have you ever had to use an hs-boot file before :D
16:55:46 <Deewiant> elliott: The TRDS stuff is accessed quite often per tick even if you're not using TRDS
16:55:54 <elliott> Deewiant: Using TRDS = slow :P
16:55:59 <Deewiant> Having TRDS = slow
16:56:02 <elliott> oerjan: even with a Shiro.Types module I got a circular dependency
16:56:31 <Deewiant> If I disabled TRDS in my Fungicide rankings I'd be 50% faster or something :-P
16:56:59 <elliott> Deewiant: I thorte you only did that when TRDS done get loaded.
16:57:05 <ais523> Deewiant: what about not enabling going back to before TRDS is loaded, like the spec allows you to?
16:57:15 <elliott> ais523: he does that
16:57:18 <elliott> thus why i said the above
16:57:21 <ais523> ah
16:57:27 <ais523> and yet it still slows the code down anyway?
16:57:43 <elliott> maybe he thinks an if (TRDS) branch would be too expensive
16:58:30 <ais523> it'd predict well
16:58:40 <oerjan> elliott: no. (1) i haven't written any proper programs with ghc yet (2) i don't think i've ever split a haskell program into several files
16:58:43 <Deewiant> There are if (TRDS) branches
16:58:52 <Deewiant> There are several per tick and per IP per tick :-P
16:58:58 <elliott> oerjan: (1) does hugs not have anything similar? (2) heh
16:59:07 <ais523> so it'd only really be expensive on a GPU, where both branches of a conditional take time even though only one executes
16:59:26 <elliott> ais523: hah
16:59:27 <elliott> *heh
16:59:27 <Deewiant> Ticks are so cheap on average that adding a bunch of branches does slow things down
16:59:31 <oerjan> elliott: hugs doesn't support mutually recursive modules. iirc it had to modify some of the libraries slightly to get around this...
17:00:03 <elliott> oerjan: hm it should have an easier time than ghc adding them, with ghc there's all kinds of stage restrictions or something and stuff
17:00:17 <elliott> or at least, they don't want to do multiple modules in one compiler invocation because it breaks the model of "ghc -c foo.hs -o foo.o"
17:00:19 <elliott> or whatever
17:00:28 <ais523> elliott: GPUs are really massively multithreaded; they'll typically run about 1000 threads in parallel, with blocks of about 32 being forced to run in exact lock-step
17:00:44 -!- Sgeo_ has quit (Ping timeout: 240 seconds).
17:01:01 <ais523> and so if two threads make different choices for a branch, both threads have to go through both sets of instructions, simply ABSTAINing from executing the set they don't want
17:01:04 <oerjan> elliott: anyway what's your circular dependency? maybe it's possible to break it
17:02:25 <elliott> oerjan: Shiro.Utils imports Shiro.Fingerprints to use the list of fingerprints. Shiro.Fingerprints imports Shiro.Fingerprints.BLAH. Shiro.Fingerprints.BLAH imports Shiro.Utils, to use its other helpful functions. i could split it but writing a Fingerprints.hs-boot was trivial, because it's just:
17:02:30 <oerjan> elliott: anyway i _think_ a .hs-boot file just contains type declarations for the relevant file so the other files can be compiled without having it compiled first
17:02:31 <elliott> module Shiro.Fingerprints where
17:02:32 <elliott> import Shiro.Types
17:02:32 <elliott> import Data.Map (Map)
17:02:32 <elliott> fingerprints :: Map Value FP
17:02:39 <elliott> and indeed
17:02:50 <elliott> before I had Shiro.Types, I had whole circular-dependencies on types and type classes
17:02:52 <elliott> that was nasty
17:03:02 <elliott> because hs-boot can't solve those
17:03:33 <oerjan> hm
17:05:23 <Vorpal> <Deewiant> Ticks are so cheap on average that adding a bunch of branches does slow things down <-- how much (says profiling)
17:05:42 <Deewiant> I can't remember, I haven't looked at this stuff in like a year
17:06:45 <elliott> OK, I have NULL, ROMA, MODU.
17:06:49 <elliott> What next :-P (Deewiant can't answer)
17:06:54 <elliott> Vorpal: implemented my O(1) wrapping function yet?
17:07:09 <Vorpal> elliott, dude. I had a full day at university. I just got home
17:07:15 <elliott> Pffft
17:07:17 <elliott> Excuses
17:07:30 <Vorpal> and I doubt I will code more today. Probably not until the weekend.
17:07:55 <Vorpal> elliott, I'd like to see you having 8 - 17 every-weekday schedule :P
17:08:24 <Vorpal> <elliott> What next :-P (Deewiant can't answer) <-- TRDS?
17:08:30 <elliott> >_<
17:08:32 <elliott> I hate you all
17:08:49 <Vorpal> elliott, well okay. What about MODE then
17:08:53 <elliott> fffff
17:08:57 <ais523> I'd suggest one that isn't feral
17:09:16 <Deewiant> HRTI so your test runs will be slowed down by another second
17:09:21 <ais523> perhaps one of the FFI-style ones like PERL, although that depends on how well Haskell's FFI works
17:09:42 <elliott> ais523: I'd probably just shell out to perl for that, ISTR perl's C API being terrifying.
17:09:52 <ais523> it's not as bad as it looks
17:09:56 <ais523> the major issues are the variable names
17:09:58 <ais523> and function names
17:10:04 <elliott> ais523: What's the function to evaluate a string :P
17:10:16 <Vorpal> elliott, HRTI. TOYS. STRN. SOCK. SCKE. MODE. TRDS
17:10:18 <Vorpal> what about that list
17:10:27 <elliott> Vorpal: SOCK can't be that hard :P
17:10:30 <elliott> Is STRN hard...?
17:10:32 <ais523> oh, you don't use Perl's C API for that, that's the wrong way round; shelling out to Perl is correct there, I think
17:10:40 <Vorpal> elliott, STRN is not really no
17:10:40 <elliott> ais523: well, that's what PERL does
17:10:45 <Vorpal> elliott, oh wait do PERL
17:10:47 <Vorpal> that is fun
17:10:51 <elliott> Vorpal: Fun sounds scary.
17:11:27 <elliott> ENVR is tempting :P
17:11:29 <elliott> Sounds nice and "easy".
17:11:34 <Vorpal> elliott, revised list: HRTI, PERL, MODE, TURT, REFC.
17:11:35 <oerjan> <ais523> elliott: oh, stack notation is not really standardised
17:11:37 <oerjan> NOW IT IS
17:11:41 <ais523> haha
17:11:44 <elliott> oerjan: but I don't like your notation!
17:11:48 <elliott> it shows evaluation as a stack element, which is just weird
17:11:49 <Deewiant> My STRN.G detects runoff strings that haven't been terminated but would hit a zero after wrapping and tries to allocate the 16+-gigabyte-stack required
17:12:01 <elliott> Deewiant: <3
17:12:02 <Vorpal> Deewiant, ... why
17:12:09 <elliott> Vorpal: It's the CONFORMANT implementation.
17:12:11 <elliott> It's in the name!
17:12:17 <elliott> `addquote <Deewiant> My STRN.G detects runoff strings that haven't been terminated but would hit a zero after wrapping and tries to allocate the 16+-gigabyte-stack required
17:12:21 <sebbu> 16gb stack ?
17:12:40 <Vorpal> elliott, STRN is rcfunge one. It is poorly enough defined that you can get away with a lot of stuff
17:12:56 <Deewiant> It only does that when you've compiled in expensive infinite loop checks though
17:12:57 <HackEgo> 301) <Deewiant> My STRN.G detects runoff strings that haven't been terminated but would hit a zero after wrapping and tries to allocate the 16+-gigabyte-stack required
17:12:58 <oerjan> elliott: as i said previously, the intuition is that x y z -- a b c indicates a stack effect which turns the result of running program x y z into the result of running program a b c instead
17:13:00 <Vorpal> elliott, do TURT
17:13:02 <Vorpal> it is fun
17:13:03 <elliott> oerjan: I know, I know
17:13:11 <elliott> Vorpal: I want to go for low-hanging fruit first :
17:13:12 <elliott> *:P
17:13:26 <ais523> let's make a fingerprint EASY
17:13:30 <oerjan> elliott: and it mixes seamlessly with my lambda notation
17:13:34 <ais523> which is vaguely useful, and trivially easy to implement
17:13:46 <Vorpal> elliott, okay then: HRTI, REFC are the catseye ones that are low hanging
17:14:01 <Vorpal> elliott, especially REFC
17:14:17 <elliott> "<p>This timer is not affected by 'time travel' contrivances."
17:14:22 <elliott> cpressey predicted TRDS?
17:14:26 <elliott> or was TRDS around very early? :-)
17:14:29 <Deewiant> It was early
17:14:39 <Deewiant> Maybe not that early, but early :-P
17:14:52 <ais523> hmm, BF Joust ethics question: should I make a minor tweak to defend13 just to beat careless?
17:14:56 <ais523> I don't really want to
17:15:07 <Deewiant> Why not?
17:15:09 <elliott> REFC seems easy enough
17:15:11 <ais523> and it will probably make it score differently against chaotic programs like wiggle
17:15:14 <ais523> so it might even do worse
17:15:20 <elliott> ais523: the scoring system practically mandates cheating like that
17:15:21 <elliott> I say go for it
17:15:22 <Deewiant> Call it defend13b then
17:15:23 <Vorpal> elliott, what about FING. That one is quite easy
17:15:29 <elliott> Vorpal: Oh fuck off :P
17:15:33 <elliott> REFC seems easy.
17:15:35 <Vorpal> elliott, no not FNGR
17:15:37 <elliott> And lets me test my state system.
17:15:38 <Deewiant> REFC is heaps of fun
17:15:44 <elliott> Deewiant: Eh?
17:15:44 <Deewiant> elliott: FING actually is easy
17:15:47 <oerjan> elliott: also you don't _have_ to use evaluation as a stack element, i just didn't see how to give stack change notation for ^ without doing so
17:15:48 <elliott> REFC looks easy
17:15:50 <Vorpal> elliott, FING is like... 20-30 lines of C code including boilerplate?
17:15:57 <Deewiant> elliott: REFC is a memory leak
17:16:01 <ais523> careless surprises me just because I've tried to write programs that work like that before and they've done badly
17:16:05 <elliott> Vorpal: MODU.hs is 27 lines long :-P
17:16:20 <elliott> My boilerplate is quite big; haven't decided the nicest way of doing the Template Haskell magic yet
17:16:25 <Vorpal> elliott, yeah MODU is more than 30 lines of C code since only one of those behaviours are native to C
17:16:26 <elliott> Deewiant: So's Haskell
17:16:36 <elliott> Vorpal:
17:16:38 <elliott> runMODU M = binary (\x y -> if y == 0 then 0 else mod x y)
17:16:38 <elliott> runMODU U = binary (\x y -> if y == 0 then 0 else abs (mod x y))
17:16:38 <elliott> runMODU R = binary (\x y -> if y == 0 then 0 else rem x y)
17:16:38 <elliott> :P
17:16:48 <Vorpal> elliott, you said 27 lines?
17:16:52 <Deewiant> elliott: abs (mod x y) can't be correct
17:16:53 <elliott> The rest is boilerplate.
17:16:57 <elliott> Deewiant: Passes Mycology
17:17:06 <Deewiant> Only because you're lucky :-P
17:17:09 <Vorpal> elliott, well C code written on one line like that would be insane
17:17:21 <elliott> Deewiant: What should it be
17:17:36 <elliott> The spec refers to the operation by a random person's name, I can hardly be blamed for misinterpreting it :P
17:17:38 <Deewiant> Consider 7 % -3 which gives -2: the correct answer is 1, not 2
17:17:57 <oerjan> !help bfjoust
17:17:58 <elliott> > 7 `mod` 3
17:17:59 <lambdabot> 1
17:18:02 <EgoBot> Sorry, I have no help for bfjoust!
17:18:07 <oerjan> !help
17:18:08 <elliott> runMODU U = binary (\x y -> if y == 0 then 0 else mod (abs x) (abs y))
17:18:08 <EgoBot> help: General commands: !help, !info, !bf_txtgen. See also !help languages, !help userinterps. You can get help on some commands by typing !help <command>.
17:18:11 <elliott> !bfjoust
17:18:12 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
17:18:15 <oerjan> ah
17:18:34 <Deewiant> elliott: mod x y + (if mod x y < 0 then abs y else 0)
17:18:44 <Vorpal> elliott, anyway FING is easy. Unlike REFC it needs no global state even
17:19:30 <elliott> Deewiant: That's not point-free
17:19:32 <Vorpal> elliott, it is just pop-and-push, swap, drop, duplicate for the fingerprint semantics stacks iirc
17:19:40 <elliott> Vorpal: Yeah, I'll do it after REFC.
17:19:53 <Deewiant> @pl \x -> x + (if x < 0 then abs y else 0) -- elliott
17:19:54 <lambdabot> ap (+) (flip (flip if' (abs y) . (< 0)) 0)
17:20:07 <elliott> :-D
17:20:24 <oerjan> hm that egodeath thing is still on the hill i see
17:20:29 <Deewiant> @pl \x -> x + fromEnum (x < 0) * abs y -- elliott
17:20:29 <lambdabot> ap (+) ((abs y *) . fromEnum . (< 0))
17:20:33 <Vorpal> elliott, only thing to remember is that you can use A-Z *or* 0-25 to refer to stacks. So you just need a normalisation function for the parameters. Trivial.
17:20:45 <elliott> not as trivial as REFC
17:20:55 <Deewiant> @pl \x y -> let m = mod x y in m + fromEnum (m < 0) * abs y -- elliott
17:20:56 <lambdabot> ap (ap (+) . (. (fromEnum . (< 0))) . (*) . abs) . mod
17:20:59 <Vorpal> elliott, here is a test program for FING (since iirc mycology doesn't test it?) http://www.rcfunge98.com/fing.f98
17:21:02 <elliott> Deewiant: It's so beautiful
17:21:11 <Deewiant> elliott: So shaddup and use the pointy :-P
17:21:19 <elliott> Deewiant: I already did, about five minutes ago
17:21:29 <Vorpal> <lambdabot> ap (ap (+) . (. (fromEnum . (< 0))) . (*) . abs) . mod <-- what
17:21:31 <Deewiant> I doubt it given that I gave it to you about three minutes ago
17:21:35 <Vorpal> @help pl
17:21:35 <lambdabot> pointless <expr>. Play with pointfree code.
17:21:38 <Vorpal> ah
17:21:48 <Vorpal> also that one was hard to read
17:21:59 <elliott> Vorpal: Point-free code is usually nicer than the equivalent pointy code, but not when lambdabot writes it :-P
17:22:05 <elliott> And also only if you split up your functions.
17:22:35 <elliott> (I'm inferring that Vorpal is learning Haskell from the things he's said.)
17:22:58 <elliott> So is REFC global or per-IP
17:23:04 <Vorpal> elliott, I just don't know lambdabot's commands. And indeed I'm not as proficient in haskell as you are.
17:23:11 <Vorpal> elliott, I'm pretty sure it is global
17:23:17 <elliott> Yay, I can use an IntMap.
17:23:19 <elliott> That gives me a happy.
17:23:21 <oerjan> Vorpal: lambdabot is not very good at optimizing pointless code, e.g. there are all kinds of tricks with curry/uncurry and Arrows which it rarely if ever uses
17:23:21 <Deewiant> I'm pretty sure it's UNDEF but I made it global
17:23:23 <elliott> Well........
17:23:31 <Deewiant> elliott: You can use an array :-P
17:23:40 <elliott> Deewiant: That would involve icky reallocation and things.
17:23:45 <Deewiant> oerjan: Never, it doesn't know about arrows
17:23:51 <elliott> Technically you could allocate more than an Int of references.
17:23:52 <Vorpal> Still is there any point (pun not intended) in spending several minutes extra just to make it pointfree when it takes a few seconds to write the non-pointfree code?
17:23:55 <oerjan> Deewiant: ah.
17:23:56 <elliott> But if you do that, fuck you.
17:23:59 <elliott> Vorpal: It doesn't take that long.
17:24:07 <elliott> Vorpal: And it makes the intention of the code nicer if done well.
17:24:11 <Deewiant> ?pl \(x,y) -> (y,x)
17:24:11 <lambdabot> uncurry (flip (,))
17:24:12 <elliott> Easier to read.
17:24:18 <Deewiant> oerjan: It knows uncurry though.
17:24:22 <elliott> Often it leads to more composable functions by noticing common substructure in code.
17:24:31 <elliott> Vorpal: Oh, and it avoids arbitrary parameter names :-P
17:24:45 <Deewiant> elliott: You'll run out of memory before allocating that many
17:24:50 <elliott> Deewiant: Indeed.
17:25:00 <Vorpal> elliott, yes indeed. Make all of your befunge implementation point free!
17:25:07 <elliott> Vorpal: Some of it already is.
17:25:15 <Vorpal> elliott, not good enough. :P
17:25:16 <elliott> Vorpal: More important than point-free code, though, is do-less code.
17:25:26 <elliott> Do notation is to be avoided at all costs :P
17:25:32 <Vorpal> elliott, why is that
17:25:39 <elliott> Unless you really have a non-trivial block of reading-and-writing imperative code, like in my instructions.
17:25:41 <ais523> naming things is one of the hard problems of computer science
17:25:49 <ais523> point-free code avoids that issue
17:25:51 <elliott> Vorpal: Because it obscures intent and makes Haskell into an imperative language.
17:25:58 <elliott> Consider:
17:26:01 <elliott> pop :: Shiro Value
17:26:01 <elliott> pop = tos <* modifyStack (drop 1)
17:26:02 <ais523> elliott: I think it's sensible to use a do-block for main, which is normally generally imperative
17:26:09 <elliott> peek :: Vector -> Shiro Value
17:26:10 <elliott> peek k = (!@ k) <$> gets fungeSpace
17:26:22 <elliott> Compare that last one with
17:26:30 <elliott> peek k = do fs <- gets fungeSpace; return (fs !@ k)
17:26:32 <elliott> Obscures intent.
17:26:53 <Vorpal> elliott, hm
17:27:33 <Vorpal> elliott, why aren't you using a monad free solution? Couldn't you just pass around a map or such.
17:27:40 <Vorpal> well a bit more than that
17:27:42 <Vorpal> but still
17:27:57 <elliott> Vorpal: Passing around a bunch of state is exactly what the state monad does.
17:28:17 <elliott> If you really have to ask "why abstract away", well...
17:28:27 <elliott> Code isn't any more functional because it takes parameters and returns a tuple.
17:28:34 <elliott> It's just harder to call (you have to thread state explicitly).
17:28:36 <elliott> It's still stateful.
17:28:52 <Vorpal> elliott, well hm. So you don't use that monad for IO at all?
17:29:03 <elliott> It's (StateT FungeState IO).
17:29:37 <ais523> if you need to be able to do I/O in the middle of a calculation, involving the IO monad somewhere is the sensible way
17:29:41 <elliott> <p>The internal list of references is considered
17:29:42 <elliott> shared among all IP's, so a global static can be used
17:29:42 <elliott> to store this list, so that this extension remains tame.
17:29:44 <elliott> Deewiant: It's explicit
17:29:44 <Vorpal> elliott, well yeah, but do you evaluate lazily. I mean, you only need to evaluate when you are about to do IO. The rest could be lazy.
17:29:49 <ais523> normally, you don't, but you do to be able to implement Funge
17:29:50 <Deewiant> elliott: Alright
17:29:51 <elliott> Vorpal: Stop trolling.
17:30:04 <Deewiant> elliott: It's not trolling really
17:30:07 <ais523> Vorpal: I'm not sure you really understand what "lazy" means in that context
17:30:10 <elliott> Well, no, it's Vorpaltrolling :P
17:30:13 <Deewiant> He has a point that you have IO available even in many places where you don't need it
17:30:23 <elliott> That's true, but they're basically inseparable.
17:30:24 <Vorpal> indeed. It seems wrong.
17:30:48 <ais523> elliott: something I've been trying to figure out: is it possible to design a monad that lets you have, say, beginWhile and endWhile as actions that repeat everything between them?
17:30:53 <elliott> ais523: yes
17:30:57 <elliott> ais523: see Cont monad
17:30:58 <ais523> I thought so, but wasn't sure
17:30:59 <Vorpal> ais523, I'm pretty sure the meaning of lazy I used is a valid meaning of that word?
17:31:05 <ais523> I was wondering about making an IFFI monad
17:31:06 <elliott> ais523: BeginWhile >>= f saves f
17:31:11 <elliott> ais523: EndWhile calls it
17:31:13 <Deewiant> elliott: You can just make a State FungeState when you don't need IO
17:31:14 <ais523> yep, that makes sense
17:31:16 <elliott> ais523: that's a do-while loop, though
17:31:18 <Deewiant> With a few helpers it shouldn't be troublesome
17:31:19 <elliott> dunno if you can do while
17:31:26 <ais523> ah, I meant while not do-while
17:31:29 <elliott> Deewiant: It'd be a waste of time.
17:31:34 <ais523> as in, can you somehow capture the bits in between
17:31:36 <Deewiant> elliott: It's more type-safe. :_P
17:31:37 <elliott> ais523: you might be able to with a "reverse Cont monad"
17:31:41 <oerjan> 16:55:14 <elliott> ais523: yes, but the whole evaluation model is different, because:
17:31:44 <oerjan> 16:55:20 <elliott> (bar)S(:^):^(foo)S
17:31:47 <oerjan> 16:55:23 <elliott> ais523: this outputs oof, then hangs
17:31:49 <elliott> Deewiant: I'll let you know if I ever type "io $" accidentally
17:31:54 <Deewiant> Your code is so unsafe that my nose got dislodged :_P
17:32:06 <elliott> THE POWER OF IO
17:32:06 <oerjan> interestingly, if you think of underload as a monoid, those evaluation models become special cases...
17:32:07 <Deewiant> Well, impure
17:32:21 <elliott> Deewiant: Funge-98, the purest of languages.
17:32:21 <Vorpal> <ais523> ah, I meant while not do-while <-- couldn't you rewrite a do while loop to a while one by adding a condition before entering first time?
17:32:23 <elliott> oerjan: :D
17:32:42 <ais523> Vorpal: that requires being able to do if, and elliott sort-of implied that that wasn't trivial either
17:32:44 <oerjan> elliott: like strict and lazy evaluation of LC, indeed
17:33:00 <Vorpal> ais523, ah.
17:33:03 <elliott> ais523: it's probably possible but I couldn't do it off-hand
17:33:11 <elliott> ais523: you probably could actually
17:33:12 <ais523> that's my guess too
17:33:13 <elliott> I can sort of see it in my head
17:33:15 <elliott> but it'd be a pain
17:33:21 <ais523> I wanted to add COME FROM to Haskell
17:33:31 <Vorpal> hahaha
17:33:34 <elliott> ais523: basically store "isWhileBody" state, and then "blah >>= f" just remembers it
17:33:35 <ais523> (don't ask "why", this is #esoteric)
17:33:36 <elliott> when isWhileBody
17:33:47 <ais523> oh right, like Maybe with Nothing
17:33:50 <ais523> yep, that'd work
17:33:54 <elliott> well sort of
17:33:57 <elliott> you still go through the whole body
17:34:00 <elliott> you just don't execute any of it
17:34:06 <elliott> but that might be hard
17:34:07 <ais523> well, Maybe does too
17:34:09 <elliott> since monadic actions yield results
17:34:11 <elliott> and f takes those results...
17:34:12 <elliott> dunno
17:34:25 <elliott> ais523: I'm not sure this would obey the monad laws, anyway :P
17:34:28 <oerjan> hm because underload lacks something which can _completely_ replace the stack, there is nothing corresponding to how lazy evaluation is canonical in LC
17:34:49 <elliott> oerjan: I don't think that's true in daolrednu
17:34:57 <ais523> oh, I see, the issue is in something like do {if false; a <- monadAction; endif; return a}
17:34:58 <elliott> it's essentially an applicative language with multiple function outputs
17:35:01 <elliott> : takes one argument and returns it twice
17:35:07 <elliott> ais523: indeed
17:35:16 <ais523> yep, that clearly makes no sense, and should equally clearly be legal
17:35:25 <elliott> *illegal
17:35:35 <elliott> ais523: or even do {if false; a <- monadAction; blah a; endif} -- even when you process it, you have to give the result of a along
17:35:38 <elliott> even if you don't want to "use" it
17:35:41 <ais523> no, I mean according to the way monads work,you should be able to do that in a monad no matter what "if" and "endif" mean
17:35:58 <ais523> s/,y/, y/
17:36:15 <oerjan> elliott: the thing is, in LC you can have one evaluation order which leads to a normal form even if another doesn't. that's not possible in underload/daolrednu, well maybe if you reduce inside subprograms, but S makes that illegal in general
17:36:32 <oerjan> or so i think.
17:36:43 <elliott> oerjan: yeah... even so, you _can_ handle:
17:36:48 <elliott> ()(~(a)*~:^):^
17:36:49 <elliott> I'm pretty sure
17:36:51 <ais523> oerjan: Underlambda changes the semantics of S just to avoid that issue
17:36:59 <ais523> its the only Underload command it changes
17:37:03 <oerjan> ais523: oh
17:37:03 <elliott> <ais523> no, I mean according to the way monads work,you should be able to do that in a monad no matter what "if" and "endif" mean
17:37:04 <elliott> <ais523> s/,y/, y/
17:37:04 <elliott> right
17:37:09 <elliott> ais523: *it's, also
17:37:21 <ais523> ah, yes
17:37:27 <ais523> took me a while to figure out what line you were correcting, there
17:37:31 <ais523> typo, rather than grammar fail
17:40:50 <Vorpal> bbl
17:41:53 <elliott> Couldn't match expected type `FPGlobalState REFC'
17:41:53 <elliott> against inferred type `IntMap a'
17:41:53 <elliott> NB: `FPGlobalState' is a type function, and may not be injective
17:41:56 <elliott> I love these kinds of errors
17:42:32 <ais523> Haskell's one of those langs which needs a CS degree just to understand the error messages
17:42:32 <elliott> shiro: Shiro/Fingerprints/REFC.hs:(30,0)-(40,22): Non-exhaustive patterns in function runREFC
17:42:35 <elliott> oh joy
17:42:44 <elliott> ais523: I have a CS degree now? woo!
17:42:56 <ais523> I'm trying to figure out what "may not be injective" means in that concept
17:42:56 <elliott> ais523: actually in the past few days I've triggered one internal GHC compiler error, and several "My brain just exploded."s
17:42:59 <ais523> *context
17:43:06 <elliott> ais523: oh, it's to do with type families
17:43:08 <elliott> which are crazy
17:43:20 <elliott> ais523: http://ehird.blogspot.com/2010/01/computing-fib3-in-haskells-type-system.html adequately shows how crazy they are
17:43:42 <oerjan> ais523: it means you cannot deduce the type t from the type FPGlobalState t
17:43:52 <elliott> ais523: (GHC actually does say "My brain just exploded.")
17:44:09 <elliott> ais523: if you do "let Foo x ... = blah" where Foo is a constructor of an existential
17:44:12 <elliott> or, I think, a GADT
17:44:30 <elliott> | qcgadt.hs:115:7:
17:44:30 <elliott> | My brain just exploded.
17:44:30 <elliott> | I can't handle pattern bindings for existentially-quantified
17:44:30 <elliott> constructors.
17:44:30 <elliott> | In the binding group
17:44:30 <elliott> | (Rep x) = uncompressRep s
17:44:32 <elliott> | In the definition of `uncompressRep':
17:44:34 <elliott> | uncompressRep (0 : 1 : 0 : s) = let (Rep x) = uncompressRep s
17:44:35 <ais523> oerjan: ah, I see, I think; ghc knows you've entered the wrong type, but can't figure out what the right type is, or if it even exists
17:44:36 <elliott> in Rep
17:44:38 <elliott> | (RList x)
17:44:40 <elliott> | Failed, modules loaded: none.
17:44:57 <oerjan> ais523: yeah probably
17:46:06 <asiekierka> hi
17:46:11 <asiekierka> i should try BF Jousting
17:46:23 <elliott> Yay, REFC works.
17:46:25 <elliott> That was painless
17:46:27 <elliott> I love Haskell.
17:46:41 <elliott> Vorpal: What was the next one you suggested? FING?
17:46:45 <asiekierka> how to try it out? i think there's a command here for one of the bots
17:46:47 <asiekierka> but what was it
17:47:07 <ais523> !bfjoust
17:47:07 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
17:47:09 <elliott> http://www.rcfunge98.com/rcsfingers.html#FING I see Mike never did stop trying to write the shortest possible specifications
17:47:23 <ais523> asiekierka: ^
17:47:30 <asiekierka> thanks
17:48:07 <elliott> Deewiant: Want to elaborate on the FING specification? :-P
17:48:18 <Deewiant> There's not much to add
17:48:24 <Deewiant> I think that's one of his better specs :-P
17:48:41 <Deewiant> He has test cases too, you know
17:48:47 <elliott> I saw fing.b98, yeah.
17:49:03 <elliott> OK, FING is semi-non-trivial with my current fingerprint code, so I'ma skip it for now.
17:49:10 <elliott> EVAR looks easy.
17:49:55 <Deewiant> Just remember that EVAR has to affect y
17:50:12 <elliott> Deewiant: It will automatically
17:50:15 <elliott> I don't cache anything about y
17:50:20 <elliott> Does anyone actually use y as pick, btw? :-P
17:50:26 <ais523> Mycology does
17:50:30 <ais523> but it's a little impractical for any other use
17:50:31 <elliott> Apart from Mycology.
17:50:35 <elliott> yeah, because y is variable-length
17:50:40 <ais523> due to the huge mess of stuff in between
17:50:46 <elliott> well, you have to run y first
17:50:49 <elliott> and calculate its total length
17:50:51 <elliott> before you can pick
17:50:58 <elliott> and if you ever change env var, etc....
17:50:58 <ais523> isn't the length of y one of the things that y returns?
17:51:01 <ais523> if so, you could use that
17:51:02 <elliott> (that's etc. + ellipsis)
17:51:03 <elliott> ais523: nope
17:51:07 <ais523> it should be
17:51:10 <elliott> ais523: it uses 0 or two 0-terminated lists
17:51:15 <elliott> so you have to scan it all
17:51:18 <elliott> pretty much
17:51:18 <ais523> haha
17:51:31 <Deewiant> No you don't
17:51:33 <elliott> ais523: did i mention that the (two 0)-terminated list is of 0gnirtses?
17:51:35 <elliott> SUCH FUN
17:51:35 <ais523> it isn't possible to edit a program's command-line args while it's running from outside the program, is it?
17:51:45 <elliott> well, you could fuck with argv directly
17:51:53 <ais523> I know on some OSes, programs that change argv will change the view in top
17:51:59 <Gregor> Not in any common OS.
17:52:01 <ais523> but I was wondering if it was possible to go the other way
17:52:03 <elliott> but you can do:
17:52:03 <elliott> withArgs :: [String] -> IO a -> IO aSource
17:52:04 <elliott> withArgs args act - while executing action act, have getArgs return args.
17:52:04 <elliott> in haskell
17:52:06 <elliott> http://www.haskell.org/ghc/docs/latest/html/libraries/base/System-Environment.html
17:52:07 <elliott> hey look
17:52:07 <ais523> Gregor: some BSD, I think it works
17:52:09 <elliott> look what's not there
17:52:09 <Deewiant> elliott: There's a constant number of cells prior to the size of the TOS
17:52:10 <ais523> I forget which
17:52:12 <elliott> look at a very interesting thing that's not there
17:52:16 <elliott> Deewiant: well yes
17:52:16 <elliott> the answer is::::
17:52:19 <Gregor> Wellllll, to be fair, you can map its memory into yours and do whatever the hell you want to.
17:52:20 <elliott> ANYTHING TO WRITE TO ENVIRONMENT
17:52:42 <Deewiant> elliott: Redecided about EVAR?-)
17:52:49 <elliott> nope, just asking #haskell :P
17:52:57 <elliott> also, what happened to your eyes?
17:53:14 <elliott> FOBJ's spec is hilarious
17:53:16 <elliott> http://www.rcfunge98.com/rcsfingers.html#FOBJ
17:53:23 <elliott> [INCREDIBLY VAGUE SPECIFICATION] [HUGE LIST OF CLARIFICATIONS]
17:53:42 <Deewiant> Yeah, that's how his specs look
17:53:52 <elliott> #3587 (provide a cross-platform way to set environment variables ...
17:53:52 <elliott> Env (package unix) provides operations to set environment variables on Linux (and probably other unices). This ticket requests adding cross-platform ...
17:53:54 <elliott> /facepalm
17:53:57 <elliott> GOODBYE PORTABILITY
17:54:08 <Deewiant> [80-char description per command] [explanatory bullet points]
17:54:36 <elliott> "FPRT 0x00000000
17:54:41 <elliott> A ( things -- other things ) do a thing
17:54:45 <elliott> B ( things -- other things ) do another thing
17:54:49 <elliott> * Thing is to be done simultaneously.
17:54:57 <elliott> * If two things are done, resulting things are modified.
17:55:03 <elliott> * Modification to things is done by doing the other thing.
17:55:08 <elliott> [500 more bullet points]
17:55:11 <elliott> (It's an SDL interface)
17:55:14 <Deewiant> I was wondering what this had to do with FPRT for a while
17:55:21 <elliott> Is that a real fingerprint?
17:55:23 <elliott> *"FPRT"
17:55:24 <Deewiant> But then I realized you used it as a generic name
17:55:26 <Deewiant> Yes, it is
17:55:29 <elliott> Ha, it is
17:55:29 <Deewiant> It gives printf
17:55:35 <Deewiant> Well, sprintf
17:55:55 <elliott> #haskell is too popular, nobody sees half the questions any more :P
17:56:07 <elliott> http://hackage.haskell.org/trac/ghc/ticket/3587 LOTS OF ATTENTION PAID HERE
17:56:19 <elliott> EXEC looks painful
17:57:06 <elliott> System.Posix.Env - Haskell - HaskellWiki
17:57:07 <elliott> getEnvDefault is a wrapper around getEnv where the programmer can specify a fallback if the variable is not found in the environment. ...
17:57:07 <elliott> www.haskell.org/ghc/docs/latest/html/.../System-Posix-Env.html - Cached
17:57:08 <elliott> Google title inferring fail.
17:57:50 <elliott> So does EVAR's G default to "" or reflect
18:00:54 <elliott> :t sepBy
18:00:55 <lambdabot> Not in scope: `sepBy'
18:01:10 <elliott> I like how Data.List.Split lacks "split up to N of these".
18:01:15 <elliott> Sorry -- I mean hate.
18:01:15 <elliott> :t break
18:01:16 <lambdabot> forall a. (a -> Bool) -> [a] -> ([a], [a])
18:01:23 <elliott> > break (=="=") "abc=def=quux"
18:01:24 <lambdabot> Couldn't match expected type `[GHC.Types.Char]'
18:01:24 <lambdabot> against inferred ty...
18:01:28 <elliott> > break (=='=') "abc=def=quux"
18:01:29 <lambdabot> ("abc","=def=quux")
18:01:33 <elliott> > break (=='=') "abc"
18:01:34 <lambdabot> ("abc","")
18:04:06 <elliott> <elliott> So does EVAR's G default to "" or reflect
18:04:07 <elliott> Deewiant? :p
18:04:18 <Deewiant> Shrug
18:04:35 <elliott> PA
18:04:35 <elliott> *PAH
18:05:54 <myndzi> ais523: i wish you would stop calling tripwires 'antitripwires', it is so confusing ;p
18:06:23 <ais523> myndzi: heh; what I meant there was that the checks I were using weren't regular tripwires (+[], check to see if it becomes 0)
18:06:36 <myndzi> ah
18:06:36 <ais523> but checking the other way round, setting a cell to 1 and then checking to see if it was still at 1
18:06:48 <myndzi> i'm also on the phone so i'm a bit distracted lol
18:06:53 <ais523> so instead of triggering on 1 value out of 256, they trigger on 255 values out of 256
18:07:11 <Vorpal> <elliott> Vorpal: What was the next one you suggested? FING? <-- yes
18:07:19 <Vorpal> elliott, it is reasonably interesting
18:07:25 <Vorpal> elliott, I linked test program for it above
18:07:36 <elliott> Vorpal: Does EVAR's G default to "" or reflect
18:07:44 <Vorpal> elliott, no idea. I don't implement EVAR
18:07:47 <elliott> Bah :P
18:07:51 <elliott> I'll assume reflect.
18:07:57 <Vorpal> elliott, ask Deewiant
18:08:00 <elliott> I did
18:08:02 <elliott> He shrugged
18:08:19 <Vorpal> hah
18:08:24 <Vorpal> elliott, doesn't the spec say anything?
18:08:34 <elliott> It's MKRY
18:08:35 <elliott> So no
18:08:41 <elliott> "EVAR" 0x45564152
18:08:41 <elliott> G(0gnirts -- 0gnirts)Get value of an environment variable
18:08:41 <elliott> N( -- n )Get number of environment variables
18:08:41 <elliott> P(0gnirts --)Put a value into the environemnt (form: name=value)
18:08:41 <elliott> V(n -- 0gnirts)Get n'th environmnt variable (form: name=value)
18:08:44 <elliott> Not even any bullet points
18:08:46 -!- asiekierka has quit (Read error: Operation timed out).
18:08:50 <Deewiant> It's too old for bullet points
18:08:58 <elliott> Deewiant: :-D
18:09:02 <Vorpal> elliott, btw this will be useful for those that you want to do but mycology doesn't test: http://www.rcfunge98.com/diag.html
18:09:04 <elliott> "Please make your specs less ambiguous" "[bullet points]"
18:09:11 <Deewiant> Pretty much
18:09:27 <Vorpal> elliott, note: you don't want to do all of them. Some are just silly. Like that UNIX IPC one or whatever it was
18:09:29 <elliott> You can _test_ MVRS? :-P
18:09:33 <elliott> Vorpal: UNIX IPC sounds like fun.
18:09:36 -!- BeholdMyGlory has quit (Read error: Operation timed out).
18:09:41 <elliott> I'm tempted to implement WIND.
18:09:50 <Vorpal> elliott, you and rcfunge eh
18:09:52 <elliott> Maybe I'll do it portably!
18:09:59 <elliott> Vorpal: What about it
18:10:02 <Deewiant> I suspect mvrs is annoying enough to test that it'll need a separate mycomvrs
18:10:10 <elliott> I just want to implement WIND because Deewiant doesn't and won't :-P
18:10:19 <elliott> Deewiant: http://www.rcfunge98.com/mvrs.f98 http://www.rcfunge98.com/mvrs2.f98
18:10:20 -!- shachaf has quit (Ping timeout: 272 seconds).
18:10:21 <myndzi> well congrats, this is not only super complicated but also successful
18:10:21 <elliott> (Former requires latter)
18:10:25 <Vorpal> "SMEM"0x534d454dSysV IPC Shared Memory
18:10:30 <Vorpal> elliott, you will do that one right?
18:10:34 <elliott> Vorpal: ABSOLUTELY
18:10:37 <Deewiant> Yes, I know he uses two files
18:10:39 <Vorpal> "SMPH"0x534d5048SysV IPC Semaphores
18:10:39 <elliott> Probably.
18:10:40 <Vorpal> that too
18:10:46 <Vorpal> elliott, from haskell? shared memory?
18:10:48 <Vorpal> what the hell
18:10:54 <elliott> Deewiant: So do you need to Mycology it?
18:10:55 <myndzi> thanks for commenting it well ;D
18:11:01 <elliott> Vorpal: You can use libc from Haskell, dude.
18:11:04 <elliott> And other C functions.
18:11:08 -!- BeholdMyGlory has joined.
18:11:12 <elliott> Vorpal: And it has extensive support for pointers.
18:11:15 <elliott> As part of the FFI.
18:11:28 <elliott> This is because Haskell is awesome.
18:11:37 <Vorpal> elliott, oh interesting. Now I have an urge to write something using ioctls in haskell.
18:11:47 <elliott> Good luck :P
18:11:56 <elliott> NCRS will be fun because ncurses is half macros!
18:12:00 <elliott> FUN FUN FUN
18:12:02 <elliott> FUUUUUUUUUUN
18:12:07 <Vorpal> elliott, yes indeed. Deewiant complained about that too
18:12:20 <Vorpal> elliott, and I say fuck it as well. #define clear() ...
18:12:21 <Vorpal> yeah right
18:12:30 <Deewiant> I ended up writing a C wrapper, it was the least painful way
18:12:31 <Vorpal> ever heard about PREFIXING IDENTIFIERS?
18:12:32 <elliott> Who made NCRS
18:12:33 <Vorpal> NO?
18:12:41 <myndzi> interestingly, careless beats it (and all the defend programs, really), i didn't quite expect that
18:12:43 <elliott> Vorpal: Be kind, curses is ancient vintage software.
18:12:44 <Vorpal> elliott, wasn't it that other one. Whatever the name was
18:12:52 <Deewiant> Jesse van Herk
18:12:53 <elliott> myndzi: ais523 says he can fix it but he's worried that it'd be cheating
18:12:57 <elliott> Deewiant: Oh right.
18:12:59 <myndzi> haha
18:13:03 <myndzi> i know how to fix it too
18:13:10 <myndzi> i'm just surprised nobody's done it yet
18:13:17 <elliott> Vorpal: curses was 1979/1980 or so
18:13:17 <myndzi> well, at least how to get a good advantage on it
18:13:22 <elliott> So it's unsurprising that the API is unprefixed :P
18:13:24 <Vorpal> elliott, fixing what?
18:13:31 <elliott> Vorpal: defend13 to beat careless
18:13:33 <elliott> I think ais523 should do it :P
18:13:37 <myndzi> but then we'd get into a modification war so i guess i don't blame him
18:13:57 <Vorpal> elliott, true but the X/Open or whatever spec for curses does allow you to use functions for those macros iirc. But I guess the identifier collision would be even worse then
18:13:58 <ais523> myndzi: I tried the careless strategy before, but it didn't work then, or maybe I screwed it up somehow
18:14:27 -!- shachaf has joined.
18:14:29 <Vorpal> ais523, what is it that would be cheating?
18:14:30 <ais523> it strikes me as being an interesting thing to do in defence programs, to do only a partial rather than full tape-clear in order to beat other defence programs trying to tape-clear at the same time due to expired timers
18:14:40 <elliott> Vorpal: modifying defend13 just to beat careless
18:14:44 <ais523> Vorpal: adding a few + commands to the start of defend13 in order to beat careless
18:14:49 <myndzi> it's not a defense program
18:14:55 <myndzi> it's a fast attack program that doesn't use loops
18:14:56 <ais523> I know it isn't
18:15:06 <myndzi> oh, i misread what you meant
18:15:11 <Vorpal> ais523, I'm not sure how that is cheating?
18:15:13 <ais523> but I think the strategy might be viable in defense programs too
18:15:18 <myndzi> probably so
18:15:20 <ais523> I was wondering about it as a defence10 variant
18:15:23 <Vorpal> also what is the strategy of careless?
18:15:27 <myndzi> it's not very thorough however
18:15:28 <ais523> (it wouldn't work well as a variant to 7)
18:15:34 <elliott> @hoogle [a] -> Int -> Maybe a
18:15:35 <lambdabot> Prelude (!!) :: [a] -> Int -> a
18:15:35 <lambdabot> Data.List (!!) :: [a] -> Int -> a
18:15:35 <lambdabot> Data.List genericIndex :: Integral a => [b] -> a -> b
18:15:38 <elliott> Gah
18:15:38 <myndzi> careless doesn't care if it wins or not
18:15:42 <myndzi> it just plows on ahead
18:15:42 <myndzi> ;)
18:15:43 <ais523> Vorpal: it changes every cell that could be the flag approximately 128 times
18:15:44 <myndzi> thus the name
18:15:44 <elliott> And length will be slow
18:15:54 <myndzi> it jumps out 10 cells, attacks fast then tries to finish, repeat
18:15:54 <Vorpal> elliott, length for?
18:16:03 <ais523> it's like the extreme opposite of an offset clear
18:16:09 <elliott> Vorpal: environment
18:16:13 <Vorpal> elliott, ah
18:16:19 <myndzi> with a little help from a 0-check
18:16:36 <myndzi> to speed it through empty cells
18:16:47 <myndzi> that's the thing that really helped it out
18:16:55 <myndzi> it beats defend because it can't be trapped
18:17:01 <myndzi> and the 0-check loops it around if it fails, i guess
18:17:04 <elliott> ais523: come on, fix defend13 :)
18:17:09 <Vorpal> myndzi, wouldn't do very well against defenders? Though I guess it would do well against attack programs
18:17:12 <myndzi> and it's fast enough that it can move the cell value
18:17:24 <myndzi> i made it to counter defend-style programs
18:17:30 <myndzi> it beats all of ais's, and a bunch of impomatic's
18:17:37 <myndzi> i don't know which of impomatic's are defenders from the names though
18:17:43 <elliott> it wouldn't beat attackers
18:17:46 <elliott> since attackers are usually fast
18:17:49 <Vorpal> myndzi, wouldn't beat a shudder though
18:17:49 <elliott> and it's very slow
18:17:51 <ais523> I see impomatic made a program that beat all of his other programs, and didn't do well against many others
18:17:53 <myndzi> it's faster than most attackers too
18:18:05 <myndzi> shudder is stupid and i don't care if i beat it
18:18:09 <myndzi> it'll fall off the hill soon enough
18:18:28 <Vorpal> myndzi, sure. But nothing wrong with simple ones
18:18:31 <myndzi> i could probably make it beat them though
18:18:42 <myndzi> no, nothing wrong with simple ones, i just don't care if it doesn't beat that particular one
18:18:46 <Vorpal> right
18:18:49 -!- impomatic has joined.
18:18:52 <ais523> oh, hi impomatic
18:19:04 <Vorpal> myndzi, that you called it stupid made it look like you disliked the simple ones
18:19:11 <impomatic> Hi :-)
18:19:19 <myndzi> no, just simple ones that don't do anything
18:19:26 <Vorpal> myndzi, that would be .
18:19:28 <ais523> careless is weird in that it's trivially counterable, and trivially adjustable to avoid that method of making it counterable at the cost of slowing it down slighlty
18:19:30 <impomatic> ais523: nice score from defend13 ;-)
18:19:31 <Vorpal> myndzi, ;P
18:19:33 <ais523> thanks
18:19:36 <myndzi> rolleyes :P
18:19:41 <ais523> so I'd say that it's a valid program strategy
18:19:43 <elliott> lol #haskell are all
18:19:49 <elliott> WHY DO YOU WANT TO ACCESS A SPECIFIC INDEX OF THE NEIVORNMENT
18:19:50 <elliott> and i'm like
18:19:54 <elliott> it's not my fault
18:19:56 <myndzi> ais523: yeah, but i don't want to call attention to it because i don't want to have to do that haha
18:19:56 <elliott> don't blame me :(
18:20:05 <myndzi> i don't want to be in another optimize war
18:20:12 <myndzi> i accidentally did it in butter though
18:20:13 <Deewiant> Yeah, I get a lot of that too when I complain about stuff in Tango
18:20:16 <myndzi> then fixed it
18:20:16 <elliott> <hpc> oh god, it's homework isn't it?
18:20:18 <Deewiant> "WHY" "Because I have to"
18:20:25 <Vorpal> Deewiant, how do you do it in ccbi
18:20:29 <elliott> I've just linked them to the EVAR spec to shut them up
18:20:29 <myndzi> haha butter isn't positive anymore
18:20:33 <myndzi> but i don't care, it beats shudder programs!
18:20:36 <Vorpal> Deewiant, it isn't like you have char **environ is it?
18:20:44 <myndzi> and a surprising number of others, really
18:20:45 <ais523> impomatic: defend13 is a cross between my strategies of mathematical defence loops, myndzi's of trying multiple defense strategies in order to beat multiple styles of opponents, and yours of doing something different after a timeout
18:20:52 <Deewiant> Vorpal: setenv / SetEnvironmentVariableA
18:20:54 <ais523> I did a lot of experimenting into doing timeouts that wouldn't kill egobot, btw
18:20:55 <Vorpal> elliott, wait you could do this with the FFI. char **environ
18:21:01 <Vorpal> Deewiant, for index I meant
18:21:05 <myndzi> anyway, finally off the phone with comcast and super late for work
18:21:11 <ais523> if a loop contains no [ or ], it's best to do it as ()*9999 or whatever
18:21:17 <myndzi> good job once more ais, pretty nice work
18:21:19 <Vorpal> Deewiant, or didn't you mean integer index?
18:21:19 <Deewiant> Vorpal: environ / GetEnvironmentVariablesA (or whatever it's called, don't remember that one)
18:21:24 <elliott> <hpc> wow
18:21:24 <elliott> <hpc> a funge interpreter
18:21:30 <ais523> if it does contain [], it's best to put it inside several nested ()* loops, as in ((([])*5)*5)*5
18:21:43 <ais523> I'm not sure offhand why egojoust finds those less problematic, but it does
18:22:08 <Vorpal> ais523, what if you want a single [] though...
18:22:11 * elliott considers referring hpc to here, decides he's mentioned #esoteric enough in #haskell
18:22:16 <myndzi> (to be clear, i didn't actually enter any programs with the idea he mentions, i just suggested it to him because it seemed up his alley ;)
18:22:46 <Vorpal> elliott, how do you NORMALLY get env vars in haskell? For use in y and such
18:22:55 <Deewiant> Vorpal: He can get them, he can't modify them
18:23:06 <elliott> <xplat> so you have legacy software in befunge that needs supported?
18:23:09 <elliott> Vorpal: System.Environment
18:23:14 <Vorpal> Deewiant, what do you do when you want to execute something with a modified environment?
18:23:21 <Vorpal> oh wait, you pass it the environment?
18:23:24 <elliott> Vorpal: I think the process stuff has that... maybe...
18:23:26 <elliott> If not: You don't.
18:23:32 <elliott> To modify: System.Posix.Env :-P
18:23:33 <ais523> elliott: that xplat quote deserves to be added to `addquote
18:23:43 <Vorpal> hm
18:23:44 <elliott> `addquote <xplat> so you have legacy software in befunge that needs supported?
18:23:45 <HackEgo> 302) <xplat> so you have legacy software in befunge that needs supported?
18:23:46 <elliott> you're welcome, ais523
18:23:52 <ais523> thanks
18:23:57 <Vorpal> <elliott> <xplat> so you have legacy software in befunge that needs supported? <-- was that... serious?
18:24:02 <elliott> Let me know when you buy a keyboard with a ` key, ais523
18:24:04 <myndzi> by the way, i also like the use of the nonzero-check
18:24:05 <elliott> Vorpal: No.
18:24:15 <Vorpal> elliott, *phew*
18:24:16 <ais523> elliott: my ` key is to the left of spacebar
18:24:28 <Vorpal> <elliott> Let me know when you buy a keyboard with a ` key, ais523 <-- "<ais523> elliott: that xplat quote deserves to be added to `addquote" <-- notice the ` there?
18:24:33 <elliott> ais523: What key in "`addquote " can't you type, then
18:24:34 <elliott> :-P
18:25:00 <elliott> Woo, EVAR works
18:25:02 <ais523> myndzi: which one? or don't I understand what you mean?
18:25:06 <ais523> every loop in BF is a nonzero-check
18:25:21 <Vorpal> ais523, I think he joked about you asking it to be added instead of doing it yourself
18:25:25 <myndzi> i mean
18:25:26 <elliott> Deewiant: Do you implement FORK :-D
18:25:30 <myndzi> the "reverse tripwire"
18:25:32 <ais523> Vorpal: it was wanting a second opinion
18:25:34 <ais523> myndzi: ah
18:25:37 <ais523> that really needs a better name
18:25:40 <myndzi> (which i like better than "anti")
18:25:44 <myndzi> inverse
18:25:45 <myndzi> perhaps
18:25:48 <myndzi> anyway, got to go
18:25:49 <ais523> yep, inverse tripwire might do
18:25:51 <myndzi> happy fucking
18:25:52 <Deewiant> elliott: I don't implement much of the new stuff, in particular the system-level stuff
18:25:52 <myndzi> ;p
18:26:10 <elliott> The system-level stuff is the easy stuff :P
18:26:27 <elliott> I'll do HRTI now, seems easy enough
18:26:31 <impomatic> Has anyone used a Rabbit 2000?
18:26:32 <Vorpal> elliott, I can't imagine sysv shm being easy in haskell.
18:26:32 <Deewiant> In particular stuff like FORK which is hard to do cross-platform.
18:26:44 <elliott> Vorpal: As easy as Haskell + constant overhead of FFI stuff.
18:26:55 <elliott> rm
18:26:56 <elliott> erm
18:26:59 <elliott> Vorpal: As easy as C + constant overhead of FFI stuff.
18:27:04 <elliott> Or linear overhead, I guess
18:27:10 <Vorpal> elliott, do you know how painful sysv shm is in *C*?
18:27:19 <elliott> "As easy" could be "very hard".
18:28:07 <Vorpal> elliott, so the only thing that can really halt the FFI is the macroness of ncurses?
18:28:12 <elliott> DING DING DING DEPENDENCY ADDED
18:28:17 <elliott> Vorpal: That would be a pain, yes.
18:28:23 <elliott> Vorpal: I'd probably just use an ncurses binding.
18:28:31 <Vorpal> elliott, seems sane
18:28:35 <Vorpal> @hoogle ncurses
18:28:36 <lambdabot> No results found
18:28:41 <Vorpal> @hoogle curses
18:28:41 <lambdabot> No results found
18:28:50 <elliott> <mux> xplat: that's normal: getenv() is in the C standard, setenv() is only in POSIX
18:28:50 <elliott> <mux> xplat: so it totally makes sense for Haskell to only export setEnv in System.Posix.env
18:28:52 <Vorpal> wait, how do you search hackage with it
18:28:52 <elliott> >_< Stupid C
18:28:55 <elliott> Vorpal: You don't
18:29:01 <elliott> (Pertinent: <zygoloid> why should a /language/ standard (for a language other than haskell) be more significant than an /operating system/ standard?)
18:29:02 <Vorpal> elliott, oh. Boring.
18:29:06 <elliott> @hackage
18:29:06 <lambdabot> http://hackage.haskell.org
18:29:19 <ais523> elliott: "other than haskell"
18:29:38 <elliott> ais523: ?
18:29:40 <Vorpal> "hayoo", "hoogle" <-- why these lame puns.
18:29:45 <ais523> I'm mentioning your quote
18:29:56 <elliott> Vorpal: Hoogle came first
18:30:03 <elliott> Hayoo came after Hoogle got popular
18:30:05 <elliott> ais523: What about it?
18:30:13 <Vorpal> elliott, that doesn't really justify the lame pun bit for either
18:30:29 <Vorpal> elliott, anyway, there seem to be a handful of bindings yeah
18:30:54 <ais523> elliott: I was wondering why he thought Haskell standard > OS standard > other lang standards
18:30:56 <ais523> it seems rather specific
18:31:03 <Vorpal> elliott, UI.HSCurses and UI.NCurses at least
18:31:09 <elliott> ais523: because Haskell is defined independent of C
18:31:16 <ais523> so are several other langs?
18:31:31 <elliott> ais523: so why should C dictate Haskell's libraries?
18:31:52 <ais523> oh, I didn't realise it was in refernce to Haskell's libraries
18:32:09 <ais523> I thought he was saying you should care more about what Haskell does than what Funge does in your interp
18:33:00 <elliott> Gah, HRTI stuff for Haskell is Unix-specific
18:33:12 <elliott> "WINDOWS reference: !! This early version is posix-only and does not build on Windows. Support will be added in the future. !!
18:33:13 <elliott> "
18:33:19 <Vorpal> elliott, you could try TERM. It could be done with just raw control codes if you want to avoid ncurses. Though that isn't very portable of course
18:33:23 <elliott> Vorpal: Ew.
18:33:41 <Vorpal> elliott, I mean, you do want to run it on old non-vt100 style terminals right?
18:33:51 <elliott> Har har har
18:34:11 <elliott> @hackage clock
18:34:11 <lambdabot> http://hackage.haskell.org/package/clock
18:34:12 <Vorpal> elliott, this one you probably need FFI for: http://www.rcfunge98.com/rcsfingers.html#REXP
18:34:33 <Vorpal> elliott, reason is that those flags are pretty much the exact ones found in the posix regexp stuff
18:34:38 <elliott> This backend provides a Haskell interface for the "posix" c-library that comes with most operating systems, and is provided by include "regex.h". This c-library probably also drives command line utilities such as sed and grep.
18:34:45 <elliott> regex-posix
18:34:51 <Vorpal> elliott, ah right
18:34:54 <elliott> [["Posix" is in quotes since it is often not fully Posix compliant and may be buggy (as on OS X, where the bug also affects sed).
18:34:54 <elliott> And the c-library has what I call impossibly-slow performance, as in at least 100x slower than other regex engines.]]
18:35:20 <Vorpal> elliott, that depends on implementations
18:35:34 <elliott> -- fucking unportable Haskell libraries
18:35:35 <elliott> import System.Posix.Clock
18:35:38 <elliott> --HRTI.hs
18:35:49 <quintopia> thx ais523
18:35:57 <Vorpal> elliott, doesn't it provide a portable clock API?
18:36:12 <elliott> Vorpal: Not a high-resolution one.
18:36:20 <elliott> Well...
18:36:24 <elliott> I think the time library goes down to picoseconds.
18:36:28 <ais523> quintopia: what are you thanking me for, btw?
18:36:35 <Vorpal> elliott, that should be enough?
18:36:56 <elliott> Vorpal: well maybe
18:37:21 <elliott> Vorpal: but it also has hour/minute fields
18:37:22 <elliott> so -> bitch
18:37:46 <Vorpal> elliott, I don't think it has to be unix time?
18:37:52 <elliott> gah, microseconds, but the posix api is nanoseconds since second
18:37:55 <elliott> fuck this, HRTI is done later
18:38:01 <elliott> Vorpal: I mean I'd have to handle rollover
18:38:02 -!- Sgeo_ has joined.
18:38:05 <Vorpal> elliott, what. It is just some basic scaling factors?
18:38:14 <elliott> Vorpal: I'm lazy and the API sucks anyway
18:38:21 <Vorpal> elliott, which API?
18:38:31 <elliott> POSIX :P
18:38:40 <elliott> ais523: are you sure there's no perl API call to eval a string? :-)
18:39:09 <ais523> elliott: no, but... you'd have to initialise a new perl interp from inside the C, and tell it to eval the string
18:39:16 <ais523> which is pretty much identical to just using perl(1)
18:39:27 <elliott> Deewiant: Didn't you have some crazy way to pass the string to perl?
18:39:37 <elliott> I suppose perl -e 'print (expr)' isn't enough
18:39:47 <elliott> What about
18:39:51 <elliott> perl -e 'print eval("expr")'
18:39:52 <Vorpal> elliott, uh I can't find where you have to handle rollovers
18:39:55 <Deewiant> It's mostly fizzie's, you can look it up
18:39:57 <Deewiant> In the source
18:40:09 <elliott> Vorpal: osjidgfhgohjdpfosgnsipfdbojker
18:40:11 <elliott> Vorpal: the time package
18:40:12 <elliott> provides the result
18:40:13 <elliott> in
18:40:20 <Vorpal> elliott, I thought you said the POSIX one
18:40:21 <elliott> (hours,minutes,seconds-up-to-picoseconds-as-fixed-precision)
18:40:22 <Vorpal> okay
18:40:24 <elliott> >_<
18:40:27 <elliott> This was for if I wasn't using it
18:40:33 <Vorpal> right
18:40:50 <Vorpal> elliott, PERL is a bit complex to get right with regards to file descriptors
18:41:25 <ais523> ah, Emacs' brainfuck-mode is so useful for BF Joust
18:41:28 <elliott> Vorpal: Why does that matter
18:41:28 * Vorpal reads cfunge code
18:41:39 <elliott> ais523: s/Emacs'/my/ surely
18:41:46 <ais523> well, yes, I wrote it
18:42:20 <Vorpal> Deewiant, what on earth is .txz?
18:42:24 <oerjan> <elliott> I've just linked them to the EVAR spec to shut them up <-- "ok it's not homework, he's just insane"
18:42:32 <Deewiant> Vorpal: You've asked that before.
18:42:35 <Deewiant> .tar.xz.
18:42:37 <Vorpal> Deewiant, aha
18:42:39 <elliott> oerjan: precisely!
18:42:39 <ais523> instead of trivially tweaking defend13 to beat careless, I'm detecting careless-style programs in order to beat them altogether
18:42:54 <Vorpal> Deewiant, I'm sure you don't remember everything either
18:43:07 <elliott> Hey Vorpal
18:43:11 <elliott> Do you implement MKRY?
18:43:12 <elliott> I forget
18:43:27 <Vorpal> I don't
18:43:28 <ais523> elliott, I'm sure you don't remember everything either
18:43:55 <elliott> ais523: ?
18:43:58 <elliott> That's what I was trolling Vorpal for :P
18:44:01 <ais523> elliott: yep
18:44:10 <ais523> I was trolling the entire conversation
18:44:11 <elliott> Anything that the Perl program writes to stdout or stderr is captured and
18:44:11 <elliott> redirected to the Funge program's stdout. Trying to forcibly write to
18:44:11 <elliott> stderr from within the Perl (through tricks such as 'open($my_stderr,
18:44:11 <elliott> ">&2")') is deemed undefined behaviour and you do so at your own risk.`
18:44:16 <elliott> Deewiant: I don't see any need for this
18:44:25 <elliott> Deewiant: Where does PERL say that output to stdout works properly
18:44:39 <Deewiant> Where does it say that it doesn't? :-P
18:44:40 <elliott> Is it in the Cat's Eye fingerprint test suite now on rcfunge's website?
18:45:32 <Vorpal> elliott, it says "the result of the call"
18:45:33 <elliott> Deewiant: Where does it say that writing to stderr by doing open($my_stderr,">&2") doesn't work
18:45:43 <Vorpal> elliott, it doesn't say "the output of the call"
18:45:50 <elliott> ais523: Got a tutorial on the C perl API anywhere?
18:45:58 <ais523> perldoc perlxstut
18:46:01 <ais523> I think
18:46:07 <Deewiant> elliott: In my code
18:46:28 <Vorpal> Deewiant, you use the C Perl API instead of calling it?
18:46:42 <elliott> Deewiant: Har har har
18:46:44 <Deewiant> I wasn't aware such an API existed until elliott mentioned it today
18:46:49 <Vorpal> ah
18:46:58 <elliott> I'm going to use it because CCBI's code looks like a mess :-P
18:47:03 <Vorpal> elliott, anyway here is why you have to preserve stdout:
18:47:14 <Vorpal> "The result of the call is pushed as a 0gnirts string back onto the stack."
18:47:30 <Vorpal> elliott, notice that is "result of call" as in "return value", not as in "standard output"
18:47:36 <elliott> Yes, I realise.
18:48:04 <elliott> <elliott> Using the FFI to talk to perl's C API to implement a Funge interpreter. Where did I go wrong?
18:48:12 <Vorpal> elliott, here is what I do basically, and I think I got most of it from fizzie: perl -e "open(CFUNGE_REALERR, \">&STDERR\"); open(STDERR, \">&STDOUT\"); print CFUNGE_REALERR eval($ARGV[0])" <perl code sent as argument here>
18:48:21 <elliott> CFUNGE_REALERR. Enterprisey.
18:48:28 <elliott> Our first extension will be very simple. When we call the routine in the extension, it will print out a well-known message and return.
18:48:28 <elliott> Run ""h2xs -A -n Mytest"". This creates a directory named Mytest, possibly under ext/ if that directory exists in the current working directory. Several files will
18:48:28 <elliott> be created under the Mytest dir, including MANIFEST, Makefile.PL, lib/Mytest.pm, Mytest.xs, t/Mytest.t, and Changes.
18:48:34 <elliott> No, perl, I want to do it without any automatic shit
18:48:38 <Vorpal> elliott, you need to swap around file descriptors :P
18:48:47 <elliott> ais523: this seems to be rather a guide to making perl extension modules >_<
18:49:14 <elliott> Add the following to the end of Mytest.xs:
18:49:14 <elliott> int
18:49:14 <elliott> is_even(input)
18:49:14 <elliott> int input
18:49:14 <elliott> CODE:
18:49:15 <elliott> RETVAL = (input % 2 == 0);
18:49:16 <ais523> elliott: it is, that's what the API's generally used for
18:49:16 <elliott> OUTPUT:
18:49:18 <elliott> RETVAL
18:49:22 <elliott> What the fuck.
18:49:26 <elliott> That.... I... what.
18:49:29 <elliott> That's not C.
18:49:33 <ais523> it's preprocessed
18:49:39 <elliott> This is hideous.
18:49:41 <ais523> because the actual internals of the API aren't human-consumable
18:49:45 <Vorpal> indeed
18:49:52 <elliott> This is the most hideous.
18:49:55 <Deewiant> Hah
18:49:58 <elliott> ais523: Great. Those are the bits I need :-P
18:50:02 <quintopia> ais523: for writing two programs today that don't beat the awesome jouster i wrote last night thereby moving me up the scoreboard to 4th place without having to do anything :P
18:50:03 <Deewiant> Who would've thought, Perl's API is a hideous mess
18:50:03 <ais523> try perldoc perlint, I think
18:50:06 <ais523> although it isn't a tutorial
18:50:11 <ais523> quintopia: heh
18:50:11 <Sgeo_> Today, my group is doing stuff with spreadsheets
18:50:15 <elliott> Deewiant: The great thing is, I can claim that Perl is shelled
18:50:24 <elliott> Deewiant: I just have to initialise the interpreter on fingerprint load
18:50:27 <Vorpal> elliott, and I thought the damn python C API was an abomination. But it pales into insignificance when compared to what you just pasted!
18:50:42 <elliott> No documentation found for "perlint".
18:50:58 <Vorpal> <ais523> because the actual internals of the API aren't human-consumable <-- why
18:51:00 <quintopia> ais523: also, it would appear i am your archnemesis, since you couldn't beat either of my other two "real" programs either
18:51:10 <Vorpal> wait true python API does macro stuff too
18:51:14 <Vorpal> but that is just C macros
18:51:17 <elliott> aha
18:51:18 <elliott> ais523: perlembed
18:51:19 <Vorpal> not that sort of insane stuff
18:51:20 <elliott> http://search.cpan.org/~rjbs/perl-5.12.3/pod/perlembed.pod
18:51:21 <elliott> perlembed - how to embed perl in your C program
18:51:28 <elliott> If you have trouble compiling the scripts in this documentation, you're not alone. The cardinal rule: COMPILE THE PROGRAMS IN EXACTLY THE SAME WAY THAT YOUR PERL WAS COMPILED. (Sorry for yelling.)
18:51:30 <Deewiant> elliott: Yes, that's what I'd expect you to do if you're using the API :-P
18:51:30 <ais523> ah, that's not the API at all, but on the other hand it's probably what you want
18:51:48 <oerjan> @hoogle maybeToList
18:51:48 <lambdabot> Data.Maybe maybeToList :: Maybe a -> [a]
18:51:48 <elliott> ais523: I like how it tells me to do `perl ...`.
18:51:52 <elliott> I guess I'll have to abandon ghc --make soon.
18:51:55 <Vorpal> elliott, it is likely to be macro heavy still
18:51:57 <oerjan> er wait
18:52:06 <oerjan> @hoogle listToMaybe
18:52:06 <lambdabot> Data.Maybe listToMaybe :: [a] -> Maybe a
18:52:10 <oerjan> elliott: ^
18:52:17 <oerjan> that + drop (n-1)
18:52:32 <elliott> oerjan: Welcome to five years ago?
18:52:44 <oerjan> (also listToMaybe = mplus, i think)
18:52:48 <elliott> It's drop n, anyway
18:53:02 <oerjan> elliott: hm right
18:53:25 <elliott> * sproingie ponders, staticly typed Befunge. StrongFunge.
18:53:27 <elliott> NEVER LET HIM NEAR US
18:53:37 <elliott> <edwardk> spoingie: we need dependently typed strongfunge
18:53:38 <elliott> oh dear god
18:53:57 <ais523> why not have a statically typed funge?
18:54:06 <elliott> ais523: yay, I Have to do "PERL_SYS_INIT3(&argc,&argv,&env)"
18:54:08 <elliott> *have
18:54:12 <elliott> that sounds like funs!
18:54:16 <elliott> plural funs
18:54:25 <elliott> WHY DOES PERL_PARSE TAKE ARGC AND ARGV
18:54:27 <elliott> OH
18:54:28 <elliott> I SEE
18:54:30 <elliott> *lowercase
18:54:32 <oerjan> ais523: YOU invent the type checker then
18:54:33 <Vorpal> <elliott> <edwardk> spoingie: we need dependently typed strongfunge <-- awesome
18:54:42 <elliott> <aristid> what about strongly typed unlambda?
18:54:45 <elliott> <aristid> that's another big market segment, and closer to haskell's spirit
18:54:53 <ais523> oerjan: it'd need to be a funge designed to be easier to compile, I think
18:54:58 <Vorpal> elliott, it will be easier to just exec perl
18:55:03 <elliott> <elliott> But Unlambda is impure!!!
18:55:03 <elliott> <elliott> Clearly you mean Lazy K.
18:55:13 <oerjan> ais523: that's like an INTERCAL designed to be more mainstream
18:55:23 <ais523> not that there's anything wrong with that
18:55:33 <Vorpal> <ais523> oerjan: it'd need to be a funge designed to be easier to compile, I think <-- you just forgot a key point of befunge
18:55:37 <elliott> Vorpal: But that will fail if someone writes to fd 3.
18:55:39 <ais523> Vorpal: no, I'm aware of it
18:55:46 <ais523> I should have said fungeoid, really
18:56:06 <Vorpal> elliott, 3?
18:56:13 <elliott> Vorpal: Or 42.
18:56:15 <elliott> I haven't decided yet.
18:56:18 <ais523> also, writing comments where the only punctuation mark you can really use is ; is frustrating, and looks bizarre
18:56:29 <Vorpal> elliott, but where did they get that fd from?
18:56:38 <elliott> I just invented it.
18:57:04 <Vorpal> elliott, I mean, don't you need to actually open a fd somehow in perl before using it
18:57:12 <Vorpal> which would presumably check if it was free
18:57:19 -!- pingveno has quit (Ping timeout: 255 seconds).
18:57:31 -!- nescience has joined.
18:57:57 <Vorpal> <elliott> ais523: yay, I Have to do "PERL_SYS_INIT3(&argc,&argv,&env)" <-- that sounds like a macro to me
18:58:02 <elliott> $ perl 42>x; cat x
18:58:02 <elliott> open FOOP,"<&=42";
18:58:02 <elliott> print FOOP "hello\n";
18:58:02 <elliott> close FOOP;
18:58:04 <elliott> darn doesn't work
18:58:51 <nescience> hey gregor
18:59:08 <nescience> I noticed from breakdown.txt that there are four results for bfjoust runs
18:59:14 <elliott> $ perl 42>x; cat x
18:59:14 <elliott> open FOOP, ">&42";
18:59:15 <elliott> print FOOP "hello\n";
18:59:15 <elliott> hello
18:59:15 -!- pingveno has joined.
18:59:16 <elliott> nailed it
18:59:26 <nescience> presumably polarity switches: ++ +- -+ --
18:59:36 <Gregor> nescience: Yes yes, and they're redundant, we know.
18:59:41 <nescience> ok
18:59:51 <ais523> Gregor: EgoBot's BF Joust hg repo seems out of date
18:59:59 <ais523> it has sicilian_defence at the tip, for some reason
19:00:01 <nescience> I figured it'd run twice as fast
19:00:01 <Vorpal> Gregor, heh you could cut time in half by just using ++ and +-
19:00:15 <nescience> lol he just acknowledged that ;)
19:00:25 <ais523> my local copy of egojoust has a command-line param to choose tapelength, and swaps polarity of one of the programs if it's negative
19:00:27 <elliott> my $_SHIRO_FUN = sub { eval($ARGV[0]); }
19:00:27 <elliott> open my $_SHIRO_OUT = ">&42";
19:00:27 <elliott> print $_SHIRO_OUT $_SHIRO_FUN->();
19:00:34 <elliott> *OUT, "
19:00:47 <ais523> also, exits silently if it's between -9 and 9, so I can just use seq -30 30 | xargs -n 1 to run a pair of programs at all lengths and polarities
19:00:58 <elliott> Gregor: Srsly, just make it +- -+.
19:01:00 <Vorpal> elliott, that's a nice solution
19:01:06 <Vorpal> elliott, ... :P
19:01:12 <elliott> Vorpal: ?
19:01:23 <ais523> elliott: do you mean +- ++?
19:01:26 <Deewiant> elliott: Shouldn't it be ++ +-?
19:01:31 <elliott> erm, right
19:01:33 <Vorpal> elliott, 1) nice solution to perl code 2) "..." to +- -+
19:01:35 <elliott> ++ +-
19:01:39 <Gregor> elliott: DUMBASS oh burn
19:01:41 <Deewiant> :-D
19:01:47 <elliott> f u
19:02:00 <elliott> I LIKE THE PART WHERE SYSTEM.PROCESS SUCKS
19:02:03 <nescience> +- -+ are the same
19:02:05 <Gregor> ais523: Now what's this about a repo being out of date?
19:02:09 <nescience> efb
19:02:15 <nescience> phonetyping blol
19:02:22 <ais523> Gregor: I just pulled and updated; apparently "hg tip" lists summary: Adding/updating impomatic_sicilian_defence.bfjoust
19:02:24 <elliott> Deewiant: Can your pipe thing handle fd 42
19:02:25 <nescience> cold fingers too
19:02:30 <ais523> and that definitely isn't the most recent program submitted
19:02:40 <Deewiant> elliott: Beats me
19:02:52 <Gregor> ais523: That's pretty bizarre ... don't care to fix it right now :P
19:02:55 <elliott> "perl api from haskell" -- NO RELEVANT RESULTS
19:03:01 <elliott> Gregor: I think you broke it when doing the new hill
19:03:21 <Gregor> elliott: Probably
19:03:47 <Vorpal> elliott, use the C FFI to call fork() ?
19:03:50 <elliott> You know what, fuck Perl.
19:03:55 <Vorpal> elliott, not sure what the hell that would do to haskell though
19:04:01 <elliott> Vorpal: That would... yeah, no.
19:04:24 <Vorpal> elliott, but since it's C FFI is so wonderful (according to one E. Hird) I'm sure it will handle it
19:04:25 <elliott> BOOL!
19:04:26 <ais523> it's got to be worth a try
19:04:28 <elliott> BOOL looks fucking easy.
19:04:33 <elliott> I'm doing Bool.
19:04:43 <elliott> ais523: no, fork() in Haskell code is the kind of thing that would make GHC's runtime hate you, I think
19:04:44 <Deewiant> The mathy ones are easy in general
19:04:50 <Deewiant> FIXP, FPSP, FPDP, etc.
19:04:58 <Vorpal> yeah
19:05:13 <Vorpal> Deewiant, well FIXP has a snag. Does haskell have long double?
19:05:37 <Deewiant> Why does FIXP need long double
19:06:08 <Gregor> Bleh, repo went all corruptomatic.
19:06:09 <Vorpal> Deewiant, well you could do sin() fixed point :P
19:06:34 <Gregor> ais523: Repull?
19:06:51 <Deewiant> Aren't doubles accurate enough for that? (I haven't bothered looking at the details)
19:06:53 <Ilari> What repo?
19:06:57 <ais523> in_egobot
19:07:12 <ais523> Vorpal: it's not too hard, use the Taylor series
19:07:13 <ais523> Gregor: doing so
19:07:21 <ais523> that looks better, ty
19:07:57 <Vorpal> ais523, "meh"
19:08:28 <elliott> Haskell has long double, it's called Double.
19:08:37 <elliott> Erm.
19:08:41 <elliott> Wait, long double.
19:08:46 <elliott> @hoogle Bool -> Bool -> Bool
19:08:47 <lambdabot> Prelude (&&) :: Bool -> Bool -> Bool
19:08:47 <lambdabot> Prelude (||) :: Bool -> Bool -> Bool
19:08:47 <lambdabot> Data.Bool (&&) :: Bool -> Bool -> Bool
19:08:55 <elliott> I meant xor, stupid search.
19:09:07 <oerjan> "xor"
19:09:15 <Deewiant> @hoogle xor
19:09:15 <lambdabot> Data.Bits xor :: Bits a => a -> a -> a
19:09:19 <Deewiant> elliott: Say what you mean
19:09:24 <elliott> Deewiant: I meant boolean xor.
19:09:30 <Deewiant> elliott: (!=)
19:09:35 <oerjan> */=
19:09:40 <Deewiant> Bleh
19:09:54 <elliott> I like how BOOL's N is just ! from the core.
19:10:38 <Deewiant> elliott: Nope, it's one's complement
19:10:49 <elliott> ...based on what
19:10:51 <Deewiant> If you're doing BOOL you want the Data.Bits stuff
19:10:58 <elliott> THEN WHY IS IT CALLED BOOL
19:10:58 <Deewiant> Based on how it works
19:11:07 <elliott> IT'S NOT BOOL, IT'S BITW
19:12:46 <elliott> :t fmap
19:12:47 <lambdabot> forall a b (f :: * -> *). (Functor f) => (a -> b) -> f a -> f b
19:12:48 <coppro> /win/win 3
19:16:21 <elliott> Dude! Deewiant! Mycology doesn't test BOOL!
19:16:26 <elliott> Unforgivable!
19:16:57 <elliott> Oh well, it passes Mike's test :P
19:19:12 <ais523> defend14 is running locally, I wonder how well it'll do?
19:19:22 <ais523> I added a few extra strategies for it to detect and lock in place, or counter differently
19:20:10 <ais523> but it's going kind-of slowly; it doesn't /quite/ break egojoust, but it's pretty complex
19:20:30 <elliott> ais523: In the year 3000, all BF Joust programs will be at least 3000 lines long, with the top competitors at about 17,000 lines of carefully tweaked code developed by teams. Then someone will come along and submit >[[-]>+] and it'll beat them all.
19:20:41 <ais523> haha
19:20:56 <ais523> don't you mean >+[[-]>+]?
19:20:59 <elliott> er, yes
19:21:03 <Gregor> elliott: Funny since that code moves one step to the --- damn, ais523 got it first :P
19:21:04 <elliott> I was going for defend1, but forgot it
19:21:08 <Gregor> [+right and then quits]
19:21:12 <elliott> Gregor: THAT'S JUST HOW BAD THEY ARE
19:21:34 <ais523> I don't thing >+[[-]>+] can win unless the opponent suicides
19:21:42 <ais523> and it puts a helpful + there so that tripwire-avoiders can also kill it
19:22:05 <quintopia> however....
19:22:06 <elliott> !bfjoust muphry >+[[-]>+
19:22:08 <elliott> oops
19:22:09 <elliott> !bfjoust muphry >+[[-]>+]
19:22:36 <EgoBot> Score for elliott_muphry: 7.8
19:22:36 <EgoBot> Score for elliott_muphry: 7.8
19:23:09 <quintopia> !bfjoust flyingleap >>>>>>>>>>>>>>>+[>[[-]]+]
19:23:21 <elliott> 7.8 both times, classic
19:23:29 <EgoBot> Score for quintopia_flyingleap: 1.6
19:23:33 <quintopia> lul
19:23:54 <Deewiant> !bfjoust bungee >+>>>>>>>>>>>>>>+[>[[-]]+]
19:24:03 <ais523> I'm not sure how well my mindbogglingly slow rush detector will work
19:24:10 <ais523> (or whether it'll actually win after detecting it)
19:24:15 <EgoBot> Score for Deewiant_bungee: 3.1
19:24:21 <Deewiant> !bfjoust bungee >+>>>>>>>>>>>>>>+[[-]>+]
19:24:32 <elliott> !bfjoust but_what_of_faith >->+>-(>)*16((-)*5[-]>+(+)*5[+]>+)*13
19:24:42 <EgoBot> Score for Deewiant_bungee: 2.9
19:24:58 <EgoBot> Score for elliott_but_what_of_faith: 0.8
19:25:01 <quintopia> that's not a proper offset clear elliott. what are you doing.
19:25:08 <elliott> hm
19:25:12 <elliott> why did it do _so_ badly?
19:25:22 <ais523> (-)*5[-]
19:25:27 <ais523> that's like... the opposite of an offset clear
19:25:32 <elliott> oh, duh :D
19:25:48 <elliott> ais523: it would have been hilarious if that worked
19:25:57 <ais523> also, it looks rather like it goes off the end of the tape quite readily
19:25:58 <elliott> !bfjoust but_what_of_faith >->+>-(>)*16((-)*5[+]>+(+)*5[-]>+)*13
19:26:01 <elliott> ais523: thus the name
19:26:04 <elliott> (derived from "leap of faith")
19:26:07 <elliott> (inspired by "flyingleap")
19:26:11 <EgoBot> Score for elliott_but_what_of_faith: 1.0
19:26:23 <ais523> in particularly, the *13 at the end is higher than it needs to be for no reason at all
19:26:29 <quintopia> the idea is that you die on short tape, but on long tape, you skip all of the decoys
19:26:32 <elliott> er, is it?
19:26:34 <elliott> that's a mistake then
19:26:35 <ais523> you may as well stop and do a proper clear if you happen to reach the 30th cell
19:26:39 <Deewiant> The tape length is 20-30
19:26:42 <ais523> Deewiant: *10-30
19:26:48 <Deewiant> Darn
19:27:00 <Deewiant> elliott: So yeah, the (>)*16 is a good way to lower your score
19:27:05 <nescience> apparently faith gets you nowhere
19:27:07 <nescience> ;)
19:27:10 <elliott> oh, it's actually >>*13
19:27:13 <elliott> duh
19:27:40 <ais523> also, it's intruiging why defend9 is doing a lot better than it used to
19:27:45 <ais523> perhaps people have stopped trying to counter it
19:27:52 <elliott> !bfjoust but_what_of_faith >->+>-(>)*15((-)*5[+]>+(+)*5[-]>+)*5(-)*100[-]
19:28:08 <EgoBot> Score for elliott_but_what_of_faith: 1.1
19:28:08 <ais523> (and I'm curious as to whether tripstridewire will ever fall off altogether, or just stay near the bottom indefinitely)
19:28:14 <elliott> 1.1!
19:28:16 <elliott> that's a win in my book
19:28:36 <elliott> !bfjoust but_what_of_faith >->+>-(>)*6((-)*5[+]>+(+)*5[-]>+)*10(-)*100[-]
19:28:42 <quintopia> ais523: taller_towers also beats that one for some reason
19:28:43 <elliott> off-by-ones are my main bug i think usually
19:28:58 <EgoBot> Score for elliott_but_what_of_faith: 18.3
19:29:03 <quintopia> wat
19:29:12 <quintopia> oh
19:29:13 <nescience> lol I was thinking about trying to add some extra >s to careless
19:29:19 <quintopia> you took out the fall-off code
19:29:20 <nescience> to skip a few decoys
19:29:23 <elliott> 18.3!
19:29:24 <elliott> that's not bad
19:29:41 <elliott> !bfjoust but_what_of_faith >->+>-(>)*6((-)*5[++][+]>+(+)*5[--][-]>+)*10(-)*100[-]
19:29:42 <Gregor> !bfjoust turtles_can_fly_but_slowly ((>++>--)*4<<<<)*1000(>)*8-[[+>(+)*128..>(-)*128..-]+]
19:29:46 <elliott> Gregor: best name ever
19:29:47 <ais523> the thing is, adding extra >s gains you as much in skipping decoys as it loses in falling off the tape
19:29:56 <ais523> unless the opponent is leaving a decoy trail, and that's rare nowadays
19:29:57 <elliott> why do all the good players use boring names?
19:29:59 <quintopia> course it's not bad. fast rushers with offset clears do not bad. there is no faith anymore.
19:30:01 <nescience> yeah
19:30:02 <elliott> and all the bad players use awesome names
19:30:05 <elliott> what's up with that
19:30:10 <elliott> nescience: i'm counting on you to start using some of this good name juice
19:30:13 <nescience> I was just curious what would happen
19:30:17 <ais523> although I will point out that it falls off the end of the tape quite aerly
19:30:24 <nescience> what, I like my names
19:30:34 <nescience> I like good words and simple names
19:30:38 <elliott> >_<
19:30:41 <elliott> you all suck
19:30:46 <ais523> I like impomatic's names
19:30:50 <nescience> also non table breaking
19:30:57 <ais523> but I prefer mine to be descriptive so I can easily remember what they did
19:31:01 <EgoBot> Score for elliott_but_what_of_faith: 1.5
19:31:02 <EgoBot> Score for Gregor_turtles_can_fly_but_slowly: 0.0
19:31:06 <ais523> and some are fun, like "decoybooster"
19:31:10 <Gregor> ... wow, really, that bad?
19:31:13 <quintopia> i was looking up chess openings last night, trying to figure out what the sicilian opening had to do with bf joust...
19:31:30 <ais523> Gregor: you repeatedly go right eight times, then left four
19:31:37 <ais523> I'm not entirely sure what that's meant to accomplish, but it won't help much
19:31:39 <Gregor> ais523: Oh, hahahah, I can totally count X-D
19:31:44 <elliott> !bfjoust but_what_of_faith >->+>->+>-->++(>)*3((-)*10[+]>+(+)*10[-]>+)*10(-)*100[-]
19:32:05 <EgoBot> Score for elliott_but_what_of_faith: 19.5
19:32:16 <elliott> 19.5!
19:32:18 <ais523> in_egobot/ais523_defend13.bfjoust vs defend14.bj: 11 (standard): Tie (left loss: flag fell; right loss: flag fell)!
19:32:19 <nescience> maybe I should rename all my programs that are good to have epic names :P
19:32:20 <ais523> now, that's rare
19:32:23 <elliott> decoys are back
19:32:24 <elliott> seriously
19:32:25 <elliott> decoys
19:32:28 <elliott> they're what's for dinner
19:32:31 <ais523> although makes sense, because they both detect each other as defence programs and go symmetrically from there
19:32:45 <elliott> !bfjoust but_what_of_faith >->+>->+>-->++>---->+>--((-)*10[+]>+(+)*10[-]>+)*10(-)*100[-]
19:33:16 <EgoBot> Score for elliott_but_what_of_faith: 19.8
19:33:32 <oerjan> <Gregor> ... wow, really, that bad? <-- this is not Discworld you know
19:33:40 <Gregor> !bfjoust turtles_can_fly_but_slowly ((>++>--)*4<<<<<<<<)*250(>)*8-[[+>[+]..>[-]..-]+]
19:33:43 <elliott> 19.8
19:33:47 <elliott> ais523: do you think this can work :D
19:33:54 <elliott> i really think everybody forgot that decoys exist
19:34:01 <ais523> hmm, looks like 14 is too clever for its own good
19:34:04 <ais523> I probably won't submit it
19:34:08 <ais523> as it wouldn't do too well
19:34:09 <EgoBot> Score for Gregor_turtles_can_fly_but_slowly: 1.5
19:34:10 <elliott> !bfjoust but_what_of_faith >->+>->+>-->++>---->+>--((-)*10[+]>+(+)*10[-]>+)*20(-)*100[-]
19:34:15 <Gregor> >_<
19:34:17 <Gregor> OK, no more flying turtles :P
19:34:18 <quintopia> i don't understand how turtle_rescue_squad hung on so long :P
19:34:47 <EgoBot> Score for elliott_but_what_of_faith: 19.7
19:34:48 <nescience> what do you mean forgot
19:35:00 <nescience> I have decoys in every program I wrote?
19:35:04 <elliott> i just realised that mine doesn't work for tape length >20 or so
19:35:04 <elliott> but eh
19:35:05 <elliott> well
19:35:06 <elliott> doesn't wor kas well
19:35:07 <elliott> so
19:35:11 <elliott> constant tweaking time
19:35:16 <elliott> !bfjoust but_what_of_faith >->+>->+>-->++>---->+>--((-)*10[+]>+(+)*10[-]>+)*17(-)*100[-]
19:35:38 <EgoBot> Score for elliott_but_what_of_faith: 19.7
19:35:54 <elliott> !bfjoust but_what_of_faith >->+>->+>-->++>---->+>--((-)*10[+]>+(+)*10[-]>+)*13(-)*100[-]
19:36:20 <EgoBot> Score for elliott_but_what_of_faith: 19.7
19:36:24 <elliott> meh
19:36:27 <elliott> !bfjoust but_what_of_faith >->+>->+>-->++>---->+>--((-)*10[+]>+(+)*10[-]>+)*10(-)*100[-]
19:36:31 <elliott> just go back to that version
19:36:36 <elliott> !bfjoust
19:36:36 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
19:36:49 <EgoBot> Score for elliott_but_what_of_faith: 19.8
19:36:58 <elliott> ok, i primarily win against Gregor
19:36:59 <elliott> it seems :D
19:38:55 <Gregor> !bfjoust furry_furry_bondage_girls [[(-)*128((+)*10(-)*20(+)*19(-)*18(+)*17(-)*16(+)*15(-)*14(+)*13(-)*12(+)*11(-)*10(+)*9(-)*8(+)*7(-)*6(+)*5(-)*4(+)*3(-)*2(+)*1)*1000(+)*128]+]
19:39:02 <elliott> ...best warrior name ever?
19:39:32 <quintopia> <ais523> wiggle3 leaves a trail behind as it moves <ais523> unless the opponent is leaving a decoy trail, and that's rare nowadays
19:39:47 <elliott> !bfjoust my_name_may_be_super_bat_man_but_my_real_name_is_peter_bruce_parker_wayne >(-)*127>(+)*127>+>->>++>----------->+>+++++[>-[-]>-[+]]
19:39:53 <quintopia> strange. one of the top players leaves a trail, so why is it so rare?
19:40:08 <EgoBot> Score for Gregor_furry_furry_bondage_girls: 15.4
19:40:09 <elliott> quintopia: because we all got lost in meta-strategy
19:40:11 <ais523> quintopia: it's just an observation, not a statement about what ought to be true
19:40:18 <elliott> and the more advanced warriors started not needing decoys
19:40:18 <Gregor> :(
19:40:21 <elliott> because of their strange tactics
19:40:27 <elliott> then when it all blended together and they became less specialised
19:40:32 <elliott> we forgot to start doing decoys again
19:40:51 <EgoBot> Score for elliott_my_name_may_be_super_bat_man_but_my_real_name_is_peter_bruce_parker_wayne: 1.5
19:41:07 <elliott> :(
19:41:18 <elliott> Decoys + modified defend1: NOT THE BEST STRATEGY
19:41:33 <elliott> Gregor_furry_furry_bondage_girls.bfjoust vs elliott_my_name_may_be_super_bat_man_but_my_real_name_is_peter_bruce_parker_wayne.bfjoust:
19:41:33 <elliott> <>>XXXXXXXXXXXXXXXXXX <<>XXXXXXXXXXXXXXXXXX <<>XXXXXXXXXXXXXXXXXX <>>XXXXXXXXXXXXXXXXXX
19:41:34 <elliott> Tie
19:41:41 <quintopia> FWIW, taller_towers also leaves a decoy trail (and it now is beating wiggle3)
19:41:42 <elliott> Gregor: Shit buddies *hi5*
19:41:48 <Gregor> Woooh
19:42:21 <quintopia> Gregor: wtf does FFBG doooooooo?
19:42:31 <elliott> !bfjoust a_more_perfect_union >-[[-]++++>-[+]----->+]
19:42:34 <Gregor> quintopia: It's just a (very bad) shudderer
19:42:41 <quintopia> that's what it looks like :P
19:43:20 <Gregor> !bfjoust even_worse_shudderer (-)*127(.+-)*100000
19:43:59 <Gregor> Err ... wow, yeah that one is bad :P
19:44:04 <quintopia> that's an alternator gregor
19:44:06 <Gregor> Worse than I even intended it to be.
19:44:10 <elliott> a more perfect union is not doing well
19:44:14 <quintopia> but
19:44:18 <elliott> it's a metaphor
19:44:19 <elliott> for america
19:44:19 <quintopia> a sucky alternator i guess
19:44:23 <Gregor> quintopia: I refuse to actually know your terminology.
19:44:46 <quintopia> Gregor: it'll be stridewire :P
19:44:48 <quintopia> *beat
19:45:17 <elliott> "DIRF" 0x44495246
19:45:17 <elliott> C(0gnirts -- )Change directory
19:45:17 <elliott> M(0gnirts -- )Make a directory
19:45:17 <elliott> R(0gnirts -- )Remove a directory
19:45:20 <elliott> Deewiant: Does CCBI do that
19:46:10 <ais523> ah, I found a few bugs in defend14
19:46:31 <ais523> Gregor: is that shuddering between 1 and 2? very slowly?
19:46:46 <Gregor> ais523: Yes X-P
19:46:52 <ais523> why?
19:46:58 <Gregor> ais523: I DON'T KNOW
19:47:41 <elliott> ais523_defend13.bfjoust vs elliott_a_more_perfect_union.bfjoust:
19:47:41 <elliott> <X<X<X<X<X<X<X<X<X<X< X<XXX<XXX<XXX<XXX<XXX X<XXX<XXX<XXX<XXX<XXX <X<X<X<X<X<X<X<X<X<X<
19:47:41 <elliott> ais523_defend13.bfjoust wins
19:47:42 <elliott> ooh
19:47:49 <elliott> n.bfjoust:
19:47:50 <elliott> <<<<<<<<<<<<<<<<<<<<< X>X>X>X>X>X>X>X>X>X>X X>X>X>X>X>X>X>X>X>X>X <<<<<<<<<<<<<<<<<<<<<
19:47:50 <elliott> ais523_defend7.bfjoust wins
19:47:50 <elliott> what
19:48:25 <Gregor> I ... think it's accidentally running two sessions at once ... which should be impossible ...
19:48:38 <Deewiant> elliott: Yes, and Mycology tests it
19:48:39 <ais523> breakdown's been doing that for a while
19:48:49 <ais523> if you keep refreshing it, it seems to keep writing in the middle of the file, etc
19:48:55 <ais523> the hill itself seems to work, though
19:49:14 <Gregor> Yeah, the hill only uses the cache, it shouldn't care even if there are fifty sessions running at once.
19:50:16 <EgoBot> Score for Gregor_even_worse_shudderer: 13.7
19:50:17 <EgoBot> Score for elliott_a_more_perfect_union: 5.1
19:50:28 <Gregor> Please hold
19:50:54 <Gregor> Proceed.
19:51:27 -!- nescience has quit (Remote host closed the connection).
19:51:41 <elliott> Gregor: How did it...
19:51:43 <elliott> 13.7... how
19:52:14 -!- ais523 has quit (Read error: Operation timed out).
19:52:20 <elliott> !bfjoust absolutely_fucking_nothing (+)*127(-++-)*10000
19:52:23 <Gregor> Man, anything that beats defend13 gets shitloads of points.
19:52:26 <elliott> X-D
19:52:32 <elliott> As I said, I'm so tempted to write antidefend13.
19:52:38 <elliott> That just targets defend13 and nothing else.
19:52:48 <elliott> UNDEF: either C doesn't work or the 'mycodirf' directory doesn't exist
19:52:51 <elliott> You don't say
19:53:12 <elliott> GOOD: created 'mycodirf' with M
19:53:12 <elliott> GOOD: entered 'mycodirf' directory with C
19:53:12 <elliott> GOOD: left 'mycodirf' with a C to '..'
19:53:12 <elliott> GOOD: can't C into 'mycodirf' after R
19:53:12 <elliott> GOOD: created 'mycodirf' with M
19:53:13 <elliott> Removed 'mycodirf' with R.
19:53:15 <elliott> Why the duplication, to check remaking works?
19:53:31 <Gregor> I don't think that targeting any one competitor will be good enough, but if you targeted the top three you could probably do well.
19:53:39 <Deewiant> Probably, y es.
19:53:44 -!- ais523 has joined.
19:53:47 <elliott> Fingerprints/BOOL.hs Fingerprints/MODU.hs Fingerprints/ROMA.hs
19:53:47 <elliott> Fingerprints/DIRF.hs Fingerprints/NULL.hs
19:53:47 <elliott> Fingerprints/EVAR.hs Fingerprints/REFC.hs
19:53:48 <elliott> Doin' good
19:53:50 <elliott> wow, ais523 was gone?
19:53:57 <elliott> I'm going to do EMEM next.
19:53:58 <Deewiant> For 90 seconds.
19:53:59 <ais523> connection issues
19:54:04 <ais523> I didn't leave on purpose
19:54:15 <Deewiant> I refuse to do EMEM because it's just malloc, and goes against all that is Fungy :-P
19:54:23 <Gregor> ais523: 's too bad since we just knocked defend13 off the hill while you were gone.
19:54:37 <ais523> Gregor: it doesn't /run/ fast enough to get knocked off the hill that quickly
19:54:38 <elliott> "As far as implementing this, hnd can be the direct pointer if it fits within the cell size of the interprter, or else a seperate list can be maintained and this would be the handle into the list."
19:54:42 <elliott> Yay, more handles.
19:54:46 <Gregor> :P
19:54:55 <ais523> in fact, you knocked it above careless
19:55:04 <EgoBot> Score for elliott_absolutely_fucking_nothing: 15.2
19:55:19 <elliott> Err, EMEM is very useless
19:55:21 <ais523> anyway, defend14 now beats careless in one polarity (so draws over all)
19:55:27 <Deewiant> elliott: Precisely :-P
19:55:29 <elliott> Since it offers no way to e.g. do pointer arithmetic
19:55:35 -!- nescience has joined.
19:55:39 <elliott> Deewiant: But hey, uselessness won't stop me.
19:55:40 <ais523> isn't there an alloc-in-fungespace fingerprint?
19:55:42 <ais523> that would be more useful
19:55:52 <Deewiant> There's an alloc-in-fungespace instruction, it's called p
19:55:53 <elliott> ais523: I was going to do fungespace GC but Vorpal was all debbie-downer about it
19:56:16 <quintopia> i think it would be hilarious
19:56:27 <ais523> Deewiant: no, that writes to fungespace; I meant, it finds a bit of unused fungespace that it hasn't allocated
19:56:28 <quintopia> you sure you can do it
19:56:33 <nescience> stupid crashphone!
19:56:33 <elliott> http://www.haskell.org/ghc/docs/6.12.3/html/libraries/base-4.2.0.2/Foreign-Storable.html SEXINESS
19:56:42 <ais523> so you can allocate and deallocate bits of fungespace
19:57:13 <copumpkin> so dependent strongfunge?
19:57:20 <elliott> http://www.haskell.org/ghc/docs/6.12.3/html/libraries/base-4.2.0.2/Foreign-Marshal-Alloc.html
19:57:21 <elliott> MALLOC!
19:57:28 <elliott> copumpkin: :D
19:58:02 -!- Sgeo_ has quit (Ping timeout: 255 seconds).
19:59:03 <elliott> Deewiant: Does anyone actually use all these RC fingerprints
19:59:50 <elliott> Okay, so I just want Ptr Word8.
20:01:18 <Deewiant> elliott: No
20:01:31 <elliott> Deewiant: Kay
20:02:54 <ais523> !bfjoust defend14 http://sprunge.us/DUYc
20:03:00 <ais523> let's hope EgoBot can handle the awesomeness
20:03:13 <ais523> most of its losses are close ones, rather than decisive ones
20:03:18 <ais523> except against quintopia, for some reason
20:04:21 <elliott> we really need lance
20:04:31 <ais523> its main disadvantage is, against most programs, on short tapes
20:04:42 <ais523> also, that the really crazy logic only works on one of the two polarities
20:04:49 <ais523> and on the other one, it just does a defend7 I think
20:05:01 <ais523> ah no, a defend10
20:05:37 <nescience> oshi another defend?
20:05:45 -!- ais523 has quit.
20:06:17 <elliott> counting down from 90 seconds
20:06:23 -!- ais523 has joined.
20:06:25 <oerjan> elliott: lance is your bfjoust interpreter?
20:06:28 <elliott> wb ais523
20:06:31 <elliott> oerjan: yes, the one that never truly got written
20:06:35 <ais523> grr, connection
20:06:35 <elliott> because gregor was faster
20:06:47 <elliott> but it wouldn't have expanded anything because that's stupid
20:07:11 <EgoBot> Score for ais523_defend14: 54.3
20:07:12 <oerjan> indeed
20:07:26 <elliott> oerjan: indeed? you mena that it's stupid?
20:07:28 <ais523> ais523_defend14.bfjoust vs myndzi_careless.bfjoust: <>>>>>>>>>>>>>>>>>>>> <>>>><<<<<<<<<<<<<<<< <>>>><<<<<<<<<<<<<<<< <>>>>>>>>>>>>>>>>>>>> myndzi_careless.bfjoust wins
20:07:29 <oerjan> yes
20:07:49 <ais523> btw, that careless-beating will work against any variation of careless, no matter how much myndzi tweaks the constants
20:07:52 <nescience> do eet elliot
20:07:54 <Deewiant> Another one that beats monorail but loses to steamroller :-/
20:07:55 <ais523> but unfortunately, only on one polarity
20:08:11 <elliott> mind you % is not trivialy
20:08:13 <elliott> *trivial
20:08:22 <elliott> (a[[{c}]d])%n for instance
20:08:38 <oerjan> elliott: it's easy if you have matching
20:08:56 <ais523> heh, 14's actually slightly behind 13
20:09:11 <ais523> because the extra setup it requires means that some programs 13 beats, 14 loses to but only on short tape lengths
20:09:21 <elliott> oerjan: eh?
20:09:43 <elliott> ais523: does the defend13 family of programs place decoys?
20:09:53 <oerjan> elliott: you just keep track of how deeply nested you are in it...
20:10:16 <ais523> elliott: sort-of; defend13 uses three detection cells (tripwires), defend14 uses four
20:10:27 <nescience> it's not that hard to even do unbalanced brackets
20:10:32 <ais523> and they work like decoys, except their values are checked
20:10:44 <ais523> both also have one actual decoy, too
20:10:53 <ais523> umm, no, 13 does, 14 doesn't
20:11:27 <oerjan> elliott: was lance being written in C too?
20:11:51 <elliott> oerjan: well erm yes, purely for the performance aspect, but if you want to contribute some nice haskell code that could be arranged too :P
20:12:16 <oerjan> elliott: i've got a BFJoust.hs window on my screen already
20:12:19 <ais523> anyway, defend13's winning overall on score, defend14 on points
20:12:32 <ais523> so I think I'm dominating the leaderboard both ways
20:12:33 <elliott> oerjan: ofc all the fancy code in the world won't let you run raw bfjoust code faster than C :p
20:12:50 <oerjan> yeah, *sigh*
20:12:52 <elliott> hmm, i think what i just said was heretical
20:13:03 <elliott> oerjan: don't worry. one day ghc will catch up. one day.
20:13:08 <oerjan> well no _elegant_ code, anyway
20:13:13 <ais523> bear in mind that you don't have to run every cycle
20:14:14 <elliott> wat
20:14:33 <ais523> if both programs are looping, and you go back to a previous tape and IP state, you can just skip to the end of the loop
20:14:40 <ais523> or immediately timeout if it's a [] rather than () loop
20:14:49 <ais523> sort-of like hashlife
20:16:52 <ais523> impomatic: was Nyarlathotep designed specifically to beat all your other programs? because it does
20:16:58 <oerjan> hmph my motivation is lousy
20:18:05 <elliott> Deewiant: I just realised how awful EMEM is.
20:18:14 <elliott> Deewiant: it does malloc, not calloc
20:18:14 <Deewiant> Just now?
20:18:14 <elliott> eurgh
20:18:17 <Deewiant> :-)
20:18:21 <elliott> if it was calloc that'd be okay
20:18:22 <elliott> but ew
20:18:24 <elliott> this just breaks...life
20:18:32 <impomatic> ais523: I noticed that too :-( No, not specifically, I just wanted to see what happened if a defender program started defending straight away
20:18:55 <ais523> ah, so it doesn't use a tripwire at all?
20:19:12 <ais523> does it have decoys?
20:20:01 <ais523> heh, shortsword's still on the leaderboard
20:20:02 <ais523> just about
20:20:14 <elliott> !bfjoust aye_said_captain_on_train_of_despair (-)*127[] ... argh, just realised that that doesn't work nay more
20:20:45 <ais523> why would you expect that to work?
20:21:15 <elliott> ais523: because it used to
20:21:16 -!- hiato has joined.
20:21:17 <elliott> before the rules got changed
20:21:20 <elliott> by you :P
20:21:37 <ais523> I don't see how one-cycle death would make that any better than two-cycle death
20:22:21 <elliott> ais523: because ] used to take 0 cycles
20:23:15 <impomatic> ais523: no decoy either, just straight into a defender. No [ ] loops either :-)
20:23:32 <ais523> anyway, I think I know why leaving decoy trails died out
20:23:40 <ais523> it's because they're so vulnerable to offset clear
20:23:59 <quintopia> at least they slow down the offset clearer that uses large offsets
20:24:00 <elliott> !bfjoust my_polarity_brings_all_the_boys_to_the_yard ((-)*64(+)*256)*100000
20:24:17 <ais523> quintopia: not really, they have an equal chance of slowing them down and speeding them up
20:24:43 <elliott> !bfjoust
20:24:43 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
20:24:57 <nescience> well they make them run code
20:25:01 <quintopia> ais523: why so? a good offset clear checks if there's anything there to clear before clearing it...
20:25:03 <elliott> wow, i tie against ais523's defend programs
20:25:05 <nescience> running code is faster than not
20:25:09 <elliott> er, wiat, no
20:25:14 <elliott> I tie to defend10 and 12
20:25:15 <elliott> *wait
20:25:17 <ais523> elliott: even 12 and 13?
20:25:18 <elliott> and lose sildly to 13 and 14
20:25:20 <elliott> *solidly
20:25:20 <EgoBot> Score for elliott_my_polarity_brings_all_the_boys_to_the_yard: 17.8
20:25:24 <elliott> and tie with defend7/9
20:25:28 <ais523> quintopia: oh, most offset clearers I've seen don't
20:25:35 <ais523> although arguably they should
20:25:52 <ais523> offset clear with special cases is what jix's wiggle programs do, and it seemed to work for him
20:26:01 <elliott> !bfjoust my_polarity_brings_all_the_boys_to_the_yard >++>-->++>-->+++>---<<<<<<((-)*64(+)*256)*100000
20:26:06 <elliott> hope i didn't miscount <s there
20:26:09 <ais523> elliott: well, 7,9,10,12 never attack ever; 13/14 do if they think they're playing a defence program
20:26:24 <ais523> and do so using a mechanism that beats most defence and most tripwire programs, but loses to most rush programs
20:26:28 <quintopia> ais523: as long as non-decoy-trail programs dominate the hill, non-zeroness checkers will have an advantage
20:26:29 <nescience> we should be recording innovations
20:26:35 <elliott> ais523: should rename the series to hybrid, then
20:26:37 <elliott> if it can attack
20:26:42 <nescience> I forget who first used offset clearing already
20:26:57 <ais523> it's still a defence program, it just attacks as a last resourt
20:26:58 <nescience> it was from the last active time surely
20:26:59 <ais523> *resort
20:27:00 <EgoBot> Score for elliott_my_polarity_brings_all_the_boys_to_the_yard: 9.2
20:27:02 <ais523> and impomatic
20:27:06 <ais523> shortsword was the first offset clearer
20:27:12 <ais523> with an offset of 1
20:27:22 <ais523> which it used to defeat the decoys of 1 which were all people thought they needed at the time
20:27:23 <nescience> ah
20:27:34 <ais523> that's what lead the innovation of large decoys
20:27:52 <quintopia> and here we are today with SUPERLARGEDECOYS
20:28:01 <Gregor> !bfjoust spin_cycle (+)*100000
20:28:11 <Gregor> (Best evar)
20:28:17 <quintopia> flail
20:28:35 <quintopia> you do know tournaments last 384000 cycles right?
20:28:49 <Gregor> In principle I know that ... in practice, I do not.
20:28:54 <nescience> dunno, there was a lot of churn, i'd sorta like to go look back through :)
20:29:08 <ais523> quintopia: it does indeed say 384000 on the wiki
20:29:14 <ais523> however, egojoust only simulates the first 100000
20:29:18 <ais523> unless I'm using an old version
20:29:25 <EgoBot> Score for Gregor_spin_cycle: 13.8
20:29:28 <quintopia> that would explain gregor's comment
20:29:44 <nescience> too bad there's no mark of the rule changes
20:29:54 <Gregor> ais523: Is that true? :P
20:29:57 <quintopia> not that particular one though
20:30:10 <quintopia> but all the other rule changes for egojoust are on the wiki
20:30:16 <ais523> Gregor: my local egojoust isn't quite the same as the one in the tournament
20:30:16 <quintopia> oh
20:30:27 <quintopia> you meant mark within the programs that competed?
20:30:41 <ais523> it's before the all-polarity-all-length thing, so it may be before correct-length too
20:30:57 <Gregor> Yup, 100K
20:31:40 <ais523> the only program it likely makes a difference to is defend14, where I had to lower some constants to fit a win into 100K
20:33:08 <ais523> hmm, something interesting is how badly chainmail and defend7 are doing nowadays
20:33:17 <ais523> the rise of defence programs has lead people to really start punishing them
20:33:44 <Gregor> Has somebody starting writing The History of Warfare: BF Joust
20:33:57 <impomatic> Gregor: I've been considering it
20:34:13 <quintopia> i would read it
20:34:22 <impomatic> But I think ais523 would do a better job.
20:35:14 <ais523> I've been considering it too
20:35:21 <ais523> perhaps impomatic and I should collaborate
20:35:30 <ais523> but I'm really busy at work atm, with something I seriously don't want to do
20:35:38 <ais523> and am thus playing BF Joust as a substitute
20:35:47 <quintopia> lol
20:36:00 <quintopia> THIS SHOULD BE A WIKI ARTICLE STAT
20:36:06 <impomatic> ais523: I'd be happy to.
20:36:09 <ais523> it should be a post on impomatic's blog
20:36:21 <quintopia> okay fine
20:36:30 <quintopia> i was just thinking the wiki didn't have nearly enough history on it
20:36:37 <ais523> putting it on the wiki too would be interesting, too
20:36:41 <ais523> probably as a separate article
20:38:10 <quintopia> speaking of history, does anyone know what the first language was that used message-passing and not global state?
20:38:27 <elliott> quintopia: Smalltalk, probably, or Modula before it
20:38:30 <Gregor> http://codu.org/eso/bfjoust/in_egobot/reports/ Here's your source :P
20:39:20 <impomatic> Maybe it could be in magazine format like http://corewar.co.uk/nw/nw03.txt :-)
20:39:42 <nescience> that would be neat
20:40:00 <nescience> mercurial I have found doesn't make it easy on you though
20:40:03 <quintopia> anyone know where i could see the programs that were entered into the agora tourney?
20:40:08 <elliott> hardly worth magazine format for a single article
20:40:12 <nescience> I gave up trying to find old programs I had submitted
20:40:15 <elliott> quintopia: they all sucked
20:40:34 <nescience> there's enough info to make an issue or three elliott
20:40:41 <Gregor> nescience: ... are you kidding me?
20:40:45 <elliott> nescience: Not worth it.
20:40:48 <Gregor> w.r.t. getting your old programs out of the repo
20:40:55 <elliott> Gregor: he's a windowser :P
20:41:08 <nescience> I had trouble searching what version they were in
20:41:13 <nescience> by filename
20:42:29 <Gregor> ... they're logged by filename, just look through the log.
20:42:31 <nescience> I seem to recall doing it before but I gave up trying to use help
20:42:57 <nescience> will try that then
20:45:35 <elliott> Deewiant: wait, HTF do G and P work in EMEM?
20:45:38 <elliott> "hnd n addr" what's addr
20:46:39 <ais523> VCSes aren't really ideal for that sort of thing, because they assume that if something's deleted it's because it turned out not to be useful, and the only reason to recall it from history is if it was deleted by mistake or the deletion later turned out to be a bad idea
20:47:19 <Gregor> They may not be ideal, but they're a hell of a lot better than much of the alternative (read: nothing)
20:47:41 -!- Sgeo_ has joined.
20:53:42 <elliott> Deewiant: Pingy :-P
20:53:52 <Deewiant> I don't know anything about EMEM, it's crap
20:54:02 <Deewiant> Presumably that's your pointer addition
20:54:32 <elliott> Deewiant: >_<
20:54:40 <elliott> Deewiant: Name some low-hanging fruit that isn't EMEM then :P
20:54:51 <Deewiant> FIXP, FPSP, FPDP
20:55:08 <Deewiant> FILE
20:55:22 <quintopia> okay, so, the big thing on xkcd fora now appears to be "code bowling"
20:55:29 <quintopia> which is the opposite of code golf
20:56:01 <quintopia> write a program that *cleverly* solves a problem with the poorest time efficiency you can achieve.
20:56:14 <quintopia> aka, take as long as possible without just wasting cycles
20:56:30 <oerjan> XD
20:57:17 <oerjan> i'm not sure i imagine bowling fitting that description better than golf...
20:57:30 <quintopia> it does though
20:57:41 <quintopia> in bowling you want to get as high a score as possible
20:57:47 <oerjan> hm
20:57:57 <myndzi> they didn't actually have the name in the log for a while
20:58:15 <oerjan> yes but the score in bowling has no positive relation to time, unlike in golf
20:58:21 <ais523> you can always use clog's logs for programs posted in-channel, I suppose
20:58:40 * oerjan thinks cricket might have been a better name
21:02:15 <elliott> @hoogle Ptr a -> IO a
21:02:16 <lambdabot> Foreign.Storable peek :: Storable a => Ptr a -> IO a
21:02:16 <lambdabot> Foreign.Marshal.Alloc free :: Ptr a -> IO ()
21:02:16 <lambdabot> Network.Socket.Internal peekSockAddr :: Ptr SockAddr -> IO SockAddr
21:03:56 <elliott> Deewiant: I'll do FILE then.
21:04:00 <elliott> Does myco test that?
21:04:31 <Deewiant> Yes, and it's actually useful since it'll then delete the tmp files
21:06:33 <oerjan> > let (ಠ_ಠ) = 2 in (ಠ_ಠ)
21:06:34 <lambdabot> 2
21:06:41 <elliott> oerjan: :D
21:06:47 <elliott> Deewiant: That WOULD be nice :-D
21:07:07 <Sgeo_> Is it just me, or is LibreOffice Base crap?/
21:07:11 <elliott> ...
21:07:12 <elliott> ANYWAY
21:07:23 <oerjan> elliott: i saw this link on reddit http://kutruff.wordpress.com/2011/02/08/using-%E0%B2%A0_%E0%B2%A0-to-throw-exceptions/ i haven't opened it yet but i imagined what it _could_ be
21:07:35 -!- ais523 has quit (Remote host closed the connection).
21:07:47 <elliott> oerjan: it's pretty much that, yep
21:07:51 <elliott> except for C# and F#
21:08:12 <oerjan> so it was
21:08:37 <elliott> > let _ ಠ_ಠ x = error x in () ಠ_ಠ "Son, I am disappoint."
21:08:38 <lambdabot> <no location info>: Parse error in pattern
21:08:41 <elliott> :(
21:08:58 <oerjan> i'm going to need the logs to actually see what you did there :D
21:09:08 <elliott> @Hoogle Handle -> Int
21:09:08 <lambdabot> Maybe you meant: google hoogle
21:09:12 <elliott> @hoogle Handle -> Int
21:09:12 <lambdabot> Data.Generics.Schemes gsize :: Data a => a -> Int
21:09:12 <lambdabot> Data.Generics.Schemes gdepth :: GenericQ Int
21:09:13 <lambdabot> Data.Generics.Schemes glength :: GenericQ Int
21:09:47 <oerjan> elliott: ಠ_ಠ is actually alphanumeric not operator
21:09:49 <Deewiant> @hoogle fd
21:09:50 <lambdabot> System.Posix.Types newtype Fd
21:09:50 <lambdabot> System.Posix.Types Fd :: CInt -> Fd
21:09:50 <lambdabot> Network.Socket fdSocket :: Socket -> CInt
21:10:09 <elliott> oerjan: ah
21:10:18 <elliott> > let ಠ_ಠ = error in ಠ_ಠ "You've been a bad, bad boy."
21:10:19 <lambdabot> *Exception: You've been a bad, bad boy.
21:10:23 <elliott> golden
21:10:30 <elliott> ok now to write helper functions for IntMaps with fingerprints
21:10:36 <elliott> except that would be a pain
21:10:37 <elliott> so meh
21:11:14 <elliott> Deewiant: The Va that O pops is storage-offset, right? :-P
21:11:32 <Deewiant> I'd assume that everything is
21:11:37 -!- augur has quit (Ping timeout: 240 seconds).
21:11:39 -!- ais523 has joined.
21:11:46 <elliott> Deewiant: It's not clear at all to me what the I/O buffer is used for ther.
21:11:48 <elliott> *there.
21:12:00 <Deewiant> It's where stuff is written to/from
21:12:34 <elliott> 08:18:34 <ehird> Deewiant: I need to store two boundary maps, vertical & horizontal, right
21:12:34 <elliott> 08:18:37 <ehird> ?
21:12:34 <elliott> 08:20:28 <ehird> ais523: so I've gone insane and am implementing befunge98
21:12:34 <elliott> 08:20:29 <ehird> again
21:12:34 <elliott> EVERY TIME
21:12:37 <elliott> I'VE CLICKED A RANDOM LOG
21:12:41 <elliott> SINCE STARTING THIS
21:12:51 <ais523> beautiful
21:12:52 <elliott> Deewiant: Linearly, I guess?
21:13:07 <Deewiant> Yeah, if it doesn't say anything else
21:13:59 <elliott> Deewiant: And then I argue with you that leaving form feed in fungespace is correct :-D
21:14:21 <elliott> 08:45:56 <Deewiant> ehird: Applies analogously for \f in Befunge.
21:14:21 <elliott> 08:46:06 <ehird> Uh huh. Where in the spec does it say this?
21:14:21 <elliott> 08:46:12 <Deewiant> It doesn't.
21:14:21 <elliott> 08:46:15 <ehird> I see.
21:14:33 <Deewiant> Key word: analogous
21:14:40 <Deewiant> In this case, there's nothing to compare to :-P
21:15:30 <elliott> Deewiant: I wasn't referring to FILE
21:15:49 <elliott> data FileMap = FileMap Int (IntMap (Handle,Vector)) deriving (Show, Typeable)
21:15:51 <elliott> IS THAT ENOUGH GOSH
21:19:44 <myndzi> hoho
21:19:50 <myndzi> i have created a text file for the manifest of every revision! :P
21:20:30 <elliott> Deewiant: Woo, I can't implement FILE using System.IO
21:20:35 <elliott> IOMode doesn't have enough members
21:20:35 -!- ais523 has quit (Read error: Connection reset by peer).
21:20:48 <elliott> I love how much I don't love this
21:21:10 <myndzi> i don't know i'd call shortsword a "true" offset clear, but "kicks_ehird" is a bit closer, also impomatic's; and it predates my "creep" slightly
21:21:22 <myndzi> i'd like to find the beginning of the (-)*N[+] style thing though really
21:21:32 <elliott> kicks_ehird? xD
21:21:33 -!- iconmaster has joined.
21:21:38 <myndzi> lol yeah
21:21:39 <Deewiant> elliott: What does it lack
21:21:50 <Deewiant> FWIW I use C I/O as well just to keep it trivial
21:22:07 <myndzi> (-)*N[+] was kind of a different development to just the simple one-off clear thing
21:22:22 <elliott> Deewiant: It has: ReadMode, WriteMode, AppendMode, ReadWriteMode; I need: those, plus TruncateReadWriteMode, AppendReadWriteMode
21:22:29 <myndzi> anyway, probably hard to search for
21:22:41 <Deewiant> elliott: Can't you simulate both of those using ReadWriteMode
21:22:44 <myndzi> maybe i could grep it, but boy, i'd have to have like, archive folders of everything
21:22:48 <elliott> So I need System.POSIX.IO, with this wonderful API: http://www.haskell.org/ghc/docs/latest/html/libraries/unix-2.4.1.0/System-Posix-IO.html#t:OpenFileFlags
21:22:50 <myndzi> also apparently report.txt wasn't archived, which is too bad
21:22:57 <elliott> Deewiant: I don't _think_ so.
21:23:05 <elliott> Deewiant: Well, maybe.
21:23:13 <elliott> Deewiant: Dunno if Haskell has a nice file size function :D
21:23:19 <elliott> Indeed not
21:23:25 <elliott> Oh wait
21:23:28 <elliott> hFileSize :: Handle -> IO IntegerSource
21:23:28 <elliott> For a handle hdl which attached to a physical file, hFileSize hdl returns the size of that file in 8-bit bytes.
21:23:29 <elliott> Good enough
21:23:33 -!- ais523 has joined.
21:24:12 -!- Mathnerd314 has joined.
21:24:36 <elliott> Deewiant: Seemingly no way of truncating, though
21:25:12 <oerjan> elliott: WriteMode truncates, doesn't it.
21:25:36 <elliott> oerjan: Well. Yes. That wouldn't be atomic, though, to open and close and re-open.
21:26:00 <oerjan> hm.
21:26:18 <Deewiant> elliott: hSetFileSize
21:26:18 <elliott> Tempted to just deal with the hideous System.Posix.IO at this point. Sigh.
21:26:24 -!- iconmaster has quit (Client Quit).
21:26:31 <elliott> Deewiant: And the "worst name" prize goes to...
21:26:45 -!- iconmaster has joined.
21:27:35 <elliott> when (mode == 4) $ hSetFileSize handle 0
21:27:36 <elliott> when (mode == 5) $ hSeek handle SeekFromEnd 0
21:27:36 <elliott> tada
21:27:56 <Deewiant> Yes, because "set file size" is so strange a way of thinking about it :-P
21:28:21 <elliott> Deewiant: I either want a perfect pearl of functional purity... or something with similar names to the C API :-P
21:28:27 <elliott> Or at least the POSIX API.
21:28:33 <elliott> Or just general terminology.
21:30:02 <oerjan> what terminology do generals use for this, anyway
21:30:35 <elliott> I really need some kind of continuation support in my monad.
21:30:38 <elliott> I keep doing
21:30:39 <elliott> case foo of
21:30:42 <elliott> Nothing -> reflect
21:30:44 <elliott> Just blah -> do
21:30:46 <elliott> LOTS OF STUFF
21:31:15 <Deewiant> Wrap ContT around it
21:31:46 <Vonlebio> http://i.imgur.com/qAgC2.jpg
21:31:51 <Vonlebio> I FEEL A MEME IS DEVELOPING
21:32:22 <oerjan> elliott: um you _could_ make a function for that pattern if it's exactly like that :D
21:32:24 <Gregor> Vonlabia: A meme ... of what? Why?
21:32:35 <elliott> oerjan: well, I'd still need an indentation
21:32:37 <elliott> for each such condition
21:32:43 <Vonlebio> Gregor, Bill O'Reilly not understanding how things work.
21:32:44 <Deewiant> ?unmtl ContT x (StateT S IO) y
21:32:45 <lambdabot> (y -> S -> IO (x, S)) -> S -> IO (x, S)
21:33:05 <elliott> Deewiant: X-D
21:33:15 <elliott> ?mtl (y -> S -> IO (x, S)) -> S -> IO (x, S)
21:33:15 <lambdabot> Maybe you meant: ft map msg pl unmtl url
21:33:17 <elliott> LAME
21:33:20 <oerjan> elliott: do Just Blah <- foo; and then fail does the reflect?
21:33:30 <elliott> oerjan: but then it'd cancel the interpreter loop :-)
21:33:52 <oerjan> hm wait that's wrong
21:34:03 <oerjan> * <- return foo;
21:34:22 <oerjan> elliott: `mplus` reflect after that...
21:34:35 <elliott> oerjan: heh
21:35:08 <oerjan> some monads allow that style, anyway. like Parsec.
21:35:14 <elliott> ANOTHER LOVELY THING ABOUT HASKELL'S IO API:
21:35:17 <elliott> NO FUCKING "FREAD"
21:35:26 <elliott> that would be TOO SIMPLE
21:35:29 <elliott> TOO EASY
21:35:46 -!- iconmaster has quit (Ping timeout: 245 seconds).
21:35:49 <Gregor> Hey there Tnurmb: No fucking fread!
21:35:54 <Deewiant> elliott: hGetBuf
21:36:07 <elliott> Gregor: ...Tnurmb?
21:36:08 <elliott> Deewiant: Thanks
21:36:11 -!- Sgeo_ has quit (Read error: Operation timed out).
21:36:12 <elliott> Deewiant: (This is how I get support from now on)
21:36:20 <elliott> Deewiant: THAT REQUIRES A PTR
21:36:24 <Deewiant> elliott: It's fread!
21:36:30 <elliott> >_,
21:36:32 <elliott> *>_<
21:37:07 <elliott> Deewiant: Seriously... using that would be an unholy pain :P
21:37:16 <fizzie> There's that MaybeT wrapper, isn't that the sort of thing that can wrap sequences of "test for Nothing every now and then" into a single level of indentation? (But I'm not a Haskell guy.)
21:37:27 <Deewiant> elliott: Data.ByteString.hGet
21:37:32 <elliott> fizzie: It's more than just that pattern match though.
21:37:36 <elliott> Deewiant: Ah, thanks. (See, support.)
21:37:44 <elliott> I wonder if it only works on Finns.
21:39:20 <elliott> @hoogle (Word8 -> m a) -> ByteString -> m ()
21:39:20 <lambdabot> Control.Monad (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
21:39:20 <lambdabot> Control.Monad (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
21:39:23 <elliott> >_<
21:39:27 <elliott> @hoogle mapM bytestring
21:39:27 <lambdabot> No results found
21:39:42 -!- azaq23 has joined.
21:41:14 <elliott> I'm assuming that G reads a line.
21:41:16 <elliott> Correct assumption?
21:42:36 <elliott> Actually I don't think so.
21:42:37 <elliott> >_<
21:42:42 <elliott> What does it do?
21:43:05 <Deewiant> "like c fgets", quoth the spec.
21:43:30 <elliott> Deewiant: fgets takes a size argument.
21:43:30 <elliott> G doesn't.
21:43:56 <Deewiant> Then it's probably a line, yes
21:44:13 <elliott> 08:53:15 <ehird> Hey, it parses mycology quite quickly.
21:44:13 <elliott> 08:53:19 <ehird> ~0.2s
21:44:13 <elliott> 08:53:24 <ehird> Maybe 0.3
21:44:13 <elliott> I think I was a liar.
21:44:21 <elliott> Deewiant: Which it pushes the length of for no reason :P
21:45:06 <fizzie> The length is nice for checking for EOF.
21:45:11 <fizzie> Assuming it reflects on fail, anyway.
21:45:42 <fizzie> Okay, so you could : and test the first read byte for the string-terminating 0.
21:45:55 <fizzie> But G| is not too shabby either, even if you then have to $ the leftover 0.
21:47:17 <fizzie> I think I also use the string length for something in fungot.
21:47:17 <fungot> fizzie: oh. you already know many concepts, then the implementation ( software user) can be used
21:48:34 <elliott> fizzie: You use FILE?
21:48:44 <fizzie> Yes, quite a lot.
21:48:47 <elliott> Deewiant: How comprehensive is Mycology's FILE testing?
21:48:53 <elliott> Lots of corner-cases I could be missing here.
21:49:07 <Deewiant> Not very, there's too many corner-cases :-P
21:49:12 <fizzie> Though G/P not so much, that only for the ascii line-based state-file storage.
21:49:26 <fizzie> The babbling uses R/S a lot.
21:49:52 <fizzie> Since it doesn't load the (multi-hundred-megabyte) model in memory, instead keeps navigating around the ngram tree with S and reading one value at a time.
21:51:00 <elliott> Yay, there's hPut.
21:51:12 <elliott> fizzie: Do you have a program that just does the babbling?
21:51:14 <elliott> Funge-98, I mean.
21:51:17 <elliott> That would be nice to test/benchmark.
21:51:44 <elliott> Hey, I can just use rectangleToByteString for this!! Oh gliffrious gee!
21:51:49 <fizzie> No, I don't. Theoretically speaking it shouldn't be too hard to extract, it doesn't really depend that much of the surroundings.
21:51:53 <elliott> Oh, and mergeByteString for the other!! Gambitulous petulancy!!!!
21:52:11 <ais523> this thread is great: http://forums.thedailywtf.com/forums/t/21257.aspx
21:54:33 <ais523> summary: someone is asked to make 100 copies of a file but with different names (and the reason is a bad one, too); then after complying with the request, finds he's missed one, and the original requestors ask for it to be sent over by FTP
21:54:57 <fizzie> elliott: Are you going to have your R/W read/write values in the [0, 255] range or the [-128, 127] range? Both are seen in the wild. (The "greater than 255" is another spec-retcon.)
21:55:31 <elliott> fizzie: [0, 255], I think.
21:55:44 <elliott> fizzie: I just rely on ByteString to do the modulo for me, works for o :-D
21:56:04 <elliott> fizzie: What does Mycology like?
21:56:29 <elliott> G(h -- h 0gnirts b)Read string from file (like c fgets)
21:56:29 <elliott> P(h 0gnirts -- h)Write string to file (like c fputs)
21:56:32 <elliott> Deewiant: fputs doesn't write a newline. Discuss.
21:56:53 <Deewiant> That probably doesn't then either?
21:57:01 <elliott> Deewiant: I'm sure it does, since G/P are the "line-oriented" functions.
21:57:07 <elliott> Maybe fizzie can disagree. :p
21:57:35 <elliott> Hmm, you appear to actually not.
21:57:37 <fizzie> I'm not sure what I assume.
21:57:39 <elliott> Okay then.
21:58:31 <fizzie> It might be that I do add the newline manually.
21:58:45 <fizzie> I can't really understand my ^save.
21:58:52 <fizzie> It looks far too small to actually save stuff.
21:59:15 <elliott> 127 lines for FILE. Whew.
21:59:41 <fizzie> I do seem to do quite a lot of "0a" + apped-from-STRN there, so I think I'm writing newlines manually.
22:01:25 <elliott> fizzie: So if I come up with some amazing feature that makes Shiro oh-so-appealing for fungot, do I get a user? :-)
22:01:25 <fungot> elliott: does " damned if i know. i just changed a word in english? :) " migrate my process thence!"
22:01:26 <fizzie> And in fact G:!#v_1-L -style stuff to strip the newline from G.
22:01:37 <elliott> Like, like, maybe I'll make babble generation SO FAST.
22:02:09 <elliott> Pretty sure that as the only actual user of Befunge-98, you have to do, like, new-implementation affirmative action.
22:02:11 <elliott> To prevent monopolies.
22:02:32 <fizzie> I could run a "shungot" on it.
22:02:50 <elliott> fizzie: And what does cfunge have that I don't?!
22:02:54 -!- hagb4rd has joined.
22:02:57 <elliott> Honestly, first you abandon RC/Funge, and now you won't even use Shiro.
22:03:01 <elliott> I get the feeling Vorpal's paying you.
22:03:09 <elliott> Deewiant: Form union?
22:03:15 <Deewiant> :-P
22:03:51 <elliott> BAD: G didn't read 'foo\n'
22:03:51 <elliott> <CTCP>GOOD: C worked
22:03:55 <elliott> That \1 in front of GOOD worries me.
22:04:08 <elliott> Looks like G expects the final newline >_<
22:04:12 <olsner> but it says good, then it can't be bad
22:04:47 <fizzie> Is this ghc-compiled binary linking against bazillion libraries (like Kerberos, SASL, GnuTLS, libgcrypt) just because it uses Network.Browser, or do they all do that? (I guess the latter.)
22:04:56 <fizzie> s/latter/former/
22:05:10 <elliott> $ ldd shiro
22:05:10 <elliott> linux-vdso.so.1 => (0x00007fff64dff000)
22:05:10 <elliott> librt.so.1 => /lib/librt.so.1 (0x00007fc20e487000)
22:05:10 <elliott> libutil.so.1 => /lib/libutil.so.1 (0x00007fc20e284000)
22:05:10 <elliott> libdl.so.2 => /lib/libdl.so.2 (0x00007fc20e07f000)
22:05:11 <elliott> libgmp.so.3 => /usr/lib/libgmp.so.3 (0x00007fc20de1f000)
22:05:13 <elliott> libm.so.6 => /lib/libm.so.6 (0x00007fc20db9c000)
22:05:17 <elliott> libc.so.6 => /lib/libc.so.6 (0x00007fc20d818000)
22:05:19 <elliott> libpthread.so.0 => /lib/libpthread.so.0 (0x00007fc20d5fb000)
22:05:21 <elliott> /lib64/ld-linux-x86-64.so.2 (0x00007fc20e6ae000)
22:05:23 <elliott> fizzie: The latter. :P
22:05:30 <fizzie> That's not very much.
22:05:38 <elliott> Not much more than your typical C program.
22:05:46 <elliott> It links in the Haskell libraries statically of course.
22:05:55 <olsner> those are all just parts of libc plus gmp
22:05:56 <elliott> But that's just how GHC works (well, without the fancy modern stuff that I don't trust and don't know how to enable).
22:06:07 <elliott> olsner: Yeah, but pthread is notable.
22:06:23 <Deewiant> Comparing against CCBI you've got: +rt,util,gmp -ncurses,formw,gcc_s
22:06:23 <elliott> fizzie: Have I mentioned that Shiro is more standards-compliant than cfunge?
22:06:41 <elliott> Deewiant: ncurses will enter soon.
22:06:42 <elliott> Dunno what formw is.
22:06:45 <elliott> gcc_s will never get in. :p
22:06:57 <Deewiant> formw is some ncurses thing it seems
22:07:03 <Deewiant> Dunno why cfunge doesn't use it
22:07:05 <fizzie> Yeah, my test case was probably just not a good one since it has all those FFI-driven externalities. (I was just wondering how tricky it would be to run an elsewhere-built binary on the fungot box.)
22:07:05 <fungot> fizzie: would xml-rpc work well enough in the abstract sense of things. there are not too long
22:07:12 <elliott> Testing fingerprint FILE... loaded.
22:07:14 <elliott> BAD: O opened 'mycotemp.tmp' for reading, won't overwrite it and thus won't test fingerprint
22:07:14 <elliott> GOOD: closed file with C
22:07:14 <elliott> YOU ARE TOO PARANOID
22:07:32 <elliott> fizzie: Erm, the GHC in Debian should work fine to compile Shiro :-P
22:07:44 <fizzie> Yes, but I don't want to install GHC on that thing.
22:07:47 <elliott> (Note that Shiro can't run fungot yet, because of missing fingerprints, and it also has some slowness, but I'm working on it.)
22:07:48 <fungot> elliott: i'm glad you are so certain.
22:07:55 <elliott> fizzie: GHC can link statically, anywho.
22:08:02 <elliott> And it doesn't add too much to the binary.
22:08:12 <fizzie> Heh, curiously coherent comment from the bot.
22:08:16 -!- taotree has quit (Ping timeout: 240 seconds).
22:08:23 <elliott> BAD: O opened 'mycotemp.tmp' for reading, won't overwrite it and thus won't test fingerprint
22:08:30 <elliott> Deewiant: You do that _after writing mycotemp yourself_.
22:08:34 -!- zzo38 has joined.
22:08:38 <elliott> I am not sure how to coerce this into testing.
22:08:59 <Deewiant> Hmm? Doesn't it only check that right after loading FILE?
22:09:01 <zzo38> How can astrology be medicine?
22:09:04 <elliott> Oh, mycotemp != mycotmp.
22:09:13 <elliott> Thanks Deewiant, your naming scheme is confusing!
22:09:19 <Deewiant> mycotemp for FILE, mycotmp[0-9] for earlier
22:09:26 <elliott> MAKES SENSE
22:09:27 <Deewiant> I didn't expect to need another temp file.
22:09:29 <elliott> :D
22:09:36 <elliott> BBAD: couldn't reopen file in truncate+read mode
22:09:38 <elliott> It's b-b-b-b-bad.
22:09:59 <elliott> Hmm, I have no idea why that's happening
22:10:15 <elliott> Deewiant: Dude, there's no truncate+read mode.
22:10:18 <elliott> Just turncate+read/write.
22:10:24 <Deewiant> Whatever.
22:10:31 <Deewiant> It probably means w+.
22:10:36 <Deewiant> If that's it.
22:11:03 <elliott> 08:54:24 <ehird> data Point =
22:11:03 <elliott> 08:54:25 <ehird> Point {
22:11:03 <elliott> 08:54:25 <ehird> x :: {-# UNPACK #-} !Int,
22:11:03 <elliott> 08:54:27 <ehird> y :: {-# UNPACK #-} !Int
22:11:03 <elliott> Ooh, tempting.
22:11:55 <elliott> *truncate
22:12:11 <elliott> Deewiant: By "couldn't" you probably mean "reflects" right?
22:12:53 <Deewiant> Yeah, probably
22:13:07 <elliott> GOOD: closed file with C
22:13:07 <elliott> mycotemp.tmp: openBinaryFile: resource busy (file is locked)
22:13:07 <elliott> BBAD: couldn't reopen file in truncate+read mode
22:13:08 <Deewiant> You could learn to read Befunge a bit and look at the source, you know :-P
22:13:10 <elliott> _What._
22:13:18 <elliott> Also -- BAD: O reflected leaving the stack untouched (or pushed an 'm' for no reason)
22:13:28 <elliott> Deewiant: Can Vorpal? :-P
22:13:35 <Deewiant> A bit
22:13:42 <Deewiant> But usually he just complains about my unreadable code
22:14:15 <elliott> BAD: O reflected leaving the stack untouched (or pushed an 'm' for no reason)
22:14:17 <elliott> ???????????????????????
22:14:20 <elliott> I so don't do that.
22:14:30 <Deewiant> Maybe you have a push 'm' there by accident
22:14:34 <elliott> fpRun ident O = do
22:14:34 <elliott> filename <- pop0gnirtsAsString
22:14:34 <elliott> mode <- pop
22:14:34 <elliott> buffer <- popVecOffset
22:14:34 <elliott> if mode < 0 || mode > 5 then reflect else do
22:14:35 <elliott> handle <- io $ openBinaryFile filename (ioMode mode)
22:14:37 <elliott> when (mode == 4) . io $ hSetFileSize handle 0
22:14:39 <elliott> when (mode == 5) . io $ hSeek handle SeekFromEnd 0
22:14:41 <fizzie> Deewiant: It does need a rather wide terminal to be comfortable to read.
22:14:41 <elliott> Those are the only places I can reflect.
22:14:45 <elliott> By IO error or by that explicit reflect.
22:15:01 <Deewiant> fizzie: Just disable line wrapping, you don't need to read everything at once anyway
22:16:07 <elliott> Can you disable line wrapping in vi?
22:16:20 <fizzie> ":set nowrap" in vim, don't know about vi-compatible modes.
22:17:35 <Deewiant> Does vi have line wrapping?
22:17:48 <fizzie> There was some editor where non-line-wrapping mode scrolled only the line the cursor was on.
22:18:08 <elliott> That sounds nice.
22:18:17 <elliott> Seriously though.
22:18:19 <elliott> "file is locked"? WTF
22:19:00 <Deewiant> That /might/ be a GHC bug, it seems to ring some kind of bell
22:20:40 -!- taotree has joined.
22:20:48 <elliott> Deewiant: Joy.
22:20:51 <elliott> Deewiant: Got a copy of slowdown.b98?
22:20:55 <elliott> Would like to try it :-D
22:20:56 <fizzie> Deewiant: What does the "reopen" thing check? C + O with the same file name? (I mean, I don't think FILE has a freopen()-like thing exposed.)
22:20:57 <Deewiant> I could be wrong, too.
22:21:10 <elliott> 09:14:55 <AnMaster> ehird, maybe. Anyway if you want to check algorithms currently you should go for ccbi and/or cfunge. cfunge if you want the fast ones.
22:21:10 <elliott> Look at you now, Vorpal!
22:21:12 <Deewiant> And yes, C + O.
22:21:16 <elliott> Losing to the immense power of CCBI2!
22:22:29 <Deewiant> elliott: You can pick it up at http://tar.us.to:1234/
22:23:58 <elliott> Brain Fuck brought 'jail for a while, then his head when water_flea Metabolix and sent me two Brain Fuck-implementation of the Fibonacci sequence to calculate. Well, as we all know, Brain Fuck no means the only one so-called esoteric programming language. Three canonical first is the 1972 intercal, one is drawn up in 1993 Brain Fuck, and the third is in the same year developed Befunge. Brain Fuck However, it is the language that most programmers
22:23:59 <elliott> are on the lips when you want to make jokes related to programming languages. It's history. This code pointers to highlight a large extent overshadowed by their peers Brainfuckin Befunge. Befungen perhaps the most interesting and most unique feature is that the commands are not being driven at all times in the same order, but the direction is determined by the various commands. Source code is divided into two-dimensional (Funge-98-standard allows
22:23:59 <elliott> virtually all one-or-useampiulotteiset, but is generally only used two-dimensional, Befungea) grid, along which one moves (Concurrent Funge-98-standard allows more than one) [i] instruction pointer [/ i ], or IP. IP start point (0, 0), ie the beginning of the file and the default screen at a time, moves to the right. Before the IP's moving in the case of the command is run. Originally
22:24:13 <Deewiant> elliott: Dude
22:24:19 <Deewiant> elliott: You don't need to paste it, it's all online already
22:24:24 <elliott> Deewiant: MACHINE TRANSLATION
22:24:38 <elliott> It's the BEST
22:24:38 <Deewiant> Oh, right, it was in Finnish wasn't it
22:24:41 <elliott> X-D
22:24:45 <elliott> You didn't notice how unreadable that was?
22:24:47 <elliott> Crazy Finns
22:25:04 <Deewiant> I knew what it was as soon as I saw the length, Befunge, and Metabolix
22:25:25 <fizzie> Heh, "'jail" for... that website.
22:25:55 <Deewiant> Well, I don't blame it for not understanding my abbreviation.
22:26:08 <elliott> You Finns, so secretive and mysterious.
22:26:14 <Deewiant> Although the capital should've hinted at the fact that it's a name :-P
22:26:25 <Deewiant> (At least I hope I left a capital letter there)
22:27:07 <elliott> $ ~/Code/shiro/shiro slowdown.b98
22:27:08 <elliott> Need nonempty file name.
22:27:08 <elliott> wat
22:28:24 <Deewiant> elliott: It's a Befunge-98 interpreter, you need to run it on a file.
22:28:28 -!- Vonlebio has quit (Remote host closed the connection).
22:28:40 <elliott> Deewiant: O KAY
22:28:47 <Deewiant> E.g. mycology.b98
22:28:54 <elliott> Deewiant: But I don't support cmdline arguments yet :-D
22:28:54 <Deewiant> Also I'm not sure you have the fingerprint it needs (can't remember which)
22:29:03 <Deewiant> elliott: Well fix that
22:29:04 <elliott> FIXP.
22:29:09 <Deewiant> Right
22:29:15 <elliott> Deewiant: Cool, my FILE never frees its file values.
22:29:19 <Deewiant> Sweet
22:29:22 <elliott> Don't try and O more than some 2 billion times, kids.
22:29:28 <elliott> Somehow I'm not overly worried :-P
22:30:05 <Deewiant> elliott, fizzie: Done with the temporary fileserver? :-P
22:30:12 <elliott> Deewiant: NO
22:30:23 <elliott> I need to find all your secrets first
22:30:27 -!- zzo38 has quit (Remote host closed the connection).
22:30:29 <elliott> tquine.bf.
22:30:31 <elliott> Er, "wow".
22:30:31 <Deewiant> There's no favicon.ico, no point in looking
22:30:41 <elliott> All your secrets are in favicon.ico?
22:30:50 <Deewiant> No, you just made 6 requests to it in a row
22:30:54 <elliott> X-D
22:30:57 <elliott> Blame my browser.
22:31:03 <Deewiant> Meanwhile fizzie mirrors everything that's there
22:31:05 <fizzie> Deewiant: wget -r'd, now I'm done.
22:31:07 <elliott> I'm saving fibo_posting, for analysis of "Crazy Finnish People".
22:31:09 <elliott> Deewiant: Ooh, let me do the same.
22:31:15 <Deewiant> fibo_posting is online, as said
22:31:20 <Deewiant> That's why I didn't bother hiding it :-P
22:31:28 <elliott> But what if wherever it is disappears?
22:31:34 <Deewiant> Then I have it, at least
22:31:36 <Deewiant> That's why I have it :-D
22:31:42 <elliott> Deewiant: But what if you turn all SECRETIVE.
22:31:56 <elliott> MYSTERIES OF THE AGES: What, exactly, does the [t] BBCode tag do?! NOBODY KNOWS
22:31:57 <Deewiant> Then nothing of value is lost
22:32:05 <elliott> Deewiant: That's exactly what a secretive Finn would say.
22:32:15 <elliott> Okay, Googling it worked :-P
22:32:25 <elliott> Now I have uncovered the secrets of the Finns.
22:32:37 <elliott> Unfortunately, as nobody can understand Finnish, this is for naught.
22:32:43 <Deewiant> Congrats, you now know what Google has known for years.
22:32:50 <elliott> I know!
22:32:58 <elliott> Google is in league with the Finns.
22:33:06 <Deewiant> They even employ Finns!
22:33:12 <elliott> LIKE NAZIS
22:33:32 -!- Sgeo_ has joined.
22:35:21 <elliott> Deewiant: Turns out hClose isn't "actually" "closing the file", anyway
22:35:40 <Deewiant> Yes, that's what it would imply
22:36:07 <elliott> Deewiant: #haskell make half-arsed comments about lazy IO, so I'm blaming GHC for now.
22:36:20 <elliott> Sought to beginning of file with 00S.
22:36:20 <elliott> "Sought"
22:36:21 <elliott> :D
22:36:38 <Deewiant> Dude, it's the simple past of seek
22:36:45 <elliott> Deewiant: But of course.
22:37:04 <fizzie> Seekeded.
22:37:18 <fizzie> Skedaddled to beginning of file with 00S.
22:37:37 <elliott> Deewiant: Bug report: Should say ^
22:38:12 <Deewiant> WONTFIX: length "skedaddled" /= length "sought"
22:38:30 <elliott> Deewiant: Skddld.
22:38:43 <Deewiant> WONTFIX: "skddld" is unclear
22:38:52 <elliott> Maybe if you can't read.
22:42:00 -!- hagb4rd has quit (Ping timeout: 240 seconds).
22:51:05 -!- FireFly has quit (Quit: swatted to death).
22:51:19 <elliott> Deewiant: Pretty sure this is a GHC bug of some description.
22:51:39 <Deewiant> Quite possible
22:51:49 <elliott> BAD: O reflected leaving the stack untouched (or pushed an 'm' for no reason)
22:51:50 <elliott> This still makes absolutely no sense.
22:51:50 <Deewiant> You can grab the Fd and close that
22:51:56 <Deewiant> And see if that helps
22:52:02 <elliott> Deewiant: Might do.
22:52:08 <elliott> Would like to solve that O thing first though.
22:52:09 <elliott> OHWAIT
22:52:13 <elliott> filename <- pop0gnirtsAsString
22:52:13 <elliott> mode <- pop
22:52:13 <elliott> buffer <- popVecOffset
22:52:15 <elliott> Spotte bugge
22:52:24 <elliott> Wait, no bug.
22:52:25 <Deewiant> Can't remember
22:52:27 <elliott> That's absolutely correct.
22:52:30 <elliott> (Va m 0gnirts -- h)
22:52:31 <olsner> ye olde bugge
22:52:31 <Deewiant> Could've been wrong order
22:52:51 <elliott> This has to be a mycology bug
22:53:06 -!- oerjan has quit (Quit: Good night).
22:53:22 <Deewiant> That, of course, is quite impossible
22:54:03 <ais523> is it /very/ impossible?
22:54:03 <elliott> Deewiant: I don't see how it can't be Mycology's bug
22:54:17 <fizzie> Yes; Mycology is, by definition, correct.
22:54:25 <Deewiant> Then delve into the source and find out where the bug is :-P
22:55:28 <Sgeo_> Grah
22:55:39 <Sgeo_> LibreOffice Base sucks major dick
22:55:51 <olsner> one does not simply delve into ...
22:57:06 -!- impomatic has quit (Quit: ChatZilla 0.9.86 [Firefox 3.5.16/20101130074636]).
22:58:54 <elliott> olsner: Into... dick?
22:59:28 <Deewiant> If you just called Mycology a dick I may have to be offended
22:59:29 <Gregor> In Soviet Russia ...
23:00:17 <elliott> In Soviet Russia, dick.
23:00:22 <Sgeo_> I am a heterosexual male. Therefore, by what Gregor said, I do not live in Russia
23:00:37 <Gregor> *Soviet Russia
23:00:54 <elliott> Heterosexual, suuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuure
23:01:01 <elliott> Mr. "<Sgeo_> [...] sucks major dick"
23:04:51 <elliott> [[Computation hClose hdl makes handle hdl closed. Before the computation finishes, if hdl is writable its buffer is flushed as for hFlush. Performing hClose on a handle that has already been closed has no effect; doing so is not an error. All other operations on a closed handle will fail. If hClose fails for any reason, any further operations (apart from hClose) on the handle will still fail as if hdl had been successfully closed.]]
23:04:57 <elliott> Deewiant: i like how it avoids explicitly saying that the fd gets closed
23:04:59 <elliott> probably because it doesn't
23:05:15 <elliott> *sigh*
23:05:44 <Sgeo_> That sounds mildly demented
23:05:58 <elliott> What?
23:06:08 <Sgeo_> hClose doesn't actually close it?
23:06:16 <elliott> Oh dear god revenantphx never shuts up in #haskell. Give me a chance to interject about how terrible hClose is, you 12-year-old >_>
23:06:22 <elliott> Sgeo_: Well, not for me at least.
23:08:29 <elliott> [[fdToHandle :: Fd -> IO HandleSource
23:08:30 <elliott> Converts an Fd into a Handle that can be used with the standard Haskell IO library (see System.IO).
23:08:30 <elliott> GHC only: this function has the side effect of putting the Fd into non-blocking mode (O_NONBLOCK) due to the way the standard IO library implements multithreaded I/O.]]
23:08:36 <elliott> At that note: >_<
23:08:55 <fizzie> It is supposed to "actually close" the handle (there's all those warnings about doing a lazy hGetContents and consuming from it after a hClose) but admittedly it doesn't say about the Fd.
23:09:30 -!- ais523 has quit (Remote host closed the connection).
23:09:53 <elliott> fizzie: I didn't know you even knew any Haskell. :p
23:09:59 <elliott> After all you used C++.
23:10:06 <elliott> I didn't think one person could manage that kind of... cognitive dissonance.
23:10:11 <Sgeo_> elliott, I wrote C++ code yet I understand some Haskell
23:10:11 <elliott> "I know Haskell... think I'll write a C++ program..."
23:10:13 <Deewiant> I don't think he's said anything about knowing Haskell
23:10:30 <Sgeo_> Then again, it's not like I voluntarily write mounds of C++ code
23:10:33 <elliott> Deewiant: Oh, is it just a Finn thing to learn tons of trivia about subjects you don't actually know in an applied manner? :D
23:10:39 <elliott> Or s/learn/Google/ I suppose.
23:10:55 <Deewiant> What trivia? His last line just referred to what you pasted
23:10:57 <olsner> google, then talk like an expert, it's a useful skill
23:11:25 <elliott> "there's all those warnings about doing a lazy hGetContents and consuming from it after a hClose"
23:11:36 <elliott> Nothing I said involved that.
23:11:39 <Deewiant> Oh, that wasn't in your paste
23:11:42 <elliott> olsner: I do that all the time. SO DOES DEEWIANT</troll>
23:11:42 <Deewiant> Well, it's in the docs anyway
23:12:02 <olsner> elliott: sure, but who cares what Deewiant does?
23:12:06 <elliott> Deewiant
23:12:07 <fizzie> Contrary to the prior, it was in fact from memory, not contemporary Google. I've been... dabbling.
23:12:07 <elliott> Presumably
23:12:23 <olsner> I don't care what I do, so why would he?
23:12:24 <elliott> fizzie: But you're not quite ready to come out of the closet, so to speak.
23:12:32 <elliott> Functional-curious.
23:12:53 <elliott> Sweet, C fails without any kind of IO error.
23:13:02 <elliott> I hypothesise that a wizard done it.
23:13:17 <olsner> if you didn't even get an error, how do you know that it failed?
23:13:23 <elliott> because Infallocology says so
23:13:57 <Deewiant> C worked, it's the subsequent O that fails.
23:14:04 <Deewiant> From Infallocology's POV.
23:14:43 <elliott> Deewiant: Mmnope, I have a different error now.
23:14:57 <elliott> ("***",mycotemp.tmp: hSeek: illegal operation (handle is closed))
23:14:57 <elliott> BAD: 20S reflected
23:14:57 <elliott> GOOD: C worked
23:15:00 <elliott> Deewiant: My errors are now non-deterministic.
23:15:07 <Deewiant> Great
23:15:27 <Deewiant> Maybe the fd's actually closed at the next GC or something
23:15:33 <elliott> Theory
23:15:35 <Deewiant> You could force a GC?
23:15:36 <elliott> handle <- io $ openBinaryFile filename (ioMode mode)
23:15:36 <elliott> when (mode == 4) . io $ hSetFileSize handle 0
23:15:36 <elliott> when (mode == 5) . io $ hSeek handle SeekFromEnd 0
23:15:41 <elliott> One of the non-openBinaryFile things is failing here
23:15:44 <elliott> And leaving the file open
23:15:52 <elliott> Problem: There's no reason whatsoever that should happen.
23:16:09 * elliott compiles without -O2
23:16:14 <elliott> Feels like I'm coding in C
23:16:15 <Sgeo_> io?
23:16:22 <elliott> Sgeo_: liftIO, but shorter.
23:16:29 <Deewiant> Inverse of oi
23:16:32 <Sgeo_> Ah
23:17:03 <elliott> Deewiant: Only if you're using TV.
23:17:34 <elliott> Sought to beginning of file with 00S.
23:17:34 <elliott> GOOD: G pushed correct line length
23:17:34 <elliott> GOOD: G read 'foo\n'
23:17:34 <elliott> GOOD: 7R read bar\nbaz
23:17:34 <elliott> BAD: C failed
23:17:44 <elliott> Deewiant: There's no debug output, so there was no IO error.
23:17:51 <elliott> Define "failed". Reflected?
23:18:01 <Deewiant> How else could it fail
23:18:30 <elliott> Deewiant: Then, er, you gave me an invalid file reference. That's the only other way this could reflect.
23:18:45 <Deewiant> Yeah, but, see, that can't happen because there are no bugs
23:20:04 <elliott> Deewiant: I _really_ think this is a Mycology bug here.
23:20:19 <elliott> GOOD: closed file with C
23:20:20 <elliott> GOOD: reopened file in append+read mode
23:20:20 <elliott> Sought to beginning of file with 00S.
23:20:20 <elliott> GOOD: G pushed correct line length
23:20:20 <elliott> GOOD: G read 'foo\n'
23:20:20 <elliott> GOOD: 7R read bar\nbaz
23:20:22 <elliott> BAD: C failed
23:20:24 <elliott> No IO errors.
23:20:29 <elliott> Still--
23:20:34 <elliott> BAD: O reflected leaving the stack untouched (or pushed an 'm' for no reason)
23:20:39 <elliott> That is also a Mycology bug :P
23:21:35 <fizzie> It's very curious how other interps don't trip these hypothetical bugs. :p
23:21:56 <olsner> they must have counterbugs
23:22:05 <elliott> fizzie: fpRun ident O = do
23:22:06 <elliott> filename <- pop0gnirtsAsString
23:22:06 <elliott> mode <- pop
23:22:06 <elliott> buffer <- popVecOffset
23:22:06 <elliott> if mode < 0 || mode > 5 then reflect else do
23:22:06 <elliott> handle <- io $ openBinaryFile filename (ioMode mode)
23:22:08 <Deewiant> It's the simplest explanation!
23:22:11 <elliott> It can *only* reflect after popping everything it pops.
23:22:29 <elliott> I can see absolutely no way modulo e.g. pixie intervention that this is not Mycology's or GHC's bug.
23:22:34 -!- variable has quit (Ping timeout: 260 seconds).
23:22:37 <Deewiant> elliott: The error message can be a bug, you know.
23:22:45 <elliott> Deewiant: My Funge core is perfect, dude. :p
23:22:53 <Deewiant> I mean, in Mycology.
23:23:17 <Deewiant> If you trip a strange-and-untested error case it might print something BAD which is not quite appropriate
23:23:40 <elliott> Deewiant: Maybe I'll trace every instruction execution.
23:23:43 <elliott> That sounds reasonable.
23:25:24 -!- variable has joined.
23:26:01 <elliott> Deewiant: Wow, this debug build is quite the party.
23:26:14 <elliott> How big IS your stack
23:27:18 <Deewiant> ?
23:28:25 <elliott> Deewiant: My tracing build of Shiro :P
23:28:31 <elliott> Mycology's stack gets rather big.
23:28:40 <Deewiant> Not really
23:28:50 <Deewiant> At most a few thousand, when it does 0y
23:28:55 <elliott> "At most a few thousand" :-D
23:29:06 <Deewiant> elliott: slowdown.b98 on mycology goes into the millions IIRC
23:29:12 <elliott> Do you not test -1y?
23:29:16 <Deewiant> And fungicide goes much higher
23:29:55 <Deewiant> And no, I probably don't
23:31:33 <elliott> FIXP looks like a bit of a pain.
23:31:39 <elliott> "Trigonometric functions work in degrees. not radians." Fail
23:32:26 <elliott> http://www.haskell.org/ghc/docs/6.12.3/html/libraries/base-4.2.0.2/Data-Fixed.html This might help...
23:32:50 <elliott> Though I'm not sure what the appropriate resolution would be, especially since technically I could swap out Value at any time.
23:32:59 <Deewiant> Unfortunately sin and co are defined for Floating only
23:33:10 <elliott> Deewiant: Gah!
23:33:20 <Deewiant> Unless you can find them elsewhere
23:33:29 <elliott> "MissingH 0.8.0 is available from:
23:33:29 <elliott> gopher://gopher.quux.org/1/devel/missingh
23:33:29 <elliott> or
23:33:29 <elliott> http://gopher.quux.org:70/devel/missingh" --Mailing list post, 2004
23:33:32 * elliott makes note: John Goerzen -- nutcase.
23:33:56 <elliott> Deewiant: http://hackage.haskell.org/package/fixed-precision Yaaaay?
23:34:11 <elliott> Tentative-DING tentative-DING tentative-DING tentative-NEW tentative-DEPENDENCY tentative-
23:34:12 <elliott> Tentative-DING tentative-DING tentative-DING tentative-NEW tentative-DEPENDENCY tentative-.
23:34:19 <elliott> Wait, MPFR?
23:34:20 <elliott> Oh gawd.
23:34:34 <Deewiant> SPEED
23:34:46 <elliott> SPEEEEEEEEEEEEEEEEED
23:40:05 <elliott> Deewiant: Got a slowdown.b98 that doesn't require FIXP? :-P
23:40:14 <elliott> Or just anything with similar performance characteristics.
23:40:29 <Deewiant> If you want to see your thing go slow, use fungicide
23:41:08 <elliott> Deewiant: I would but it looks like it has all kinds of dependencies to run it.
23:41:14 <elliott> I just want to give my interp a file and watch it crawl. :p
23:41:38 <quintopia> elliott: you need to make sure to include an optimizer :D
23:41:38 <Deewiant> You don't need to "run" fungicide, just use any one of the benchmarks.
23:41:51 <elliott> Deewiant: Link me to the one derived from slowdown :-P
23:42:04 <Deewiant> There is none
23:42:21 <quintopia> something that takes any long straight sequence of whitespace moves and converts them into a direct jump...or would that break intentional timing constructs?
23:42:38 <elliott> Deewiant: None with similar performance? i.e. relying on the same sort of wrapping stuff?
23:42:45 <elliott> quintopia: whitespace takes 0 ticks
23:42:46 <Deewiant> Nope
23:42:54 <elliott> Deewiant: Lame
23:43:10 <quintopia> elliott: already? nice. how'd you do it?
23:43:18 <Deewiant> elliott: slowdown.b98 doesn't rely on wrapping stuff anyway
23:43:18 <elliott> quintopia: Umm, that's just how Funge-98 is defined.
23:43:23 <elliott> Deewiant: You said it does in logs.
23:43:26 <elliott> quintopia: 0 ticks != instant
23:43:27 <Deewiant> No I did not
23:43:29 <elliott> 0 ticks = 0 Funge-98 ticks
23:43:32 -!- augur has joined.
23:43:37 <elliott> Deewiant: If you don't shrink bounds you end up traversing $lots of cells.
23:43:38 <Deewiant> Mycology wraps, and is clever enough to reset the storage offset
23:43:39 <elliott> Where lots = 2^something big.
23:43:52 <Deewiant> So it ends up writing stuff to (0,0)
23:44:02 <Deewiant> And that tends to cause trouble for interps with only one bounding rectangle for all of space
23:44:04 <quintopia> elliott: oh, so yeah, that optimization thing. you can do it, right?
23:44:11 <Deewiant> Since the code is at (millions,millions)
23:44:14 <elliott> quintopia: No.
23:44:18 <elliott> For a start, that would break timing.
23:44:22 <quintopia> (not at load time, just by caching paths that are actually used)
23:44:24 <elliott> For another, it would break alignment of code.
23:44:29 <elliott> For another, Funge-98 is self-modifying.
23:44:30 -!- augur has quit (Remote host closed the connection).
23:44:30 <elliott> For another, ...
23:44:36 <elliott> It would never, ever work.
23:45:05 <quintopia> 1) why would it break timing? 2) no 3) cache invalidation
23:45:06 <Deewiant> elliott: For "most programs", slowdown.b98 causes no troublesome wrapping
23:45:23 <elliott> Deewiant: What was the pathological case, then.
23:45:29 <elliott> quintopia: Because optimisations change the amount of ticks things take.
23:45:33 <elliott> 2) Yes, it would.
23:45:38 <elliott> 3) Are you sure you know what you're talking about>
23:45:40 <elliott> *about?
23:45:52 <quintopia> you just said whitespace takes 0 ticks!
23:45:57 <Deewiant> elliott: The case I recall where I used that term was CCBI's wrapping with a delta on the order of INT_MAX or something
23:46:00 <quintopia> do you know what you're talking about?
23:46:06 <Deewiant> And I can't actually remember whether that was the pathological case
23:46:07 <elliott> quintopia: Yep.
23:46:40 <elliott> Deewiant: Heh, technically my interpreter is all kinds of broken according to the report. It relies on Value being smaller-or-equal-to Int, and Int only has to store up to 2^29.
23:46:48 <elliott> Thankfully it almost certainly stores 2^64.
23:46:55 <elliott> Or 2^32, which is equal.
23:47:06 <elliott> So INT_MAX scares me a bit.
23:47:24 <Deewiant> You'll never run into that case
23:47:43 <quintopia> elliott: i'm saying that any time a program *actually* crosses a long whitespace path, you can add that path to a cache and the next time that path comes up, just skip straight from the beginning to the end in O(1) without actually doing the looping on IP positions. If a p happens on that path, toss it from the cache.
23:48:02 <elliott> You can do that just by storing per-line-and-column bounds.
23:48:03 <quintopia> p
23:48:06 <elliott> But you can't do that for every delta.
23:48:17 <elliott> And I doubt many lines are traversed to the point of wrapping over and over.
23:48:19 <elliott> That's pathological.
23:48:21 <quintopia> i should think you'd be able to do it for any delta
23:48:33 <elliott> Write an interp that does it then
23:48:37 <quintopia> the cache invalidation thing would be hard there tho
23:48:46 <elliott> You have 0.003 seconds on Mycology to beat I think.
23:48:53 <elliott> Although Deewiant's said cfunge has dropped below 0.001 before IIRC.
23:49:29 <quintopia> does mycology do lots of tight (but space-inefficient) loops?
23:49:52 <elliott> No, nothing does.
23:50:01 <elliott> Tight, yes, space-inefficient, no.
23:50:23 <Deewiant> What's "space-inefficient" in this case
23:50:36 <elliott> Wrapping, I think.
23:51:06 <Deewiant> Yeah, I don't think even Mycology has a tight loop with a wrap in the middle
23:51:30 <elliott> That would be hideously awkward :)
23:51:43 <quintopia> space-inefficient would be something like fungot's ^reload path
23:51:44 <fungot> quintopia: and why shouldn't they in scheme? and of what nature?
23:51:47 -!- BeholdMyGlory has quit (Remote host closed the connection).
23:52:45 <elliott> How's it inefficient
23:53:11 -!- cheater00 has joined.
23:53:34 <quintopia> but yeah, i think i could make the cache thing work for arbitrary deltas with only an O(programsize) increase in memory usage. whitespace paths of any length would be crossed instantly and cache invalidation would be O(1)
23:53:56 <elliott> Good luck with that
23:53:59 <elliott> Let us know when it passes Mycology
23:54:16 <quintopia> eh, this is why i suggested it to you because you're actually working on an implementation
23:54:18 <Deewiant> Sounds a bit like jitfunge but only optimizing useless stuff
23:54:41 <elliott> quintopia: Except that if I was going to optimise that, I'd do it the way Deewiant does by using multiple bounding boxes.
23:54:46 <elliott> That also doesn't require reworking half of everything :P
23:55:16 <quintopia> not sure exactly how the multiple bounding boxes thing works :P
23:55:25 <Deewiant> Nobody is!
23:55:32 <quintopia> mine optimizes stuff that doesn't wrap/cross boundaries too though
23:55:39 <elliott> Yours wouldn't work :P
23:55:50 <quintopia> you still haven't told me why though
23:56:31 <quintopia> i might try to hack it into your impl when you're done and i've learned haskell
23:56:34 <elliott> It would "work" in the sense that theoretically you can do it.
23:56:36 -!- cheater- has quit (Ping timeout: 240 seconds).
23:56:42 <elliott> But the overhead of all the IMMENSE pain mutating the code like that would cause,
23:56:43 <Sgeo_> Hail Chydrego!
23:56:49 <elliott> plus the fact that it optimises only things that basically never happens.
23:56:50 <elliott> *happens,
23:56:58 <elliott> would mean that the great overhead for little gain would destroy performance.
23:57:34 <quintopia> possibly. there's not as much overhead as you think i bet, but i'd be willing to try it and find out
23:58:26 <elliott> http://tpdsaa.tumblr.com/
←2011-02-08 2011-02-09 2011-02-10→ ↑2011 ↑all