00:02:08 -!- impomatic has quit (Quit: ChatZilla 0.9.86 [Firefox 3.5.16/20101130074636]).
00:02:27 <elliott__> shiro: Shiro/Monad.hs:82:35-63: Non-exhaustive patterns in lambda
00:02:54 <elliott__> modifyCurrentIP :: (IP -> IP) -> Shiro ()
00:02:54 <elliott__> modifyCurrentIP f = modifyIPList $ \(ip:xs, r) -> (f ip : xs, r)
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:10 <elliott__> elliott@elliott-MacBookAir:~/Code/shiro$ ./shiro forks.b98
00:04:10 <elliott__> elliott@elliott-MacBookAir:~/Code/shiro$
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:06:55 <elliott__> I'll wait until that happens on an actual program.
00:07:04 <elliott__> doNextIns Shiro.Interpreter 100.0 7.3
00:08:43 <elliott__> insertFS Shiro.FungeSpace 85.8 91.5
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: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: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: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: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: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: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:21:34 <elliott> Deewiant: What do you call it when one module is more elegant than the rest of your program?
00:23:25 <elliott> You call it "oh yeah, this is the one I drafted up separately".
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:34:56 <myndzi> !bfjoust careless >+++++>+++++>----->----->+>->>>((>[(-)*126(-.)*3)*22(])*22)*22
00:35:33 <EgoBot> Score for myndzi_careless: 59.1
00:43:49 -!- Mathnerd314 has quit (Ping timeout: 250 seconds).
00:46:16 -!- cal153 has quit (Ping timeout: 265 seconds).
00:46:32 <myndzi> straight to the ... TOP
00:47:06 <quintopia> !bfjoust juggernaut_bitch (.)*48(>[-[++[>>>[>(+)*20[[-]]+]]]](+)*13>[-[++[>>>>>[>(+)*20[[-]]+]]]](-)*13)*11
00:47:28 <EgoBot> Score for quintopia_juggernaut_bitch: 12.9
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: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:13 <Gregor> Observation: pizzicato and harpsichord are not the same.
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:54:37 <elliott> Gregor: 30-second harpischord solo... come on. Yes.
00:54:42 <EgoBot> Score for myndzi_tag: 3.6
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: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: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:59:06 <quintopia> and the harpsichord should be played ragtime
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:31 <Gregor> elliott: 'snot happening :P
01:00:09 <quintopia> elliott: you share knowledge tension gregor and then
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:28 -!- Mathnerd314 has joined.
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:07:01 <elliott> imports: Shiro.Fingerprint
01:07:03 <elliott> Shiro.FungeSpace (./Shiro/FungeSpace.hs)
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: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: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:20 <quintopia> apparently more decoys = higher score
01:27:21 <myndzi> huh, it put them both in the breakdown,txt
01:27:36 <myndzi> confusing, i wanted a report of that program
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: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: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: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: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:59 <quintopia> !bfjoust slowermonorail (>->+)*3>->++++>---->([(..-)*20[+]]+>[(..-)*20[+]]->)*10
01:33:43 <EgoBot> Score for quintopia_slowermonorail: 26.2
01:33:56 -!- copumpkin has joined.
01:34:16 <quintopia> myndzi: answer: leave no gaps near homebase
01:34:28 <myndzi> that's not really true necessarily
01:35:03 <myndzi> you don't know why your score improved, it likely has very little to do with decoys
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: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: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: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: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:40:07 <EgoBot> Score for quintopia_slowermonorail: 25.4
01:41:03 <quintopia> !bfjoust slowermonorail (>->+)*3>->++++>---->([(..-)*20[+]]+>)*20
01:41:33 <EgoBot> Score for quintopia_slowermonorail: 26.3
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: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:46:25 <quintopia> i will kill you back with SAX AND VIOLINS
01:47:58 <elliott> Holy shit, this might actually work.
01:48:06 <elliott> Aww man, and it might not.
01:49:05 <myndzi> !bfjoust butter (>[(-.)*500-(-.)*500(+.)*500+(+.)*500])*30
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: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: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: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: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:47 <myndzi> !bfjoust butter (>[(-.)*128-(-.)*128(+.)*128+(+.)*128>])*30
01:53:51 <Gregor> !bfjoust turtle_rescue_squad (.)*1000(>)*9(>[[-]..>>[-]..])*1000
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: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:54 <Gregor> !bfjoust turtle_rescue_squad (.)*1000(>)*9(>[[-]..>(>[-])*20])*21
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 <Gregor> !bfjoust turtle_rescue_squad (>+>-<<)*250(>)*9(>[[-]..>>[-]..])*1000
01:56:10 <Gregor> Why do I keep putting *1000 on something which by definition can't happen more than *20 ...
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:56 <myndzi> and i made it beat careless too
01:57:02 <myndzi> nah, it doesn't really loop like slowrush does
01:57:23 <myndzi> it's not all that slow
01:57:26 <Gregor> !bfjoust turtle_rescue_squad -(>)*5(>+>-<<)*250(>)*4(>[[-]..>>[-]..])*21
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: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:35 <elliott> !bfjoust die_hard >>>>>((-)*127[(+)*10]<)*4(--+)*10000
01:59:15 <myndzi> !bfjoust butter -->+++++>+++++>----->----->+>->>(>[(-.)*128(.-)*128>])*30
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: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:01:00 <myndzi> !bfjoust butter -->+++++>+++++>----->----->+>->>(>[(-.)*128-(-.)*128(+.)*128+(+.)*128>])*30
02:01:01 <elliott> someone link me to breakdown :P
02:01:15 <EgoBot> Score for myndzi_butter: 38.8
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: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:55 <myndzi> can you manually remove it?
02:03:02 <elliott> !bfjoust die\really\hard >>>>>((-)*127(-)*30<)*4(--+)*10000
02:03:12 <EgoBot> Score for elliott_die_hard: 1.7
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:37 <EgoBot> Score for elliott_die\really\hard: 1.9
02:04:37 <EgoBot> Score for elliott_\: 0.0
02:04:54 <elliott> !bfjoust in_egobot \\\\\\\\\\\\\\\\\\\\\\\\\\ //////////////////////////////////////////////\\\\\\\\\///////
02:05:00 <myndzi> at least they didn't make it on
02:05:45 <Gregor> Heh, I accidentally explicitly ALLOWED \ instead of disallowing it :P
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:39 <Gregor> !bfjoust test\o\rama <
02:06:51 <elliott> quintopia: no because -- and ++ are testd
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:41 <elliott> quintopia: program vs self = draw
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:09:13 <quintopia> i guess it would be something like
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: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: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:32 <elliott> quintopia: it just checks that the output was the input. it's internal to the anagol code.
02:14:38 <elliott> it literally just runs it with the input
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: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: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:35:48 -!- nddrylliog has joined.
02:35:55 <elliott> BAD: ) should have reflected trying to unload nonexistent fingerprint 0
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: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: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> 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:18 <nddrylliog> Sgeo, "collapse" is just today's pretty word for "pass out"
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: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: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: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: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:19 <Sgeo> elliott, Atomo is written in Haskell
02:47:31 <elliott> Starting to regret taking Sgeo off ignore.
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: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: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:54:05 <nddrylliog> oh my god, "subsumer" is actually a french verb as well
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: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: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: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: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:56 <fungot> http://git.zem.fi/fungot/blob/HEAD:/fungot.b98
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: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:31 <quintopia> are you gonna kick everyone that doesn't? :P
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:42 <pikhq> quintopia: The split lagged me out somehow.
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:36 <quintopia> pikhq: is one beer past the ballmer peak?
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: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: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: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: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: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:21 <Sgeo> And I'm shutting up now. This is getting close to things I will not talk about.
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: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:53:39 <zzo38> Maybe I might, at some time
06:18:30 <zzo38> ...is that right? *pic|=(0xFF>>b)&~(0xFF>>(b+c));
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:38 <quintopia> that selects the bth through b+cth bits
06:51:54 <Vorpal> <elliott> Vorpal: ping <-- pong
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:52:18 -!- Mathnerd314 has quit (Ping timeout: 240 seconds).
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: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: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: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 <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:46:13 <quintopia> it's an amalgam of c, perl, and shell script :P
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 <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 <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 <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: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:44 <oerjan> oh and of course this is also inspired by this egodeath thing
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: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: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:28 <oerjan> zzo38: what is the ip for codu.org?
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: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: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: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: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:42 <zzo38> Is that why I got two responses from Gregor?
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: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: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:52 <elliott> 05:24:43 <Sgeo> According to pikhq, they only have one song
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: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:07:27 <elliott> 09:52:54 <oerjan> quintopia: well i meant the program that actually runs a single duel
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: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: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: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: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: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: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: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: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: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:23 <ais523> unloading the semantics is defined as popping a semantics stack
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: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:18 <ais523> elliott: 26 stacks, there's no ban on loading a fingerprint more than once
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: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: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 <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: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: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: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: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: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: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> head $ Map.findWithDefault [reflect] ins m
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: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:33 <elliott> Module imports form a cycle for modules:
14:59:33 <elliott> Shiro.Fingerprints.NULL (./Shiro/Fingerprints/NULL.hs)
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
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: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: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: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:59 <elliott> Ohhh, I see how that 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:20:03 -!- elliott has left (?).
15:20:07 -!- elliott has joined.
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 <elliott> Is it literally the remainder of (a/b) as an int in C?
15:25:54 <Deewiant> I can't remember whether I went with C99 or UNDEF
15:26:00 <elliott> @check \x y -> (rem x y) == (x - (x `div` y) * y)
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:19 <Deewiant> @check \x y -> y == 0 || (rem x y) == (x - (x `quot` y) * y)
15:26:32 <lambdabot> forall a. (Integral a) => a -> a -> a
15:26:55 <Deewiant> @check \x y -> quot x y == div x y
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: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: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:36 <elliott> Deewiant: So... the same as the % instruction?
15:31:50 <elliott> OK, I'll do ceiling of mod.
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:33:05 <elliott> that's counting the old copies :D
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: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: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: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: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: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: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: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: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:08 <Deewiant> Or was that the one that was in one Rc/Funge-98 readme but not the other
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:53 <elliott> I wonder if RC/Funge will get a new update since the first one Susan made.
15:58:20 <Gregor> http://codu.org/eso/bfjoust/in_egobot/myndzi_careless.bfjoust
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: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: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: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: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: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: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: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:06:02 <EgoBot> Score for elliott_all_credit_to_ais523_defend13_tweaked_tinily: 57.6
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:22 <elliott> ais523: and you can copy it to defend13
16:06:27 <elliott> I just replaced the - with a space
16:06:30 <ais523> elliott: they score completely identical points
16:06:37 <ais523> which is not surprising given how it works
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: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:47 <ais523> but you can tell which way your opponent changed your flag
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:58 <Deewiant> Obfuscated open-source is still open-source
16:16:06 <elliott> Deewiant: GPLv2 prohibited obfuscation
16:16:08 <ais523> not by certain definitions I've seen
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: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: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: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: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: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: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: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:19 <elliott> and returns its second argument
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: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:33 <elliott> that's an underload program that ostensibly puts (xxxxxxxxx...) on the stack, yes?
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:18 <ais523> elliott: oh, stack notation is not really standardised
16:30:24 <ais523> I end to leave one set of parens in for stack elements
16:30:33 <elliott> ("*** Exception: rabble rabble
16:30:42 <ais523> also, ouch at not doing tr/()/)(/ when reversing the program
16:30:53 <elliott> findprn "" = error "rabble rabble"
16:30:54 <elliott> findprn (x:s) = (x:xs,s') where (xs,s') = findprn s
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: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:14 <ais523> as in, is it semantically different from Underload at all?
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:50 <elliott> ais523: yes, but the whole evaluation model is different, because:
16:34:59 <elliott> ais523: this outputs oof, then hangs
16:35:29 <ais523> are programs actually evaluated back to front?
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:36:11 <ais523> so they're evaluated from the front, )( style
16:36:55 <elliott> *Main> let prog = reverse "()(~(x)*~:^):^S"
16:37:00 <elliott> ("","",["x"],["^:~*)x(~"])
16:38:28 <elliott> oh, I think ^ is borkenified
16:38:47 -!- augur has quit (Remote host closed the connection).
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:59 <elliott> don't worry, the bug wasn't in your code :P
16:43:12 -!- augur has joined.
16:43:54 <oerjan> <elliott> I will refrain from buying a domain then
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: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: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:30 <elliott> Deewiant: The Fingerprint mixin
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:55 <Deewiant> "Global" state is in the fingerprint's template, per-IP is just in the IP
16:48:14 <elliott> Deewiant: so you can't add per-ip state without modifying core code? ha ha ha
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: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: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: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: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: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:54:00 <elliott> (OK, so accessing fingerprint state incurs the cost of a map lookup, but come on.)
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:21 <oerjan> elliott: as i implied, i don't know what they use nowadays but lambdabot obviously uses _something_
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: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: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: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: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: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: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> fingerprints :: Map Value FP
17:02:50 <elliott> before I had Shiro.Types, I had whole circular-dependencies on types and type classes
17:03:02 <elliott> because hs-boot can't solve those
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: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:49 <Vorpal> elliott, well okay. What about MODE then
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: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:27 <elliott> Vorpal: SOCK can't be that hard :P
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: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: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:09 <elliott> Vorpal: It's the CONFORMANT implementation.
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: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:11 <elliott> Vorpal: I want to go for low-hanging fruit first :
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:26 <elliott> or was TRDS around very 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: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:23 <Vorpal> elliott, what about FING. That one is quite easy
17:15:37 <elliott> And lets me test my state system.
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: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: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:48 <Vorpal> elliott, you said 27 lines?
17:16:52 <Deewiant> elliott: abs (mod x y) can't be correct
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:18:02 <EgoBot> Sorry, I have no help for bfjoust!
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:12 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
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: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: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 <lambdabot> pointless <expr>. Play with pointfree code.
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: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: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: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: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: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: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: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: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: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: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 <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: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: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:13 <Deewiant> elliott: You can just make a State FungeState when you don't need IO
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: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 <oerjan> interestingly, if you think of underload as a monoid, those evaluation models become special cases...
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: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: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:13 <elliott> I can sort of see it in my head
17:33:21 <ais523> I wanted to add COME FROM to Haskell
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:47 <ais523> oh right, like Maybe with Nothing
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:09 <elliott> since monadic actions yield results
17:34:11 <elliott> and f takes those results...
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:16 <ais523> yep, that clearly makes no sense, and should equally clearly be legal
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: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:43 <elliott> oerjan: yeah... even so, you _can_ handle:
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 <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: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: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: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:43:06 <elliott> ais523: oh, it's to do with type families
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:30 <elliott> | I can't handle pattern bindings for existentially-quantified
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:40 <elliott> | Failed, modules loaded: none.
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: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:48:07 <elliott> Deewiant: Want to elaborate on the FING specification? :-P
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:49:03 <elliott> OK, FING is semi-non-trivial with my current fingerprint code, so I'ma skip it for now.
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:30 <ais523> but it's a little impractical for any other use
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: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:10 <elliott> ais523: it uses 0 or two 0-terminated lists
17:51:15 <elliott> so you have to scan it all
17:51:33 <elliott> ais523: did i mention that the (two 0)-terminated list is of 0gnirtses?
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:52:01 <ais523> but I was wondering if it was possible to go the other way
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:06 <elliott> http://www.haskell.org/ghc/docs/latest/html/libraries/base/System-Environment.html
17:52:07 <ais523> Gregor: some BSD, I think it works
17:52:09 <Deewiant> elliott: There's a constant number of cells prior to the size of the TOS
17:52:12 <elliott> look at a very interesting thing that's not there
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: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:54:08 <Deewiant> [80-char description per command] [explanatory bullet points]
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: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:24 <Deewiant> But then I realized you used it as a generic name
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: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:01:10 <elliott> I like how Data.List.Split lacks "split up to N of these".
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:28 <elliott> > break (=='=') "abc=def=quux"
18:04:06 <elliott> <elliott> So does EVAR's G default to "" or reflect
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 <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:08:24 <Vorpal> elliott, doesn't the spec say anything?
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: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: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: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: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:25 <Vorpal> "SMEM"0x534d454dSysV IPC Shared Memory
18:10:30 <Vorpal> elliott, you will do that one right?
18:10:39 <Vorpal> "SMPH"0x534d5048SysV IPC Semaphores
18:10:46 <Vorpal> elliott, from haskell? shared memory?
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:08 -!- BeholdMyGlory has joined.
18:11:12 <elliott> Vorpal: And it has extensive support for pointers.
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:56 <elliott> NCRS will be fun because ncurses is half macros!
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: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: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:53 <elliott> myndzi: ais523 says he can fix it but he's worried that it'd be cheating
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: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: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: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> Data.List genericIndex :: Integral a => [b] -> a -> b
18:15:38 <myndzi> careless doesn't care if it wins or not
18:15:42 <myndzi> it just plows on ahead
18:15:43 <ais523> Vorpal: it changes every cell that could be the flag approximately 128 times
18:15:54 <myndzi> it jumps out 10 cells, attacks fast then tries to finish, repeat
18:16:03 <ais523> it's like the extreme opposite of an offset clear
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: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:49 -!- impomatic has joined.
18:19:04 <Vorpal> myndzi, that you called it stupid made it look like you disliked the simple ones
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:41 <ais523> so I'd say that it's a valid program strategy
18:19:49 <elliott> WHY DO YOU WANT TO ACCESS A SPECIFIC INDEX OF THE NEIVORNMENT
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: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 <elliott> <hpc> oh god, it's homework isn't it?
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: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:32 <elliott> To modify: System.Posix.Env :-P
18:23:33 <ais523> elliott: that xplat quote deserves to be added to `addquote
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: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: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: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: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:37 <ais523> that really needs a better name
18:25:40 <myndzi> (which i like better than "anti")
18:25:49 <ais523> yep, inverse tripwire might do
18:25:52 <Deewiant> elliott: I don't implement much of the new stuff, in particular the system-level stuff
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: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: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: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: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:19 <ais523> elliott: "other than haskell"
18:29:40 <Vorpal> "hayoo", "hoogle" <-- why these lame puns.
18:29:45 <ais523> I'm mentioning your quote
18:30:03 <elliott> Hayoo came after Hoogle got popular
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: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:41 <Vorpal> elliott, I mean, you do want to run it on old non-vt100 style terminals right?
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: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:57 <Vorpal> elliott, doesn't it provide a portable clock API?
18:36:12 <elliott> Vorpal: Not a high-resolution one.
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:37:21 <elliott> Vorpal: but it also has hour/minute fields
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: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: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:40:09 <elliott> Vorpal: osjidgfhgohjdpfosgnsipfdbojker
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:27 <elliott> This was for if I wasn't using it
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:39 <elliott> ais523: s/Emacs'/my/ surely
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: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:28 <ais523> elliott, I'm sure you don't remember everything either
18:43:58 <elliott> That's what I was trolling Vorpal for :P
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:46:28 <Vorpal> Deewiant, you use the C Perl API instead of calling it?
18:46:44 <Deewiant> I wasn't aware such an API existed until elliott mentioned it today
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: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:15 <elliott> RETVAL = (input % 2 == 0);
18:49:16 <ais523> elliott: it is, that's what the API's generally used for
18:49:41 <ais523> because the actual internals of the API aren't human-consumable
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 <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: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 <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:52:06 <lambdabot> Data.Maybe listToMaybe :: [a] -> Maybe a
18:52:32 <elliott> oerjan: Welcome to five years ago?
18:52:44 <oerjan> (also listToMaybe = mplus, i think)
18:53:25 <elliott> * sproingie ponders, staticly typed Befunge. StrongFunge.
18:53:37 <elliott> <edwardk> spoingie: we need dependently typed strongfunge
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:25 <elliott> WHY DOES PERL_PARSE TAKE ARGC AND ARGV
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: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: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:59:08 <nescience> I noticed from breakdown.txt that there are four results for bfjoust runs
18:59:15 -!- pingveno has joined.
18:59:26 <nescience> presumably polarity switches: ++ +- -+ --
18:59:36 <Gregor> nescience: Yes yes, and they're redundant, we know.
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 <Vorpal> Gregor, heh you could cut time in half by just using ++ and +-
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: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:23 <ais523> elliott: do you mean +- ++?
19:01:26 <Deewiant> elliott: Shouldn't it be ++ +-?
19:01:33 <Vorpal> elliott, 1) nice solution to perl code 2) "..." to +- -+
19:01:39 <Gregor> elliott: DUMBASS oh burn
19:02:00 <elliott> I LIKE THE PART WHERE SYSTEM.PROCESS SUCKS
19:02:05 <Gregor> ais523: Now what's this about a repo being out of date?
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:30 <ais523> and that definitely isn't the most recent program submitted
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:47 <Vorpal> elliott, use the C FFI to call fork() ?
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:26 <ais523> it's got to be worth a try
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: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:51 <Deewiant> Aren't doubles accurate enough for that? (I haven't bothered looking at the details)
19:07:12 <ais523> Vorpal: it's not too hard, use the Taylor series
19:08:28 <elliott> Haskell has long double, it's called 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:15 <lambdabot> Data.Bits xor :: Bits a => a -> a -> a
19:09:24 <elliott> Deewiant: I meant boolean xor.
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:51 <Deewiant> If you're doing BOOL you want the Data.Bits stuff
19:10:58 <elliott> THEN WHY IS IT CALLED BOOL
19:12:47 <lambdabot> forall a b (f :: * -> *). (Functor f) => (a -> b) -> f a -> f b
19:16:21 <elliott> Dude! Deewiant! Mycology doesn't test BOOL!
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:56 <ais523> don't you mean >+[[-]>+]?
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: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:29 <EgoBot> Score for quintopia_flyingleap: 1.6
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:27 <ais523> that's like... the opposite of an offset clear
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: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:35 <ais523> you may as well stop and do a proper clear if you happen to reach the 30th cell
19:27:00 <Deewiant> elliott: So yeah, the (>)*16 is a good way to lower your score
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: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:13 <nescience> lol I was thinking about trying to add some extra >s to careless
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: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:02 <elliott> and all the bad players use awesome names
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:34 <nescience> I like good words and simple names
19:30:46 <ais523> I like impomatic's names
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: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: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: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: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: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: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:27 <elliott> !bfjoust but_what_of_faith >->+>->+>-->++>---->+>--((-)*10[+]>+(+)*10[-]>+)*10(-)*100[-]
19:36:31 <elliott> just go back to that version
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: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: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: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: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:42:31 <elliott> !bfjoust a_more_perfect_union >-[[-]++++>-[+]----->+]
19:42:34 <Gregor> quintopia: It's just a (very bad) shudderer
19:43:20 <Gregor> !bfjoust even_worse_shudderer (-)*127(.+-)*100000
19:43:59 <Gregor> Err ... wow, yeah that one is bad :P
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:23 <Gregor> quintopia: I refuse to actually know your terminology.
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: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: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: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:51:27 -!- nescience has quit (Remote host closed the connection).
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: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: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: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:57 <elliott> I'm going to do EMEM next.
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:55 <ais523> in fact, you knocked it above careless
19:55:04 <EgoBot> Score for elliott_absolutely_fucking_nothing: 15.2
19:55:21 <ais523> anyway, defend14 now beats careless in one polarity (so draws over all)
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:27 <ais523> Deewiant: no, that writes to fungespace; I meant, it finds a bit of unused fungespace that it hasn't allocated
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:20 <elliott> http://www.haskell.org/ghc/docs/6.12.3/html/libraries/base-4.2.0.2/Foreign-Marshal-Alloc.html
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: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: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: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:31 <elliott> oerjan: yes, the one that never truly got written
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: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:49 <ais523> btw, that careless-beating will work against any variation of careless, no matter how much myndzi tweaks the constants
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: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: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: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: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: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:21 <elliott> if it was calloc that'd be okay
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:20:01 <ais523> heh, shortsword's still on the leaderboard
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: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 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
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:17 <ais523> elliott: even 12 and 13?
20:25:18 <elliott> and lose sildly to 13 and 14
20:25:20 <EgoBot> Score for elliott_my_polarity_brings_all_the_boys_to_the_yard: 17.8
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: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:27:00 <EgoBot> Score for elliott_my_polarity_brings_all_the_boys_to_the_yard: 9.2
20:27:06 <ais523> shortsword was the first offset clearer
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: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: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: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: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: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: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:36:00 <quintopia> THIS SHOULD BE A WIKI ARTICLE STAT
20:36:09 <ais523> it should be a post on impomatic's blog
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: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: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: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:45:35 <elliott> Deewiant: wait, HTF do G and P work in EMEM?
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:52 <Deewiant> I don't know anything about EMEM, it's crap
20:54:02 <Deewiant> Presumably that's your pointer addition
20:54:40 <elliott> Deewiant: Name some low-hanging fruit that isn't EMEM then :P
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:57:17 <oerjan> i'm not sure i imagine bowling fitting that description better than golf...
20:57:41 <quintopia> in bowling you want to get as high a score as possible
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: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: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:47 <elliott> Deewiant: That WOULD be nice :-D
21:07:07 <Sgeo_> Is it just me, or is LibreOffice Base crap?/
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: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:58 <oerjan> i'm going to need the logs to actually see what you did there :D
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:50 <lambdabot> System.Posix.Types Fd :: CInt -> Fd
21:09:50 <lambdabot> Network.Socket fdSocket :: Socket -> CInt
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:30 <elliott> ok now to write helper functions for IntMaps with fingerprints
21:10:36 <elliott> except that would be a pain
21:11:14 <elliott> Deewiant: The Va that O pops is storage-offset, right? :-P
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: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:20:28 <ehird> ais523: so I've gone insane and am implementing befunge98
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: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: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:33 -!- iconmaster has joined.
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:13 <elliott> Deewiant: Dunno if Haskell has a nice file size function :D
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: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: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: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: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: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: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: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:34:22 <oerjan> elliott: `mplus` reflect after that...
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:46 -!- iconmaster has quit (Ping timeout: 245 seconds).
21:35:49 <Gregor> Hey there Tnurmb: No fucking fread!
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: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: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:42 -!- azaq23 has joined.
21:41:14 <elliott> I'm assuming that G reads a line.
21:42:36 <elliott> Actually I don't think so.
21:43:05 <Deewiant> "like c fgets", quoth the spec.
21:43:30 <elliott> Deewiant: fgets takes a size argument.
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:24 <ehird> Maybe 0.3
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: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:12 <elliott> fizzie: Do you have a program that just does the babbling?
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: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: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: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:51 <elliott> BAD: G didn't read 'foo\n'
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: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: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: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: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:13 <elliott> Thanks Deewiant, your naming scheme is confusing!
22:09:19 <Deewiant> mycotemp for FILE, mycotmp[0-9] for earlier
22:09:27 <Deewiant> I didn't expect to need another temp file.
22:09:36 <elliott> BBAD: couldn't reopen file in truncate+read mode
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:11:03 <elliott> 08:54:24 <ehird> data Point =
22:11:03 <elliott> 08:54:25 <ehird> x :: {-# UNPACK #-} !Int,
22:11:03 <elliott> 08:54:27 <ehird> y :: {-# UNPACK #-} !Int
22:12:11 <elliott> Deewiant: By "couldn't" you probably mean "reflects" right?
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:18 <elliott> Also -- BAD: O reflected leaving the stack untouched (or pushed an 'm' for no reason)
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:30 <Deewiant> Maybe you have a push 'm' there by accident
22:14:34 <elliott> filename <- pop0gnirtsAsString
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:48 <fizzie> There was some editor where non-line-wrapping mode scrolled only the line the cursor was on.
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:51 <elliott> Deewiant: Got a copy of slowdown.b98?
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: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: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: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 <Deewiant> Oh, right, it was in Finnish wasn't it
22:24:45 <elliott> You didn't notice how unreadable that was?
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: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: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:15 <elliott> Deewiant: Cool, my FILE never frees its file values.
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:23 <elliott> I need to find all your secrets first
22:30:27 -!- zzo38 has quit (Remote host closed the connection).
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: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: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: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:58 <elliott> Google is in league with the Finns.
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:38 <Deewiant> Dude, it's the simple past of seek
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: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: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:52:08 <elliott> Would like to solve that O thing first though.
22:52:13 <elliott> filename <- pop0gnirtsAsString
22:52:27 <elliott> That's absolutely correct.
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: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:59:28 <Deewiant> If you just called Mycology a dick I may have to be offended
23:00:22 <Sgeo_> I am a heterosexual male. Therefore, by what Gregor said, I do not live in 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:44 <Sgeo_> That sounds mildly demented
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: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: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:42 <elliott> olsner: I do that all the time. SO DOES DEEWIANT</troll>
23:12:02 <olsner> elliott: sure, but who cares what Deewiant does?
23:12:07 <fizzie> Contrary to the prior, it was in fact from memory, not contemporary Google. I've been... dabbling.
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: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:43 <elliott> Deewiant: Mmnope, I have a different error now.
23:14:57 <elliott> ("***",mycotemp.tmp: hSeek: illegal operation (handle is closed))
23:15:00 <elliott> Deewiant: My errors are now non-deterministic.
23:15:27 <Deewiant> Maybe the fd's actually closed at the next GC or something
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:52 <elliott> Problem: There's no reason whatsoever that should happen.
23:16:14 <elliott> Feels like I'm coding in C
23:16:22 <elliott> Sgeo_: liftIO, but shorter.
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:44 <elliott> Deewiant: There's no debug output, so there was no IO error.
23:17:51 <elliott> Define "failed". Reflected?
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: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: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> 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: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:25:24 -!- variable has joined.
23:26:01 <elliott> Deewiant: Wow, this debug build is quite the party.
23:28:25 <elliott> Deewiant: My tracing build of Shiro :P
23:28:31 <elliott> Mycology's stack gets rather big.
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:16 <Deewiant> And fungicide goes much higher
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: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> 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: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: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: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: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: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: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:38 <elliott> 3) Are you sure you know what you're talking 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: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: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: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: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:50:01 <elliott> Tight, yes, space-inefficient, no.
23:50:23 <Deewiant> What's "space-inefficient" in this case
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: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: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:32 <quintopia> mine optimizes stuff that doesn't wrap/cross boundaries too though
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:49 <elliott> plus the fact that it optimises only things that basically never 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