00:00:56 -!- iconmaster has joined.
00:01:23 -!- iconmaster has quit (Client Quit).
00:01:38 <elliott> Anyone wanna take a look at my file code? :P
00:02:31 <elliott> O KAY, if I make O just reflect after popping it _works_.
00:04:02 <elliott> ("***",mycotemp.tmp: openBinaryFile: does not exist (No such file or directory))
00:04:02 <elliott> BAD: O reflected leaving the stack untouched (or pushed an 'm' for no reason)
00:04:11 <elliott> so it *does* fail in the right place
00:04:26 <elliott> it can't be reflecting in the same way
00:04:31 <elliott> it goes totally differently
00:05:34 <elliott> Testing fingerprint FILE... loaded.
00:05:34 <elliott> ("***",mycotemp.tmp: openBinaryFile: does not exist (No such file or directory))
00:05:34 <elliott> BAD: O reflected leaving the stack untouched (or pushed an 'm' for no reason)
00:05:56 <elliott> This is ... breaking every rule of logic
00:06:05 <fizzie> jitfunge-style tracing/caching of instructions (into linear-in-memory basic blocks) might be a win in some cases even without the jit (just think of it as icache in a cpu), since the instruction fspace-fetches take quite a lot of time.
00:06:15 <elliott> Deewiant: That error message better be SUPER misleading... but even if it is...
00:06:19 <elliott> there is absolutely no way this is happening.
00:06:30 <elliott> If I make it reflect it works. If it reflects, it doesn't work.
00:06:52 <fizzie> Implementing that is a bit ugly though, there's all kinds of cases to take care of when the fungespace changes.
00:07:14 <fizzie> So Deewiant's bounding-boxes may be better.
00:07:41 <elliott> fizzie: How is jitfunge doing btw? Any work?
00:07:44 <fizzie> Deewiant: Do you do something like keep a pointer of the "current" box for an IP?
00:08:06 <fizzie> Nothing new there, but maybe all this fungetalk will inspire me.
00:08:22 <quintopia> fizzie: i was just thinking of storing a pointer to the path-cache in each whitespace cell that gets crossed. it means a little extra work the first time the path is crossed, but invalidating on p commands is instantaneous. it could be a flag you can turn on and off when you think it'll help
00:09:44 <fizzie> Wrapping paths might possible need to be all recomputed if the boundaries change.
00:09:51 <elliott> THIS CODE MAKES NO FUCKING SENSE
00:10:01 <elliott> You're totally losing me here, Haskell.
00:10:12 <elliott> Losing me with your what-the-fuck.
00:10:20 <elliott> OK. Maybe I have a bug in catchShiro.
00:10:29 <elliott> catchShiro :: (Exception e) => Shiro a -> (e -> Shiro a) -> Shiro a
00:10:29 <elliott> catchShiro action handler =
00:10:29 <elliott> StateT $ \s -> runStateT action s `catch` (\e -> runStateT (handler e) s)
00:10:43 <elliott> Except that I think it might fail to... nope...
00:10:49 <fizzie> Whitespace-skipping sounds like a rather limited win compared to instruction-fetches. At least assuming reasonable code densities. :p
00:11:00 <elliott> ...nope, I'm pretty sure that's perfect. Deewiant? Any bugs obvious to you? :p
00:11:20 <quintopia> fizzie: what you mean by instruction fetching?
00:11:28 <Deewiant> Creating a StateT manually looks dubious but beats me
00:11:47 <quintopia> like pipelining/preloading instruction?
00:11:49 <fizzie> The thing where you do a fungespace lookup for the next instruction.
00:12:16 <Deewiant> That is by far the relevant thing to optimize.
00:12:33 <elliott> Deewiant: You wrote that code IIRC.
00:12:36 <lambdabot> forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
00:12:51 <elliott> Possibly e's type is wrong there.
00:13:04 <Deewiant> elliott: e :: SomeException should catch everything
00:13:06 <fizzie> A proper instruction cache is trickier, though; for ;-jumps you need to invalidate things when a ; is put in the middle and so on.
00:13:10 <quintopia> just cache the next instructions, and undo them if they turn out not to be the right ones ... basically how branch prediction works in processors
00:13:11 <elliott> Deewiant: Right. Which I don't want.
00:13:14 <elliott> I only want to catch IOException.
00:13:26 <Deewiant> If you have Prelude.catch it'll catch only that
00:13:40 <elliott> Right. I'll just inline catchShiro into doIns.
00:14:52 -!- augur has joined.
00:14:57 <elliott> BAD: O reflected leaving the stack untouched (or pushed an 'm' for no reason)
00:15:25 <elliott> fizzie: Can you look at this block of code? I seriously just need someone to tell me how stupid I am for missing this obvious bug.
00:15:33 <elliott> Because I CAN'T SEE IT >_<
00:15:52 <elliott> Once-in-a... ok, not once in a lifetime, I'm laughable-at regularly.
00:17:40 <elliott> http://sprunge.us/iHdM if anyone wants to laugh at me.
00:23:05 <Sgeo_> Browser's being slow
00:23:12 <Sgeo_> I do want to laugh at you though
00:23:15 -!- Mathnerd314 has quit (Ping timeout: 276 seconds).
00:24:48 <Sgeo_> WBE BETTER IF I KNEW WHAT IT WAS SUPPOSED TO DOargh packs lock
00:26:01 <Sgeo_> And for capslock to die
00:27:02 <Sgeo_> I assume parents arond the mode < 0 and the mode > 5 won't help, if precedence were weird it wouldn't typecheck?
00:27:24 <elliott> Even then I think both should reflect at the same point.
00:28:37 <Sgeo_> I'm about to have access to hoogle
00:29:07 <lambdabot> Data.Graph.Inductive.Example a :: Gr Char ()
00:29:07 <lambdabot> Data.Graph.Inductive.Example a' :: IO (SGr Char ())
00:29:07 <lambdabot> Data.Graph.Inductive.Example ab :: Gr Char ()
00:29:27 <Sgeo_> That's... especially useful
00:29:39 <elliott> But it's totally irrelevant.
00:29:45 <elliott> I have checked -- beyond doubt, by tracing the error -- that openBinaryFile fails.
00:29:51 <elliott> And that nothing after it executes.
00:29:58 <elliott> And my exception handler reflects on failure.
00:30:03 <elliott> I see no possible way the two code snippets could differ in behaviour.
00:30:26 <Sgeo_> Two code snippets?
00:32:26 <Sgeo_> So O isn't supposed to read?
00:32:30 -!- poiuy_qwert has joined.
00:35:03 <Sgeo_> @hoogle openBinaryFile
00:35:03 <lambdabot> System.IO openBinaryFile :: FilePath -> IOMode -> IO Handle
00:35:20 <lambdabot> Control.Monad.Trans liftIO :: MonadIO m => IO a -> m a
00:35:40 <elliott> copumpkin: http://sprunge.us/iHdM ;_; haskell sucks because this doesn't make sense
00:35:47 <elliott> (my tried and trusted support mechanism)
00:36:02 <Sgeo_> It's not an indentation issue, right?
00:36:11 <Sgeo_> It ... looks right to my eyes
00:37:21 <Sgeo_> Try openBinaryFile in GHCi with arguments that would be given to it by whatever?
00:38:21 <elliott> Sgeo_: As I said, _I have logged that openBinaryFile fails_.
00:38:32 <elliott> I have added to the exception handler a print statement and it prints out the correct error from openBinaryFile.
00:38:40 <elliott> As that line runs, the next one, which reflects the IP, runs too.
00:38:45 <elliott> Therefore the code should be identical.
00:39:06 <Sgeo_> And it's not? what happens?
00:39:36 <elliott> As I said, I have no idea what happens.
00:40:12 <Sgeo_> You're saying that openBinaryFile errors and should result in a reflect. It's not doing that, if I understand you correctly. What is it doing?
00:41:38 <elliott> It reflects, but something goes wrong with the stack.
00:42:09 <Sgeo_> So it might be an error in your error-handling code?
00:42:31 <elliott> StateT $ \s -> runStateT (coreIns . chr . fromIntegral $ i) s
00:42:31 <elliott> `catch` \(_::IOException) -> runStateT reflect s
00:43:46 <Sgeo_> Is push supposed to alter the stack?
00:44:10 <Sgeo_> Why would openBinaryFile being replaced by reflect stop the rest of the code from executing?
00:44:16 <Sgeo_> This may be a dumb question, of course
00:44:31 <elliott> Sgeo_: because it's an exception
00:44:38 <elliott> Sgeo_: and, i've already print-debugged that it does
00:46:04 <elliott> Sgeo_: the core instruction evaluator
00:48:26 <elliott> ...ouch that's a nasty bug
00:48:34 <Sgeo_> elliott, what was it?
00:48:53 <elliott> Sgeo_: the state would be part of the state returned by the first runStateT, but since it errors out, we never get that state
00:48:58 <elliott> and reflect based on the _previous_ state
00:49:00 <elliott> so all the popping is lost
00:49:07 <elliott> this means that my error handling is totes broken
00:49:30 <Sgeo_> I was right about something?
00:50:26 <elliott> Yeah, but I was already considering that :P
00:51:20 <elliott> This is going to complicate so much code >_<
00:51:40 <Sgeo_> I don't think I ever really learned IO exceptions
00:52:47 <Sgeo_> Then again, even the liftIO stuff is.. not stuff that I really remember anything about
00:57:58 <lambdabot> GHC.IO.Handle.Types.Handle -> Integer -> IO ()
00:58:36 <lambdabot> Control.Monad when :: Monad m => Bool -> m () -> m ()
00:58:38 <lambdabot> System.Directory createDirectoryIfMissing :: Bool -> FilePath -> IO ()
00:58:38 <lambdabot> Network.HTTP.Headers HdrIfMatch :: HeaderName
00:58:38 <lambdabot> Network.HTTP.Headers HdrIfModifiedSince :: HeaderName
01:07:58 <elliott> Ohmygawd this is going to get so ugly.
01:15:26 <elliott> Sgeo_: No, I made it less ugly again.
01:16:10 <elliott> BAD: O opened 'mycotemp.tmp' for reading, won't overwrite it and thus won't test fingerprint
01:17:20 <Sgeo_> By Io, I meant the language >.>
01:17:47 <elliott> There is no way this code would still be standing of not for the expressivity Haskell has given me.
01:18:08 <elliott> Heck, even CCBI has extensive compile-time metaprogramming and use of strong typing.
01:18:47 <Sgeo_> Surely metaprogramming isn't Haskell's forte? Is Template Haskell really that great?
01:19:10 <elliott> Template Haskell is a bitch to code the templatey bits for but a joy to use and very expressive, yes.
01:19:21 <elliott> Sgeo_: But rather I'm doing things in Haskell that would be impossible to do without compile-time metaprogramming in other languages.
01:19:22 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
01:19:27 -!- azaq23 has quit (Ping timeout: 246 seconds).
01:19:32 <elliott> Such as my Fingerprint typeclass.
01:20:03 <elliott> \(ShiroIOException st) -> reflect >> put st
01:20:07 <elliott> (should be put st >> reflect)
01:20:50 <elliott> Sgeo_: "Mycelium (plural mycelia) is the vegetative part of a fungus, consisting of a mass of branching, thread-like hyphae. The mass of hyphae is sometimes called shiro, especially within the fairy ring fungi."
01:22:07 -!- azaq23 has joined.
01:23:21 <pikhq> SCEA published the PS3 key by accident on Twitter.
01:23:35 <pikhq> I am now referring to this case as SCEA v. Hotz, SCEA, et al.
01:24:24 <pikhq> http://twitpic.com/3xwe6h Screenshot, as the post was brought down.
01:24:54 <pikhq> TheKevinButler is the Twitter account of a fictional character used by Sony for promotion.
01:25:13 <elliott> pikhq: Run by an idiot, evidently.
01:25:40 <pikhq> But nevertheless. SCEA is now a John Doe defendant in the case. :P
01:28:33 -!- zzo38 has joined.
01:30:11 <Sgeo_> http://blog.moviefone.com/2011/02/09/mpaa-disconnect-internet/?a_dgi=aolshare_twitter lolwat
01:30:51 <elliott> I should read Techdirt more.
01:31:06 <elliott> Us anti-copyright fellows have to stick together.
01:32:21 -!- nescience has quit (Read error: Connection reset by peer).
01:32:24 -!- nescien29 has joined.
01:32:49 -!- nescien29 has quit (Client Quit).
01:33:34 <Gregor> http://angryhosting.mirror.waffleimages.com/files/ff/ff52cc68b141e3122963cbff434934fb24cbd74c.jpg Oh IPv4
01:36:43 <elliott> Deewiant: Self-log-read-ask: Vorpal: When FILE functions reflect, do they push the file handle back again, or keep it popped?
01:36:53 <zzo38> Gregor: What do you win? I think not.
01:37:58 <Sgeo_> zzo38, we both saw it in the same place
01:39:15 <elliott> (LOOK AT THAT FAST IN-BRAIN DATABASE QUERY)
01:42:45 -!- copumpkin has joined.
01:43:59 <elliott> Gregor: Please, like you'd willingly associate with Sgeo anywhere >:D
01:57:17 <pikhq> Sony is also filing for a subpoena to obtain every document in Paypal's possession.
01:57:31 <pikhq> Not every document relevant to a one George Hotz.
01:58:06 <Sgeo_> They need US lawyers on their legal team, I think
01:58:23 <pikhq> Sgeo_: The lawyers in question are a block down the road from the courthouse.
01:58:48 <Sgeo_> Why was I thinking Japan?
01:58:49 <pikhq> SCEA is a US company which, interestingly, does not actually have anything to do with the Playstation 3.
01:59:14 <pikhq> It may be found that SCEA cannot sue for being a completely unassociated party.
02:00:08 <pikhq> The company that actually *makes* the PS3 is Sony Kabushikigaisha.
02:00:15 <pikhq> Which is, of course, in Japan.
02:03:27 -!- Slereah has quit.
02:07:56 <elliott> 07:59:13 <ais523> fizzie: which reminds me, we should write a Lisp interp in Nintendo DS asm someday, collectively
02:07:56 <elliott> 07:59:17 <ais523> purely to annoy Joel Spolsky
02:14:27 <zzo38> One common protocol used to receive email messages from the service provider is POP3, but I think an option to use SMTP should be given. After authenticating and sending any messages you want to send, you send TURN and then you will receive messages from the server (you can send back response codes to retain the message or whatever), ...
02:14:45 <zzo38> ... and then after all messages are received, the server sends TURN and then you can continue to send more messages or QUIT
02:16:28 <zzo38> As far as I know most mail services do not support SEND or TURN
02:32:29 <elliott> ##WhatIsGoingOnInSgeosDayToday
02:32:35 <elliott> That is the channel we are in
02:47:30 <pikhq> Though, given that it's apparently made by Gregor, it may just taste weird to those of us who are more osmic.
02:49:17 <elliott> pikhq: He's been doing this for ages.
02:49:23 <elliott> OK, strace proves that C works properly and files are being closed.
02:49:26 <elliott> But it's still reading wrong.
02:49:38 <elliott> And then remove debug statements :P
02:50:26 <elliott> He likes ginger-flavoured beverages, so obviously he's not human.
02:51:00 <pikhq> I love ginger-flavored beverages.
02:51:37 <pikhq> Proper ginger beer is deliciousness.
02:53:02 <pikhq> "Dry" ginger ale is very solidly meh, though.
02:53:41 <elliott> Ginger drinks just taste like bitter :P
02:53:42 <pikhq> (originally used as a mixer for liquor, and hence is much less ginger-y. Inexplicably, it's very popular.)
02:53:53 <zzo38> What I should do is once I make complete version of TeXnicard, compile the DVI file without line numbers, and then find out the large empty space in texnicard.dvi (and plain_cards_book.dvi) to insert other stuff there, such as pictures, diagrams, quotation, cartoons, and whatever else (as long as there is a large enough quiet area around it).
02:54:06 <pikhq> elliott: Bitter is something that ginger isn't. At all.
02:54:23 <pikhq> Spicy? Yes. Bitter? WTF.
02:54:33 <zzo38> I don't know because I have never drink ginger or beer.
02:54:49 <elliott> pikhq: I mean, it just tastes harsh, I don't get much of a ginger taste from it.
02:54:58 <elliott> Compare with e.g. ginger nuts, biscuit of the gods*
02:55:02 <elliott> *apart from every other biscuit
02:55:51 <elliott> It was... it was glorious.
02:55:59 <elliott> It was *utterly* glorious.
02:56:35 <zzo38> If you are stuck in a elevator with only two buttons, one labeled "?" and the other one is labeled "!", then what are you going to do?
02:56:45 <pikhq> elliott: You may not have actually had a good ginger beer/ale, then.
02:57:06 <pikhq> elliott: Though you were definitely closer to "good" than most Americans' experience with it.
02:57:16 <elliott> SGEO ON IMPLEMENTING FUNGE-98: 11:44:16 <Sgeo_> I guess I shouldn't allocate a 2^32 by 2^32 array/list/whatever
02:57:30 <pikhq> (which is a beverage which actually approaches bland.)
02:57:34 <zzo38> elliott: But there is nobody else in elevator. The only people to punch would be yourself.
02:57:58 <elliott> 11:46:01 <Deewiant> alise: I maintain that the core can be done in less than a 1000 lines :-P
02:58:01 <zzo38> The door is automatic and has no handle to open.
02:58:11 <elliott> zzo38: I'd get my nails in-between and open it manually.
02:58:37 <pikhq> I guess I'm being a bit too harsh on dry ginger ale.
02:58:42 <pikhq> It's *alright*, I guess.
02:58:56 <pikhq> It just pales in comparison to the sheer delicious GLORY that is the real thing.
02:59:12 <zzo38> O, ya? And what happened in case you fall into an open elevator shaft and *die*? (And also ruin the elevator due to a dead body being stuck in the shaft)
02:59:33 <Sgeo_> I misunderstood the term for a second
02:59:41 <Sgeo_> Thought it meant two equivalent options in Go
02:59:44 <elliott> zzo38: So I got in, and didn't get out when I noticed that its buttons were crazy?
02:59:46 <Sgeo_> It's... related to that, i guess
03:00:30 <zzo38> elliott: Of course I wouldn't think such a things would actually happen, either.
03:00:45 <zzo38> It is like a kind of thought experiment, instead.
03:02:12 <elliott> 11:56:53 <Deewiant> AnMaster: Can we agree to unimplement static areas? I don't like them :-P
03:02:12 <elliott> 11:57:09 <AnMaster> Deewiant, what? Of course I'll keep it
03:02:12 <elliott> 11:57:24 <AnMaster> Deewiant, why should I remove it when it speeds things up? :P
03:02:12 <elliott> 11:57:33 <Deewiant> It slows down wrapping programs
03:02:13 <elliott> 11:57:43 <AnMaster> Deewiant, oh? AABBs don't though
03:02:15 <elliott> 11:57:46 <Deewiant> It increases memory usage
03:02:17 <elliott> 11:57:49 <AnMaster> well yes
03:02:19 <elliott> 11:57:56 <Deewiant> For CCBI, it's only faster because the hardware is faster at using constants than variables
03:02:22 <elliott> 11:57:59 <AnMaster> but I prefer speed in speed-memory tradeoffs
03:02:24 <elliott> 11:58:07 <Deewiant> I think it's such a hack all in all :-P
03:02:26 <elliott> 11:58:09 <AnMaster> Deewiant, well sure, but that is always true
03:02:28 <elliott> 11:58:18 <AnMaster> Deewiant, you don't need to implement it in CCBI
03:02:30 <elliott> Deewiant: You have to remove the static area from CCBI :-P
03:04:43 <elliott> pikhq: Are you ever gonna finish that Funge-98 interp? :-D
03:06:31 <pikhq> elliott: I never even started.
03:06:46 <pikhq> elliott: I'm afraid I have other things to do.
03:06:53 <Sgeo_> I should implement Funge-98 at some point
03:07:04 <pikhq> Like attempt to get something resembling a social life, learn Japanese, and play Minecraft.
03:07:08 <pikhq> Conflicting goals, I know.
03:07:45 <coppro> pikhq: what are you doing right now? student?
03:07:53 <Sgeo_> elliott, you have no faith in me?
03:08:01 <elliott> Sgeo_: I have no faith in /anyone/, Funge-98 is a bitch
03:08:04 <pikhq> coppro: Seeking CS and math degrees.
03:08:16 <coppro> pikhq: go find some student group or something to hang out at
03:08:21 <coppro> and/or play Minecraft at
03:08:27 <elliott> And that's excluding the fingerprint code.
03:08:28 <pikhq> coppro: The student groups suck.
03:08:33 <pikhq> coppro: I'm at a community college ATM.
03:08:36 <elliott> Anything that takes 820 lines of Haskell is fucking hard.
03:08:56 <pikhq> coppro: And this is a city notable for a complete lack of anything happening.
03:09:10 <pikhq> coppro: As you can imagine, that makes social things difficult.
03:09:33 <pikhq> Screw you, far-right conservatives. Screw you so much.
03:09:52 <pikhq> (Colorado Springs, CO. Christian fundamentalist capital of the US.)
03:10:04 <elliott> 12:23:24 <pikhq> Also, 98-Fungespace is hard to do efficiently.\
03:10:04 <elliott> 12:23:39 <pikhq> I'm not entirely sure what datastructure I'd *like* to use.
03:10:10 <elliott> i am very tempted to switch to quadtrees at some point
03:10:14 <pikhq> elliott: So I thought about it.
03:10:15 -!- elliott has left (?).
03:10:18 -!- elliott has joined.
03:10:18 <coppro> also you're doing a double degree?
03:10:31 <pikhq> coppro: Yes, and it will take 3 credit hours more.
03:10:33 <pikhq> elliott: So I thought about it.
03:10:45 <pikhq> elliott: Inplementing Funge-98.
03:10:45 <coppro> pikhq: yeah, it's not hard to double major CS/something else here
03:10:52 <Sgeo_> elliott, what are you using now?
03:10:56 <coppro> where something else is a math field
03:11:05 <pikhq> coppro: It's *pretty* easy to double major math/anything here.
03:11:12 <coppro> but you can only get one degree out of it; either a BCS if you're lame or a BMath if you aren't
03:11:14 <elliott> Sgeo_: just an associative array
03:11:16 <zzo38> Sometimes you are so "fundamentalist" that you are not only fundamentalist, you are now Illogical Christianity (cf. Jack Chick)
03:11:24 <pikhq> coppro: It requires a gigantic swath of electives, you see.
03:11:26 <elliott> pikhq: "So I thought about it"
03:11:34 <coppro> actually maybe you can't get a double major on a BCS; BCS is weird
03:11:38 <elliott> Do you mean you thought you'd use quadtrees too?
03:11:48 <pikhq> elliott: But I never actually did anything related to implementing Funge-98.
03:12:00 <elliott> I was just using your lines as a piggyback for my own opinions :P
03:12:35 <pikhq> coppro: Anyways, pretty easy to add math onto a CS degree. What with a CS degree having a free math minor pretty much everywhere.
03:12:46 <pikhq> (exception, Sgeo's college, though that's not a CS degree.)
03:12:53 <zzo38> s/s/s/s//s/s/s/s/ss///ssss/////s/s///s//s///s/s//s/s///
03:13:29 <coppro> pikhq: pure math minor requirements: http://ugradcalendar.uwaterloo.ca/page/MATH-Pure-Mathematics-Minor-1
03:13:38 <quintopia> is this a valid slashes program if you remove the s's?
03:15:10 <pikhq> coppro: Y'mean this? http://ugradcalendar.uwaterloo.ca/page/MATH-Plans-Outside-Math-Pure-Mathematics-Minor
03:15:30 <pikhq> Oh, wait, is CS in "Faculty of Mathematics"?
03:15:51 <pikhq> Yeah, looks like a nearly-free math minor for a CS student...
03:16:01 <coppro> if you can handle PMATH courses
03:16:11 <Sgeo_> elliott, you expect me to transfer within this semester?
03:16:33 <coppro> I did the math; it's actually possible to triple major PMATH, CS, and CO with only a few extra credits
03:17:17 <coppro> combinatorics and optimization
03:17:41 <coppro> you could probably swap CO or PMATH for applied math too
03:17:58 <coppro> if you can stomach taking the tough courses, you can get a ridiculous piece of paper at this university
03:20:28 <pikhq> Sgeo_: Remember: your course of study wouldn't earn you a CS *minor* anywhere else.
03:36:13 -!- azaq23 has quit (Quit: Leaving.).
03:36:27 -!- elliott has quit (Quit: Leaving).
04:15:13 <pikhq> Well I'll be damned. There's actually a useful IPv6 transition mechanism for letting an IPv6 host on the IPv4 Internet.
04:15:28 <pikhq> NAT64 is, as you can imagine, a NAT scheme between IPv6 and IPv4.
04:15:59 <pikhq> DNS64 is, essentially, having the DNS server generate AAAA records that will actually be mapped by NAT64.
04:17:14 <quintopia> how many host can be behind the NAT?
04:17:18 <pikhq> Granted, this is still essentially carrier-grade NAT, and has all the problems inherent in that, but at least it would only be used for accessing IPv4-only hosts...
04:17:54 <pikhq> quintopia: 2^16-1 simultaneous connections, I do believe.
04:19:51 <pikhq> ARIN has actually reserved a block soley for IPv6 transition schemes such as NAT64...
04:23:59 <Sgeo_> "http://engt.co/e3LA1T"
04:24:43 <Sgeo_> "The study also shows that, despite concerns about online safety, one in eight young people is in contact with strangers when on the web and often lies about their appearance, age and background.
04:24:52 <Sgeo_> What a horrible thought
04:26:12 <pikhq> BTW guys I've been lying about my appearance, age, and background.
04:26:55 <pikhq> I'm really a 4-dimensional being whose appearance you could not even contemplate, I am ageless, and my desktop background is solid gray.
04:27:52 <quintopia> and i'm actually a post-singularity AI traveled back in time and stored myself as a brainfuck program in a CERN supercomputer
04:28:24 <quintopia> it's like death being in such a slow language, but their toy BF interpreter was the only security hole i could exploit from the future
04:43:29 <zzo38> They did the report about making a computer that can be one of the players in Jeopardy! game. Their opponents are the two best players in Jeopardy! ever. The computer ended in a tie.
04:47:16 <quintopia> i figured Watson'd kick their asses
04:52:13 <zzo38> Almost! But they tied three ways (that happened only once before).
04:52:26 <zzo38> (And the time before, it wasn't a computer.)
04:54:35 -!- zzo38 has quit (Remote host closed the connection).
04:58:48 <Gregor> 15 32.94 5.74 ais523_defend9.bfjoust
04:58:49 <Gregor> 37 32.69 -6.29 myndzi_butter.bfjoust
04:58:52 <Gregor> Best scoring system ever.
04:59:12 <Gregor> Difference in points: 12.03 (and one is negative)
04:59:18 <Gregor> Difference in score: 0.25
05:00:50 <quintopia> it's truly the perfect scoring system
05:10:03 -!- poiuy_qwert has quit (Ping timeout: 240 seconds).
05:10:44 -!- poiuy_qwert has joined.
05:22:09 -!- asiekierka has joined.
06:00:28 <Ilari> Heh. IPv6 address space isn't nearly as large as is comonly stated. The effective size is only something like 20 000 to 100 000 times the size of IPv4 space. Or something like that.
06:01:28 -!- asiekierka has quit (Read error: Operation timed out).
06:01:43 <pikhq> Counting inherent overhead in how blocks are assigned, I see.
06:02:17 <Ilari> More like allocation sizes.
06:04:56 <Ilari> There are 35 184 372 088 832 /48s in global unicast space. That's about 9 500 times the total number of usable IP addresses in IPv4. But how many such addresses would each such /48 "replace"?
06:06:23 <Ilari> And of course, smaller places could get /56s or so and it would be very likely more than sufficient.
06:10:52 <pikhq> Not to mention that the smallest "usual" allocation is a /64.
06:12:31 <pikhq> The gleeful disposal of addresses probably does make routing easier, but definitely does make the whole "IPv6 is enough to address every bit of sand on every beach in the world" thing seem like BS.
06:21:01 -!- pikhq has quit (Read error: Connection reset by peer).
06:21:32 -!- pikhq has joined.
06:34:32 -!- hagb4rd has joined.
06:48:25 <quintopia> MAN I FORGOT HOW AWESOME THIS SONG WAS
06:49:21 <quintopia> Homage the Halfrican Cracker - I Just Do Theory
06:52:43 <fizzie> elliott: I think I've mostly been assuming that when they reflect, all the arguments have disappeared from the stack; but since they "keep" the handle on stack "normally" I guess that's arguable.
06:53:27 <fizzie> It does make it marginally easier to close the handle after a failing operation if it does stay there.
07:40:01 -!- oerjan has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:26:52 -!- augur has quit (Remote host closed the connection).
08:31:42 -!- ais523 has joined.
08:31:47 -!- augur has joined.
08:39:54 -!- poiuy_qwert has quit (Read error: Operation timed out).
08:40:17 -!- ais523 has quit (Read error: Connection reset by peer).
08:41:05 -!- ais523 has joined.
08:41:47 -!- augur has quit (Remote host closed the connection).
08:42:52 -!- augur has joined.
08:43:32 -!- hagb4rd has quit (Ping timeout: 240 seconds).
08:49:32 -!- cheater00 has quit (Ping timeout: 240 seconds).
08:50:28 -!- cheater00 has joined.
08:59:48 -!- Mannerisky has left (?).
09:05:36 -!- copumpkin has quit (Ping timeout: 250 seconds).
09:06:01 -!- copumpkin has joined.
09:20:18 -!- ais523 has quit (Read error: Connection reset by peer).
09:28:06 -!- ais523 has joined.
09:41:06 -!- ais523 has quit (Remote host closed the connection).
09:41:51 -!- pikhq has quit (Read error: Operation timed out).
09:42:20 -!- ais523 has joined.
09:43:00 -!- pikhq has joined.
10:00:34 -!- Slereah has joined.
10:35:41 -!- Deewiant has quit (Read error: Connection reset by peer).
10:36:01 -!- Deewiant has joined.
10:36:40 -!- augur has quit (Remote host closed the connection).
10:42:00 <ais523> !bfjoust decoytuner >+>+>->>>>>(>[>-[++[+[+[-----[-[((-)*120(.-)*16>)*19](>---[(+)*120[+]])*19](>--[(+)*120[+]])*19](>+++[(+)*120[+]])*19](>++[(+)*120[+]])*19](>+[(+)*120[+]])*19](>-[(+)*120[+]])*19])*20>[[-]][-]
10:42:23 <ais523> hmm, I see an obvious improvement to that
10:42:54 <ais523> but I doubt the strategy will work too well anyway
10:44:38 <EgoBot> Score for ais523_decoytuner: 31.7
10:46:43 <ais523> !bfjoust decoytuner >+>+>->>>>>(>[>-[++[+[+[-----[-[(-)*115(.-)*16(>(-)*120(.-)*16)*18](+>---[(+)*120[+]])*19](+>--[(+)*120[+]])*19](+>+++[(+)*120[+]])*19](+>++[(+)*120[+]])*19](+>+[(+)*120[+]])*19](+>-[(+)*120[+]])*19])*20>[[-]][-]
10:46:55 <ais523> that incorporates the obvious fix, and also a trail
10:46:58 <EgoBot> Score for ais523_decoytuner: 34.4
10:52:38 <ais523> !bfjoust decoytuner >+>+>->>>>>(>[>-[++[+[-----[(-)*118(.-)*16(>(-)*120(.-)*16)*18](+>--[++++[(+)*118[+]]])*19](+>++[----[(-)*118[-]]])*19](+>+[--[(-)*119[-]]])*19](+>-[++[(+)*119[+]]])*19])*20>[[-]][-]
10:52:49 <EgoBot> Score for ais523_decoytuner: 48.6
10:54:22 <ais523> there's a bug, that should have beaten rather than tied with shortsword
10:55:21 <ais523> !bfjoust decoytuner >+>+>->>>>>(>[>-[++[+[----[(-)*118(.-)*16(>(-)*120(.-)*16)*18](+>--[++++[(+)*118[+]]])*19](+>++[----[(-)*118[-]]])*19](+>+[--[(-)*119[-]]])*19](+>-[++[(+)*119[+]]])*19])*20>[[-]][-]
10:55:26 <ais523> duh, that was stupid...
10:55:34 <EgoBot> Score for ais523_decoytuner: 50.3
10:59:30 <ais523> it uses a strategy inspired by myndzi, in that it's doing something similar to careless, but with various elements of my own thrown in (something entirely new, and some ideas from wiggle and tripwire_avoider too)
11:03:10 <ais523> unlike careless, it doesn't beat programs that leave no decoys, in order to get an advantage over programs that do
11:06:31 -!- FireFly has joined.
11:09:11 -!- augur has joined.
11:22:31 -!- pikhq has quit (Ping timeout: 240 seconds).
11:22:49 -!- pikhq has joined.
11:30:47 -!- variable has quit (Ping timeout: 260 seconds).
11:32:36 -!- variable has joined.
11:41:47 -!- BeholdMyGlory has joined.
12:10:53 -!- poiuy_qwert has joined.
12:22:25 -!- ais523_ has joined.
12:37:49 -!- ais523_ has quit (Quit: Page closed).
12:47:56 -!- MigoMipo has joined.
12:49:29 -!- Ilari has quit (Read error: Operation timed out).
12:51:15 -!- Ilari_antrcomp has quit (Ping timeout: 260 seconds).
12:53:59 -!- Ilari has joined.
12:55:53 -!- pikhq has quit (Read error: Operation timed out).
12:57:34 -!- pikhq has joined.
12:59:23 -!- atrapado has joined.
13:00:13 -!- Ilari_ has joined.
13:00:23 -!- Ilari_ has changed nick to Ilari_antrcomp.
13:02:55 -!- hiato has quit (Read error: Operation timed out).
13:03:10 -!- hiato has joined.
13:22:18 -!- Sgeo has joined.
13:24:39 -!- Sgeo_ has quit (Ping timeout: 255 seconds).
13:24:52 -!- taotree has quit (Quit: Ex-Chat).
13:41:50 <Gregor> FFFFFFFFFFFUUUUUUUUUUUUUUUUU
13:44:59 -!- cheater00 has quit (Ping timeout: 240 seconds).
13:45:56 -!- cheater00 has joined.
14:02:35 -!- nddrylliog has joined.
14:22:51 -!- poiuy_qwert has quit (Quit: This computer has gone to sleep).
14:34:58 -!- asiekierka has joined.
14:54:09 -!- cheater00 has quit (Ping timeout: 240 seconds).
14:55:01 -!- cheater00 has joined.
14:55:50 <ais523> !bfjoust decoytuner >+>+>->>>>(>[>-[++[+[----[(-)*118(.-)*16(>(-)*120(.-)*16)*18](+>--[++++[(+)*118[+]]])*19](+>++[----[(-)*118[-]]])*19](+>+[--[(-)*119[-]]])*19](+>-[++[(+)*119[+]]])*19])*20>[[-]][-]>[[-]][-]
14:57:28 -!- Mannerisky has joined.
14:59:43 <EgoBot> Score for ais523_decoytuner: 54.4
15:00:18 <ais523> hmm, I wonder if decoytuner will be up at 100 by the time I stop finding and fixing obvious bugs?
15:01:26 <ais523> let's see what happens if I add a defence detector
15:02:33 <ais523> !bfjoust decoytuner >+>+>->>>>(>[>-[++[+[----[(-)*118(.-)*16(>(-)*120(.-)*16)*18][+-.-](+>--[++++[(+)*118[+]]])*19][+-.-](+>++[----[(-)*118[-]]])*19][+-.-](+>+[--[(-)*119[-]]])*19][+-.-](+>-[++[(+)*119[+]]])*19])*20>[-][+-.-]>[-][+-.-]
15:02:52 <EgoBot> Score for ais523_decoytuner: 50.3
15:03:04 <ais523> slows it down too much, by the look of things
15:03:07 <ais523> !bfjoust decoytuner >+>+>->>>>(>[>-[++[+[----[(-)*118(.-)*16(>(-)*120(.-)*16)*18](+>--[++++[(+)*118[+]]])*19](+>++[----[(-)*118[-]]])*19](+>+[--[(-)*119[-]]])*19](+>-[++[(+)*119[+]]])*19])*20>[[-]][-]>[[-]][-]
15:03:24 <EgoBot> Score for ais523_decoytuner: 54.4
15:03:28 <ais523> it seems to be better off just losing to shudder and its friends
15:05:18 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
15:06:33 -!- Sgeo has quit (Ping timeout: 240 seconds).
15:15:44 -!- augur has quit (Ping timeout: 240 seconds).
15:28:31 -!- augur has joined.
15:31:14 -!- copumpkin has joined.
15:32:06 -!- pikhq has quit (Ping timeout: 240 seconds).
15:32:15 -!- pikhq has joined.
15:38:24 -!- Phantom_Hoover has joined.
15:39:08 <Gregor> !bfjoust dobleve_te_efe_barbeque ([)*100(]+)*100
15:39:58 <ais523> Gregor: that's basically a NOP
15:40:06 <EgoBot> Score for Gregor_dobleve_te_efe_barbeque: 9.1
15:41:58 <ais523> decoytuner loses to NOPs
15:42:39 <ais523> !bfjoust a_better_nop (+)*64
15:43:07 <EgoBot> Score for ais523_a_better_nop: 15.2
15:43:08 <Gregor> Except mine has a tight loop waiting for the flag to be zeroed first :P
15:44:16 <ais523> mine beats careless too :)
15:46:16 <ais523> !bfjoust no_longer_quite_a_nop (+)*64(.)*50000[>[...-]+]
15:46:55 <EgoBot> Score for ais523_no_longer_quite_a_nop: 21.1
15:47:25 <ais523> in fact, it isn't even last, but second-last
15:48:41 <ais523> !bfjoust decoyvibration >>>++<(-)*85<(+)*85<(-)*128(+-)*25000(+)*19[>[...-]+]
15:49:27 <EgoBot> Score for ais523_decoyvibration: 20.7
15:51:26 <ais523> woah, that did really well on raw results compared to what I expected
15:51:35 <ais523> it's around 50:50 against many enemies
15:52:10 <ais523> !bfjoust decoyvibration >>>++<(-)*85<(+)*85<(-)*128(+-)*100000
15:52:25 <ais523> let's try a version that doesn't give up and settles for draws instead
15:52:28 <ais523> also, why are you sobbing?
15:53:08 <EgoBot> Score for ais523_decoyvibration: 17.3
15:53:40 <ais523> and htf is that losing to defence programs, given that it never trips their tripwires?
15:54:15 <ais523> !bfjoust decoyvibration >>>++<(-)*85<(+)*85<(-)*128(+-)*1000000
15:55:09 <EgoBot> Score for ais523_decoyvibration: 17.3
15:57:56 <Gregor> !bfjoust snapping_turtle (>)*8-[[+>(+)*128..[+].>(-)*128..[-].-]+]
15:58:29 <EgoBot> Score for Gregor_snapping_turtle: 4.5
15:58:39 <Ilari> APNIC down 0.07. Now at ~4.52 (including ERX blocks).
15:58:48 <Gregor> Wow, srsly? Why is that so much worse than mind_bogglingly_slow_rush_with_benefits ...
15:58:58 <ais523> Gregor: there's a bug in egojoust
15:58:59 <Gregor> !bfjoust snapping_turtle (>)*8-[[+>(+)*128..>>(-)*128..-]+]
15:59:07 <ais523> !bfjoust decoyvibration >>>++<(-)*85<(+)*85<.(-)*128(+-)*1000000
15:59:10 <Gregor> ais523: That's nae good?
15:59:10 <EgoBot> Score for Gregor_snapping_turtle: 13.1
15:59:22 <Ilari> This graph covers 2 weeks, during this time APNIC is down by 0.26
15:59:25 <ais523> to be precise, if the run times out and one of the flags is at 0, the program in question loses even if the flag's been at 0 for only 1 cycle
16:00:08 <EgoBot> Score for ais523_decoyvibration: 14.3
16:00:43 <Gregor> !bfjoust snapping_turtle (>)*8-[[+>(+)*128..>(-)*128..-]+]
16:00:54 <EgoBot> Score for Gregor_snapping_turtle: 28.8
16:00:55 <Gregor> Errr, whoops, I just modified that into a clone of MBSRWB
16:01:40 <ais523> !bfjoust decoyvibration >>>++<(-)*85<(+)*85<(-)*128(+-)*49881---
16:02:40 <ais523> (that 49881 is carefully calculated merely for the purpose of dodging an egojoust bug)
16:02:44 <Gregor> !bfjoust snapping_turtle (>)*8+[[->(+)*128..>(-)*128..+]-]
16:02:45 <EgoBot> Score for ais523_decoyvibration: 18.3
16:03:08 <EgoBot> Score for Gregor_snapping_turtle: 27.6
16:03:31 <Gregor> !bfjoust snapping_turtle (>)*8-[[+>(+)*128..-]+]
16:03:33 <ais523> that one beats most defence programs, but loses to attack program
16:03:45 <EgoBot> Score for Gregor_snapping_turtle: 29.1
16:04:41 <Gregor> !bfjoust snapping_turtle (>)*9([(+)*128..>])*20
16:04:55 <ais523> haha, that won't work well
16:05:03 <ais523> I think you're missing a >
16:05:17 <EgoBot> Score for Gregor_snapping_turtle: 10.2
16:05:21 <Gregor> That should be "gumming_turtle"
16:05:23 <Gregor> !bfjoust snapping_turtle (>)*9([(+)*128..>]>)*20
16:05:37 <EgoBot> Score for Gregor_snapping_turtle: 43.2
16:05:57 <Gregor> This is why you change your flag value ;)
16:06:23 <ais523> yep, looks like that will have to get into some sort of arms war soon
16:06:40 <Gregor> !bfjoust snapping_turtle (>)*9([(+)*128..>>]>)*20
16:06:51 <EgoBot> Score for Gregor_snapping_turtle: 23.6
16:06:57 <Gregor> !bfjoust snapping_turtle (>)*9([(+)*128..>]>)*20
16:07:00 <Gregor> Wow, that was much worse :P
16:07:09 <Gregor> I thought I might skip some decoys, but instead I skipped the tape :P
16:07:11 <EgoBot> Score for Gregor_snapping_turtle: 43.2
16:07:30 <ais523> careless also relies on flags being 128; decoytuner, when it detects "large" decoys, also switches to that strategy but looks for values near 128 instead
16:08:43 <Gregor> !bfjoust scaredy_turtle (>)*9([(+)*128..[[-]<]]>)*100
16:09:03 <EgoBot> Score for Gregor_scaredy_turtle: 24.7
16:09:04 <Gregor> I don't know by what logic that's supposed to make sense :P
16:09:25 -!- augur_ has joined.
16:09:34 -!- augur has quit (Read error: Operation timed out).
16:10:25 <Gregor> !bfjoust careful_turtle (>)*9([(+)*112([+)*32(])*32..>]>)*100
16:10:39 <ais523> !bfjoust decoybooster2 (>)*7++<(-)*85(<(-)*85<(+)*85)*3(-)*43(>)*9([(+)*5[-.]]>)*21
16:10:45 <Gregor> Should've been 20 instead of 100 there ...
16:10:48 <ais523> also, there's a control code / Unicode in your program
16:10:51 <EgoBot> Score for Gregor_careful_turtle: 21.1
16:11:06 <EgoBot> Score for ais523_decoybooster2: 53.5
16:11:32 <ais523> wow did I not expect that to go straight to the top of the leaderboard
16:12:50 <Gregor> !bfjoust careful_turtle (>)*9([([+)*142(])*142>]>)*20
16:13:35 <EgoBot> Score for Gregor_careful_turtle: 14.6
16:13:47 <Gregor> !bfjoust snapping_turtle (>)*9([(+)*128..>]>)*21
16:14:00 <EgoBot> Score for Gregor_snapping_turtle: 39.4
16:14:09 <ais523> also, I don't get why decoybooster2 beats careless at all, that should be a hideous matchup for it
16:14:13 <Gregor> !bfjoust snapping_turtle (>)*9([(+)*128..>]>)*20
16:14:24 <EgoBot> Score for Gregor_snapping_turtle: 39.2
16:14:32 <Gregor> Oh, it wasn't worse >_>
16:14:34 <Gregor> !bfjoust snapping_turtle (>)*9([(+)*128..>]>)*21
16:14:47 <EgoBot> Score for Gregor_snapping_turtle: 39.4
16:14:53 <Gregor> !bfjoust snapping_turtle -(>)*9([(+)*128..>]>)*21
16:15:04 <EgoBot> Score for Gregor_snapping_turtle: 40.3
16:15:13 <Gregor> May as well not make the same mistake I'm exploiting X-P
16:15:47 -!- elliott has joined.
16:15:51 <Gregor> !bfjoust trapping_turtle -(>(+)*128>(-)*128)*4>([(+)*128..>]>)*21
16:16:05 <ais523> oh, ofc, because it changes its own flag value to stop that sort of shenanigans
16:16:26 <ais523> elliott: I just went straight to the top of the hill with the following relatively short program: (>)*7++<(-)*85(<(-)*85<(+)*85)*3(-)*43(>)*9([(+)*5[-.]]>)*21
16:16:46 <ais523> and it changes the flag value by 43, even though I could have just changed it by 1 or 2 to avoid the current flag=128 programs
16:17:34 <elliott> decoys would make a comeback
16:17:57 <EgoBot> Score for Gregor_trapping_turtle: 30.3
16:17:59 <ais523> it's arguably just a tweaked-constants version of decoybooster, /but/ I tweaked the constants in order to make them good generally (mathematically), rather than good against the current hill in particular
16:18:26 <ais523> elliott: I didn't say that decoys were useless nowadays (they are useful in most types of programs), but trails, which decoybooster doesn't leave as there'd be no point at all
16:18:29 <Gregor> Before I was somewhat distressed by the fact that there really is no "canonical" good BFJoust program. Now I've realized that that's part of the joy of it: We're not trying to find the perfect program, we're in a battle against /each other/.
16:18:46 <elliott> ais523: I wasn't saying you'd contradicted it
16:19:08 <Gregor> !bfjoust trapping_turtle -(>(+)*128>>(-)*128>)*2>([(+)*128..>]>)*21
16:19:11 <ais523> decoybooster(|2) uses decoys in order to buy time to set up better decoys, thus the name
16:19:27 <elliott> I think it's obvious that no program can do everything, because some strategies rely on doing something as soon as you start, and some rely on waiting ages
16:19:40 <EgoBot> Score for Gregor_trapping_turtle: 30.6
16:19:42 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
16:19:51 <ais523> Gregor: it's also notable that the score of the winning program has gone down significantly
16:20:05 <ais523> I think there was one above 60 a while back, now the best program's below 55
16:20:07 <elliott> should we award programs for shortness in points?
16:20:10 <ais523> so obviously there's more diversity
16:20:41 <Gregor> Has somebody started writing A Brief History of BF Joust yet? :P
16:20:57 <ais523> !bfjoust decoybooster2 (>)*7++<(-)*85(<(-)*85<(+)*85)*3(-)*43(>)*8(>[(+)*5[-.]])*21(+(.)*5)*10000
16:21:09 <elliott> BF Joust hasn't really had _that_ interesting a history
16:21:16 <EgoBot> Score for ais523_decoybooster2: 53.4
16:21:18 <ais523> trivial fix, to not fall for vibration-style tricks if the tape happens to be exactly 30 squares long
16:21:35 <elliott> ais523: it's decoybooster3!
16:21:43 <elliott> hmm, that finished really fast
16:21:46 <elliott> has the program been optimised
16:22:01 <Gregor> !bfjoust trapping_turtle -(>++>>-->)*2>([(+)*128..>]>)*21
16:22:03 <ais523> I'm not going to rename a program when I make a change that only comes up against one particular style of program with only two representatives on the current hill, and only for one tape length
16:22:12 <EgoBot> Score for Gregor_trapping_turtle: 38.9
16:22:38 <Gregor> !bfjoust trapping_turtle -(>++>--)*4>([(+)*128..>]>)*21
16:22:49 <EgoBot> Score for Gregor_trapping_turtle: 40.6
16:23:04 <Gregor> OK, it's beat snapping :P
16:23:05 <ais523> elliott: not for emulation speed; but it's good vs. defense, which means that it doesn't get caught up in ten-thousand-cycle battles, and it's easy to parse
16:23:58 <elliott> !bfjoust centos_vs_city_of_turtle >>>>>>>>>>>>((-)*85>)*17
16:24:12 <EgoBot> Score for elliott_centos_vs_city_of_turtle: 1.5
16:24:54 <ais523> that doesn't even actually beat the program it's meant to beat
16:25:01 <elliott> ais523: does decoybooster2 decrease by 43 or increase? :D
16:25:09 <elliott> i was trying to beat it, in case that's not obvious
16:25:20 <ais523> depends on polarity, obviously
16:25:33 <ais523> but it topples your flag before you topple its, on every tape length
16:25:44 <ais523> try adding a . between (-)*85 and >
16:25:49 <ais523> then you might actually have a chance ;)
16:26:11 -!- hagb4rd has joined.
16:26:12 <elliott> anyway, Shiro! I fixed my stupid bug, and now I just have a different stupid b ug instead
16:26:24 -!- augur_ has quit (Ping timeout: 240 seconds).
16:26:53 <elliott> !bfjoust I_WILL_SUE_YOU_IN_A_COURT_OF_LAW_IN_TRENTON_NEW_JERSEY >>>>>>>>>>>>((-)*85>)*17
16:26:53 <ais523> I think that for /any/ BF Joust program, there's some program that beats it on every tape length at every polarity
16:27:05 <EgoBot> Score for elliott_I_WILL_SUE_YOU_IN_A_COURT_OF_LAW_IN_TRENTON_NEW_JERSEY: 1.5
16:27:06 <ais523> elliott: err, you didn't change it at all
16:27:12 <elliott> !bfjoust I_WILL_SUE_YOU_IN_A_COURT_OF_LAW_IN_TRENTON_NEW_JERSEY >>>>>>>>>>>>((-)*85.>)*17
16:27:16 <elliott> ais523: you proved that a program always draws with itself, right?
16:27:19 <elliott> peeps in here were wondering
16:27:23 <ais523> yep, obvious due to symmetry
16:27:24 <EgoBot> Score for elliott_I_WILL_SUE_YOU_IN_A_COURT_OF_LAW_IN_TRENTON_NEW_JERSEY: 1.5
16:27:46 <elliott> ais523: obvious, but proven?
16:27:53 <ais523> ais523_decoybooster2.bfjoust vs elliott_I_WILL_SUE_YOU_IN_A_COURT_OF_LAW_IN_TRENTON_NEW_JERSEY.bfjoust: <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< ais523_decoybooster2.bfjoust wins
16:27:54 <elliott> it seems something obvously true but not obviously trivial to prove
16:28:02 <ais523> elliott: you can prove it in one line, "symmetry"
16:28:09 <ais523> that'd be accepted by any paper or journal
16:28:15 <ais523> if you really care, you can point out what the symmetry is
16:28:32 <Gregor> !bfjoust trapping_turtle -(>++>--)*2(>)*5([(+)*128..>]>)*21
16:28:43 <EgoBot> Score for Gregor_trapping_turtle: 37.3
16:28:47 <ais523> elliott: I'm going to run that locally, to see why you still aren't beating decoybooster2
16:28:55 <Gregor> !bfjoust trapping_turtle -(>++>--)*4>([(+)*128..>]>)*21
16:29:08 <EgoBot> Score for Gregor_trapping_turtle: 40.6
16:29:10 <elliott> ais523: an interesting project would be to create a program that takes a program and tries to print out a counter-program
16:29:16 <elliott> I think this would actually be feasible for the most-part
16:29:20 -!- augur has joined.
16:29:21 <Gregor> !bfjoust trapping_turtle -(>+>-)*4>([(+)*128..>]>)*21
16:29:41 <EgoBot> Score for Gregor_trapping_turtle: 41.0
16:30:07 <ais523> elliott: you got the flag value wrong, I actually set the flag to (+/-) 86
16:30:22 <Gregor> !bfjoust bisexual_trapping_turtle -(>+>-)*4>([(+)*128..>]>[(-)*128..>]>)*10
16:30:23 <ais523> and ofc on half the polarities, you change it the wrong way anyway
16:30:38 <Gregor> In retrospect, that might make no difference at all :P
16:30:43 <EgoBot> Score for Gregor_bisexual_trapping_turtle: 39.0
16:30:48 <ais523> getting up into the 40s is impressive, anyway
16:30:50 <Gregor> !bfjoust bisexual_trapping_turtle <
16:30:58 <elliott> ais523: but you said 4something yourself
16:31:03 <EgoBot> Score for Gregor_bisexual_trapping_turtle: 0.0
16:31:23 <elliott> Gregor: What happened to furry_furry_bondage_girls, did you not come up with a warrior worthy of the name?
16:31:34 <Gregor> elliott: Not really :P
16:31:39 <elliott> !bfjoust I_WILL_SUE_YOU_IN_A_COURT_OF_LAW_IN_TRENTON_NEW_JERSEY >>>>>>>>>>>>((-)*86.>)*17
16:31:50 <EgoBot> Score for elliott_I_WILL_SUE_YOU_IN_A_COURT_OF_LAW_IN_TRENTON_NEW_JERSEY: 1.6
16:32:11 <ais523> ais523_decoybooster2.bfjoust vs elliott_I_WILL_SUE_YOU_IN_A_COURT_OF_LAW_IN_TRENTON_NEW_JERSEY.bfjoust: <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<>>>>>>>>>>< <<<<<<<<<<>>>>>>>>>>< <<<<<<<<<<<<<<<<<<<<< ais523_decoybooster2.bfjoust wins
16:32:21 <ais523> you win on just under half the tape lengths for half the polarities
16:32:31 <ais523> and that's with specifically targeting my program
16:33:30 <ais523> on short tapes, you fall off the end before my program has had time to change its flag to 86
16:33:38 <ais523> because it sets up decoys first
16:34:02 <elliott> I fall off the end of really short tapes on purpose
16:34:37 <nddrylliog> I'm just wondering what someone would think of you if he were to drop by at this precise moment of the conversation with no prior knowledge of esoteric programming languages.
16:34:41 <Gregor> !bfjoust furry_furry_bondage_girls -(>)*9(([>)*2 ([-]>)*20 ([-]])*2)*20
16:35:14 <EgoBot> Score for Gregor_furry_furry_bondage_girls: 11.7
16:36:18 -!- augur has quit (Ping timeout: 260 seconds).
16:36:21 <ais523> elliott: that's a bad move generally, IMO; the time saved from getting their faster is normally not worth anything, and the time saved from dodging decoys is less helps on no more tape lengths than you sacrifice
16:36:36 <Gregor> 5 38.40 -0.62 Gregor_snapping_turtle.bfjoust // heyo, I'm the highest-scoring program with negative points :P
16:37:21 <ais523> wow, tripstridewire has almost fallen off
16:37:27 <ais523> that should have happened ages ago :P
16:37:56 -!- augur has joined.
16:38:55 <Gregor> !bfjoust return_of_nescience_creep >+>->+>->+>->+(>-++-(.)*132[+]++>-++-(.)*132[-]--)*15 HAY GUYS I TOTES DIDNT WRITE THIS I JUST WANNA SEE IT ON THE HILL
16:39:11 <EgoBot> Score for Gregor_return_of_nescience_creep: 18.1
16:39:23 <Gregor> That was the winner of the very first egojoust hill :P
16:39:26 -!- augur has quit (Read error: Connection reset by peer).
16:39:54 -!- augur has joined.
16:40:09 <ais523> looks like it predates the existence of offset clear
16:40:13 -!- augur has quit (Read error: Connection reset by peer).
16:40:18 <Gregor> Wow, jix_wiggle3 has been near the top for SO LONG
16:40:21 <ais523> also, is that before or after you fixed the hill being upside-down?
16:40:37 -!- augur has joined.
16:40:57 <ais523> defend7 has started dropping because people know how to take advantage of defence nowadays
16:41:28 <ais523> it's actually pretty interesting that we have the three different main strategies (slow attack, defense, fast attack) in the top three programs
16:41:49 <elliott> "ahumanright.org plans to buy satellite and provide free Internet access for entire world"
16:41:49 <ais523> which is a nice sign of hill diversity
16:41:58 <elliott> I doubt that will happen...
16:42:24 <Gregor> elliott: Naturally, there is nothing more to it than having a satellite.
16:42:41 <elliott> I don't expect it to be accurate.
16:43:29 <elliott> http://www.ahumanright.org/ ;; this is a bit flashy for an organisation that plans to actually do something.
16:43:38 <elliott> Also the javascript effects are annoying; colour me sceptical (but I do support the idea)
16:43:43 <Gregor> More like "a bit retarded"
16:44:18 <Gregor> elliott: That web site's "design"
16:44:33 <elliott> 10 hours/week at the AHR offices
16:44:33 <elliott> Website & Graphics Designer
16:44:35 <elliott> ...PHP, HTML, AJAX, Wordpress, and sexy layouts
16:44:39 <elliott> Represent us in your country]]
16:44:43 <elliott> You don't need PHP, HTML, AJAX, Wordpress and sexy layouts to provide Internet access.
16:45:14 -!- jix has quit (Quit: leaving).
16:46:38 <elliott> I wonder if DEEWIANT is awake
16:47:16 <elliott> 01:57:24 <elliott> Deewiant: Self-log-read-ask: Vorpal: When FILE functions reflect, do they push the file handle back again, or keep it popped?
16:47:23 <Deewiant> Keep it popped like fizzie said
16:47:45 <Deewiant> 2011-02-10 09:13:33 ( fizzie) elliott: I think I've mostly been assuming that when they reflect, all the arguments have disappeared from the stack; but since they "keep" the handle on stack "normally" I guess that's arguable.
16:47:49 <Deewiant> 2011-02-10 09:14:17 ( fizzie) It does make it marginally easier to close the handle after a failing operation if it does stay there.
16:47:55 <Deewiant> While you were gone, but still.
16:48:06 <elliott> Deewiant: That's amusingly annoying in that if you plan to use a file past errors you have to duplicate and pop it when the operation works.
16:48:17 <Deewiant> And re. static area: I'd still like to remove it but unfortunately it's needed to be competitive with cfunge on certain classes of programs
16:48:43 <ais523> Deewiant: are you busy trying to get CCBI faster than cfunge?
16:48:56 <elliott> CCBI2 is something like 10x faster than cfunge on Fungicide, or was it 100x?
16:49:14 <elliott> Deewiant says that fungot is faster on CCBI now at least, not sure what metric he means
16:49:14 <fungot> elliott: welcome to the internet for help never have any interesting technical fnord?, &c.? string-foldcase or string-case-fold? ;p it might make a nice title for something.
16:49:25 <Deewiant> Don't consider fork.b98 and it's probably not more than 10xish
16:49:30 <elliott> Mycology runs in <0.1s, though, pretty sure it's just about instant
16:49:52 <Deewiant> My fungot comments were mostly based on running ^ul
16:49:52 <fungot> Deewiant: heh, i didn't know that was a big disappointment. i'll have to ascend it again if you can
16:49:54 <elliott> Deewiant: Admittedly Fungicide is more like an "edge-case benchmark" than a benchmark benchmark :P
16:50:11 <Deewiant> It's synthetic and tests mostly boundaries, yes
16:50:44 <fungot> Available: agora alice c64 ct darwin discworld europarl ff7 fisher ic irc* jargon lovecraft nethack pa speeches ss wp youtube
16:51:02 <elliott> Deewiant: You still use a hash-table for the main fungespace right?
16:51:20 <Deewiant> No, the fungespace is almost always stored in the bounding boxes
16:51:34 <Deewiant> I think it falls back to a hash table when there are more than 128 of them or something
16:51:37 <elliott> Deewiant: Which are indexed by a hash table?
16:51:53 <elliott> I mean outside of the static area.
16:51:55 <Deewiant> (This is where the bucket PR-CIF k-d tree would come in
16:52:09 <elliott> Deewiant: I was about to suggest indexing a hash table as "hashtable[foo/16][foo%16]" for some 16.
16:52:12 <elliott> i.e. hash table of static arrays
16:52:18 <Deewiant> The static area is a statically allocated array
16:52:27 <Deewiant> Most of the rest of funge-space is typically dynamically allocated arrays
16:52:48 <Deewiant> In pathological cases that show up only in fungicide, there's a hash table in addition to these.
16:53:13 <elliott> Deewiant: Would the bucket PR-CIF k-d tree let you eliminate the static array? :-P
16:53:39 <Deewiant> The speed of the static array is due to the fact that a[y*CONSTANT + x] is faster than a[y*variable + x], basically
16:53:58 <Deewiant> And likewise tests like x >= 0 && x < CONSTANT instead of x >= variable && x < variable
16:54:26 <Deewiant> This is why I feel so annoyed by its existence :-P
16:54:34 <elliott> Deewiant: Is it so significantly faster that cfunge wins based on it?
16:54:44 <Deewiant> And CCBI wins again when it's added
16:55:06 <Deewiant> CCBI's is smaller though, so at least that's something.
16:55:13 <elliott> Deewiant: Are we talking 0.001s vs. 0.002s?
16:55:32 <Deewiant> elliott: On fungot's ^ul interpreter, we're talking 10s vs 15s or something
16:55:33 <fungot> Deewiant: or /dev/ blum, which probably is index.html, unless people really write ' hello o) instead, ( read)
16:55:48 <elliott> Deewiant: You could make it less of a hack by relocating the static array when the IP moves out of it.
16:55:57 <elliott> Deewiant: i.e. make the static array be a "scratch space" for fungespace.
16:56:13 <Deewiant> elliott: Then it loses part of its usefulness because its position is no longer constant
16:56:18 <Deewiant> So you again slow down bounds checking
16:56:35 <ais523> what about a JIT interpreter?
16:56:42 <ais523> as in, you aren't JITting the funge itself
16:56:53 <ais523> but rather rewriting constants in your own program in order to adapt to the changes in fungespace
16:56:53 <elliott> It beats everyone by a large margin but doesn't pass Mycology yet AFAIK
16:57:09 <Deewiant> It uses a hash table, CCBI should beat it in some cases at least
16:57:40 <Deewiant> elliott: If any decent programming languages supported self-modifying code I probably would
16:57:41 -!- augur has quit (Ping timeout: 240 seconds).
16:58:08 <Deewiant> It annoys me that you get to do it pretty much only at the asm level :-P
16:58:09 -!- jix has joined.
16:58:50 <elliott> (I would say CCBIx64 to fit with your dobela interp but "x64" is abominable)
16:59:20 <Deewiant> elliott: But, part of it is also the fact that you can compile [y*constant + x] to [y << 6 + x] or whatever
16:59:40 <elliott> Deewiant: Optimise for powers of two or whatever :P
16:59:45 <Deewiant> Would really need that JIT there
16:59:48 <elliott> Also, people who care about 8.3 are weird.
16:59:52 <Deewiant> And this is the point where this becomes a pain
17:00:11 <Deewiant> I don't "care" about 8.3 as such but I prefer it
17:00:13 <elliott> Deewiant: Have you considered doing something slightly similar to jitfunge:
17:00:28 <elliott> Deewiant: Compile certain rays to threaded code i.e. lists of function/goto pointers
17:00:41 <elliott> Deewiant: If they're walked along more than once or twice, say
17:00:49 <elliott> Then tight code that doesn't get changed can go super-fast
17:00:54 <elliott> and you don't even have to worry about moving the IP until the end
17:01:00 <Deewiant> "Compile x to code" = reimplement jitfunge
17:01:06 <elliott> Deewiant: Didn't say compile
17:01:16 <Deewiant> elliott: You did say compile :-P
17:01:20 <elliott> You _already have_ a goto-pointer to each instruction
17:01:24 <elliott> So just make a list of them
17:01:45 <elliott> You ideally want the blocks of code they point to to end with a jump to the next one but you could do it in an outer loop if that would be more convenient
17:03:23 -!- cal153 has quit (Ping timeout: 240 seconds).
17:04:02 -!- poiuy_qwert has joined.
17:04:38 <elliott> Deewiant: So anyway, my bug with FILE was that any IO error was undoing EVERY change that instruction made
17:04:41 <elliott> Thus not popping the stack
17:04:49 <elliott> I've fixed that and now I have another inexplicable bug -- but hey, at least files actually get closed.
17:05:19 <Deewiant> I think I just scrolled to where you pinged me and saw it near there
17:05:40 <elliott> Deewiant: My new problem is what you might call "slightly bizarre": question, does the FILE test use the o instruction?
17:06:02 <elliott> GOOD: reopened file in truncate+read mode
17:06:02 <elliott> Sought to beginning of file with 20S107-S.
17:06:03 <elliott> BAD: G pushed wrong line length
17:06:03 <elliott> BAD: G didn't read 'bar\n'
17:06:07 <elliott> My testing tells me that it reads:
17:06:24 <elliott> mycotemp.tmp looks like this:
17:06:36 <elliott> Basically a bunch of befunge code squashed into thinness.
17:06:44 <elliott> I don't know whether my reading or writing is broken.
17:06:56 <Deewiant> Run ccbi -t and take a look at the file between instructions :-P
17:07:33 <elliott> Deewiant: ccbi -t on Mycology is an incredibly tedious experience.
17:07:40 <elliott> And I have no idea how to set a sane breakpoint.
17:07:45 -!- poiuy_qwert has quit (Client Quit).
17:08:10 <Deewiant> Just grep for '"FILE"' in mycology.b98 and set it where that starts
17:09:14 <elliott> Deewiant: And step through print loops?
17:09:31 <Deewiant> elliott: Break on the fingerprint instructions, G and W etc?
17:12:05 <elliott> Deewiant: Your TOYS tests sure call W a lot.
17:12:29 <Deewiant> That's why you run to the FILE place first.
17:13:01 <Deewiant> No, it was comma-separated: -f-all,+FILE
17:13:53 <fizzie> -ffast-FILE -foptimize-up-the-wazoo
17:14:36 <elliott> Deewiant: How much do I have to pay you to uneqpber zlpbybtl'f bhgchg naq fvqr-rssrpgf va gur arkg ppov naq oent nobhg lbhe HYGVZNGR CRESBEZNAPR gb ibecny?
17:15:14 <fizzie> You should put in a -ffast-FILE that uses some crafty logic to turn FILE R/W loops into zero-copy splice(2) calls on Linux (when you don't inspect the Funge-space data except by the corresponding R).
17:15:37 <elliott> "Crafty logic" a.k.a. magic
17:16:01 <fizzie> Nah, it can be some sort of a conservative imperfect heuristic.
17:16:42 <Deewiant> elliott: Not very much, I can always do a following release that undoes the changes
17:16:59 <elliott> Deewiant: I will pay you in gratitude.
17:17:21 <Deewiant> Unfortunately that won't suffice
17:19:26 <Deewiant> To make it worth my time and the stupidity of it all... 100 €
17:20:52 <elliott> Your loss. In performance.
17:21:01 <Deewiant> Mycology isn't a good benchmark anyway
17:21:16 <Deewiant> Even the current cfunge/ccbi do it in less than 0.01 seconds
17:21:18 <elliott> Deewiant: Seriously, that threaded code thing would work :-P
17:21:40 <Deewiant> I'm not convinced of how much it'd win compared to how much it slows everything down
17:22:35 <elliott> Deewiant: It wouldn't slow things down, you'd only trigger it if you repeatedly go over the same ray; for going over a ray normally, it'd literally be shoving the ray into a data structure as quickly as possible.
17:22:42 <elliott> You could even "heuristicise" whether to even bother doing that.
17:23:21 <elliott> Obviously the time it finally decides to thread it would take about, say, half the time it takes to actually execute, before actually executing it, but after that you'd be able to avoid tons of paperwork when going over it.
17:23:23 <Deewiant> You're checking stuff what, every time an IP moves?
17:23:34 <elliott> Just every time it changes delta.
17:23:54 <elliott> And _any_ kind of advanced optimisation is going to involve a branch _somewhere_.
17:24:19 <Deewiant> Of course, I'm just not convinced that the branch in this case isn't enough of a pessimization
17:24:28 <Deewiant> Since you don't then JIT-optimize the ray in any way
17:24:44 <elliott> Deewiant: Threading every ray would be slow since most rays aren't repeatedly executed I would guess
17:25:34 <fizzie> Most of fungot is repeatedly executed, as long as you keep it running and use all the features.
17:25:34 <fungot> fizzie: give it to them
17:25:37 <Deewiant> I always figured I'd add this kind of stuff and funge-space GC and whatnot into other threads but I haven't really bothered doing any more advanced stuff
17:25:48 <fizzie> fungot: Yes I will GIVE IT TO THEM.
17:25:48 <fungot> fizzie: haskell distinguish them by their order, 1 being first, 2 second and so on
17:26:05 <ais523> fungot: surely 0 should be first, 1 second, etc?
17:26:05 <fungot> ais523: i can't be bothered sorting it out
17:26:33 <ais523> that made surprising sense in-context
17:26:38 <ais523> and where did you learn Agoran pronouns?
17:26:46 <fizzie> From the channel, I guess.
17:27:01 <fungot> Selected style: agora (a large selection of Agora rules, both current and historical)
17:27:09 <fungot> elliott: days after a payment order identical to another entity.
17:27:16 <elliott> fizzie: Are you sure it wouldn't prefer "it"?
17:27:56 <fizzie> Isn't 'e' just Spivak, anyway? It's in the gender-neutral pronoun table, that's another place where I might have caught it from.
17:28:07 <fizzie> It might prefer it, it's true.
17:28:38 <fizzie> s/table/table of Wikipedia/
17:29:48 -!- poiuy_qwert has joined.
17:30:03 -!- impomatic has joined.
17:30:41 <elliott> Deewiant: How do you do that -f-all,+FILE thing?
17:30:45 <elliott> "-t -f-all,+FILE" doesn't work.
17:30:52 <elliott> "r" just makes it run until the end.
17:31:43 <Deewiant> That's what it's supposed to do
17:31:50 <Deewiant> -f-all,+FILE disables all fingerprints and then enables FILE
17:32:08 <Deewiant> So you should be able to break on W and be guaranteed that it's FILE'S W, for example
17:39:16 -!- nddrylliog has quit (Ping timeout: 240 seconds).
17:43:52 -!- poiuy_qwert has quit (Read error: Connection reset by peer).
17:44:21 -!- poiuy_qwert has joined.
17:47:15 -!- cal153 has joined.
17:54:41 <Gregor> !bfjoust the_most_obvious_strategy (>)*8(>[-]..)*21
17:55:26 <Gregor> ais523: Because I forgot that ] would take a cycle anwyay.
17:55:27 <ais523> or, indeed, just using the ] as your 2-cycle buffer
17:55:48 <ais523> well, if you're going for "most obvious" rather than "simplest", you can leave in the .
17:57:58 <ais523> Gregor: it seems to beat all or at least most of impomatic's defense programs, anyway...
17:58:25 <EgoBot> Score for Gregor_the_most_obvious_strategy: 11.4
17:58:30 <Deewiant> !bfjoust simplest_most_obvious_strategy (>)*8(>[-])*21
17:58:58 <EgoBot> Score for Deewiant_simplest_most_obvious_strategy: 13.8
18:00:32 <Gregor> !bfjoust furry_furry_bondage_girls -(>+>-)*2(>)*5([(+)*112[+]>)*21
18:00:39 <Gregor> Whoops, that's all wrong.
18:01:04 <Deewiant> simplest ties against Nyarlathotep and beats keke2, I think those were the only differences
18:01:10 <EgoBot> Score for Gregor_furry_furry_bondage_girls: 6.9
18:01:15 <Gregor> !bfjoust furry_furry_bondage_girls -(>+>-)*2(>)*5([(+)*112[+]>]>)*21
18:01:38 <EgoBot> Score for Gregor_furry_furry_bondage_girls: 17.1
18:01:47 <Gregor> !bfjoust furry_furry_bondage_girls -(>+>-)*2(>)*5([(+)*112[+]..>]>)*21
18:02:07 <EgoBot> Score for Gregor_furry_furry_bondage_girls: 15.8
18:02:17 <Gregor> Poor Furry Furry Bondage Girls.
18:02:23 <Gregor> No stupid strategy to their name :P
18:03:09 <Gregor> !bfjoust trapping_turtle -(>+>-)*4>([(+)*128.>]>)*21
18:03:14 <ais523> strangely, I was wondering about (+)*112[+]-style strategies this morning
18:03:20 <ais523> but concluded that they wouldn't work too well
18:03:26 <EgoBot> Score for Gregor_trapping_turtle: 40.3
18:03:45 <Gregor> ais523: They do poorly against enemies that set up uninteresting decoys :P
18:04:19 <ais523> yep, I'm beginning to think that a boring trail of 1s is an advantage for any fast-rush program
18:04:40 <Gregor> !bfjoust crapping_turtle -(>+>-)*4>([(+)*128.>]+>[(+)*128.>]->)*11
18:04:59 <EgoBot> Score for Gregor_crapping_turtle: 41.4
18:05:15 <ais523> trails sort-of died out with the introduction of offset clear, but the notion of "disregard 0" that normally guards the offset clears lets them punish large offsets
18:05:32 <ais523> heh, the only change there is an alternating trail, I take it?
18:06:18 <Deewiant> !bfjoust monorail (>+>-)*4(>[(-)*9[+]])*21
18:06:33 <ais523> wow, is that all monorail is?
18:06:51 <ais523> simple decoy, offset clear, defense detector?
18:06:52 <Deewiant> It used to be (>+>-)*4>++>([(-)*9[+]]>)*20
18:06:54 <EgoBot> Score for Deewiant_monorail: 36.1
18:07:12 <Deewiant> And is a bit better now that it doesn't suicide on 10-cell tapes
18:07:31 <Deewiant> !bfjoust (>+>-)*4>(>[(-)*4[+.]])*21
18:07:32 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
18:07:32 <ais523> you've pushed careless below all three of my top 3 programs, now
18:07:36 <Deewiant> !bfjoust steamroller (>+>-)*4>(>[(-)*4[+.]])*21
18:08:01 <EgoBot> Score for Deewiant_steamroller: 39.3
18:08:03 <ais523> steamroller's "slow offset clear" beats defenders which are trying to punish c/2 offset clears
18:08:15 <Deewiant> Wait, hang on, I'm still moving too much
18:08:27 <Deewiant> !bfjoust steamroller (>+>-)*4(>[(-)*4[+.]])*21
18:08:51 <EgoBot> Score for Deewiant_steamroller: 44.4
18:09:00 <Deewiant> Wow, that helped more than expected
18:09:01 <Gregor> !bfjoust crapping_turtle -(>+>-)*4>([(+)*128.>](+)*11>[(+)*128.>](-)*11>)*11
18:09:15 <EgoBot> Score for Gregor_crapping_turtle: 38.6
18:09:25 <Gregor> Yeah, thought that wouldn't help :P
18:09:36 <Gregor> !bfjoust crapping_turtle -(>+>-)*4>([(+)*128.>]+>[(+)*128.>]->)*11
18:09:43 <ais523> Deewiant: the difference made by winning on even one more tapelength against the majority of programs is significant on the current hill, the leaderboard's really close
18:09:46 <EgoBot> Score for Gregor_crapping_turtle: 40.6
18:10:05 <ais523> also, a bizarre side effect of this is that it's pushing defend14 back up the leaderboard
18:10:15 <ais523> presumably because it detects slow offset clears on one polarity
18:10:23 <ais523> it detects far too many other things, too...
18:10:39 <Deewiant> !bfjoust monorail (>+>-)*4(>[(-)*4[+]])*21
18:10:54 <ais523> heh, tweaking constants?
18:11:03 <EgoBot> Score for Deewiant_monorail: 31.4
18:11:12 <Deewiant> Evidently 4 works better for steamroller :-P
18:11:18 <Deewiant> !bfjoust monorail (>+>-)*4(>[(-)*13[+]])*21
18:11:26 <Deewiant> Just wondering if 9 is still approximately the best
18:11:33 <ais523> I think 19 is the next-highest decoy on the current hill
18:11:41 <EgoBot> Score for Deewiant_monorail: 32.4
18:11:47 <Deewiant> !bfjoust monorail (>+>-)*4(>[(-)*20[+]])*21
18:11:51 <ais523> ooh, I have to go home
18:12:16 <EgoBot> Score for Deewiant_monorail: 31.6
18:12:24 <Deewiant> !bfjoust monorail (>+>-)*4(>[(-)*9[+]])*21
18:12:55 <EgoBot> Score for Deewiant_monorail: 37.4
18:13:23 -!- ais523 has quit (Remote host closed the connection).
18:15:16 -!- atrapado has quit (Quit: Abandonando).
18:15:45 <Gregor> !bfjoust crapping_turtle -(>+>-)*4>([(+)*128.+>]+>[(+)*128.->]->)*11
18:16:02 <EgoBot> Score for Gregor_crapping_turtle: 42.0
18:16:23 <Gregor> Of course, all my turtle techniques depend entirely on NOT CHANGING YOUR FLAG X-P
18:16:24 <Deewiant> !bfjoust sloth >(+)*12<((++-)*1024-(--+)*1024)*100(>-)*8(>[+[-]])*21
18:16:44 <Gregor> You could easily drop it to zero just by updating all the top programs to start with a + :P
18:17:11 <EgoBot> Score for Deewiant_sloth: 25.5
18:18:11 <Deewiant> !bfjoust sloth >(+)*12<(+--++-)*65536(>-)*8(>[+[-]])*21
18:19:07 <EgoBot> Score for Deewiant_sloth: 7.7
18:19:27 <Deewiant> !bfjoust sloth >(+)*12<(+--++-)*16384(>-)*8(>[+[-]])*21
18:20:11 <elliott> what are offset claers anyway?
18:20:16 <EgoBot> Score for Deewiant_sloth: 10.5
18:20:21 <Gregor> elliott: (-)*something[+]
18:20:28 <Gregor> elliott: Just avoids a full wrap-'round
18:20:28 <Deewiant> !bfjoust sloth >(+)*12<(+--++-)*8192(>-)*8(>[+[-]])*21
18:21:15 <EgoBot> Score for Deewiant_sloth: 11.2
18:21:33 <Deewiant> !bfjoust sloth >(+)*12<(++----+)*8192(>-)*8(>[+[-]])*21
18:22:22 <EgoBot> Score for Deewiant_sloth: 23.8
18:22:41 <Deewiant> !bfjoust sloth >(+)*12<(++----+)*8192(>)*8(>[+[-]])*21
18:23:13 <oerjan> <fizzie> Isn't 'e' just Spivak, anyway? [...] <-- yes agora pronouns are spivak or a slight variation thereof (i vaguely recall something about ey vs. e)
18:23:32 <EgoBot> Score for Deewiant_sloth: 23.8
18:23:46 <Gregor> !bfjoust flapping_turtle (-)*127(>)*9([(+)*128.+>]+>[(+)*128.->]->)*11
18:24:02 <EgoBot> Score for Gregor_flapping_turtle: 35.8
18:24:14 <Deewiant> !bfjoust sloth >(+)*12<(++----+)*8192(>)*8(>[+[-.]])*21
18:25:01 <EgoBot> Score for Deewiant_sloth: 33.8
18:25:37 <Deewiant> !bfjoust sloth >(+)*12<(++----+)*8192(>)*8(>[(+)*4[-.]])*21
18:26:16 <EgoBot> Score for Deewiant_sloth: 34.5
18:26:44 <Deewiant> !bfjoust sloth >(+)*12<(++----+)*8192(>)*8(>[(+)*9[-.]])*21
18:27:30 <EgoBot> Score for Deewiant_sloth: 34.5
18:27:47 <Ilari> The amount of address space APNIC would get from ERX blocks seems to be about 26 647 552 (1.59 blocks).
18:27:48 <Deewiant> !bfjoust sloth >(+)*12<(++----+)*8192(>)*8(>[(+)*4[-.]])*21
18:28:33 <EgoBot> Score for Deewiant_sloth: 34.5
18:29:07 <elliott> !bfjoust poop_machine (>+)*9([-]>(+)*10)*5([-]>(+)*50)*5([-]>(+)*128)*5
18:29:37 <EgoBot> Score for elliott_poop_machine: 4.4
18:30:01 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
18:30:18 -!- asiekierka has quit (Read error: Operation timed out).
18:30:25 <elliott> Deewiant: No; I think your FILE test might be using o.
18:30:42 -!- augur has joined.
18:30:53 <Deewiant> elliott: You realize that's easy to verify either with ccbi -t or putting something like 'error "WTF"' in your o
18:31:09 <elliott> Deewiant: I don't *really* think that.
18:31:20 <elliott> I just am utterly ununderstanding of why this would happen.
18:34:19 -!- copumpkin has changed nick to auger.
18:35:17 <Deewiant> elliott: Mayhap your W does something completely incorrect
18:35:40 <elliott> ioReflect . B.hPut handle $
18:35:40 <elliott> rectangleToByteString fs buffer (buffer + (bytes,0))
18:35:48 <elliott> rectangleToByteString works fine.
18:35:53 <elliott> (since Mycology's o tests it).
18:35:55 <elliott> That is of course binary mode.
18:36:00 <elliott> So the spaces at the end of the buffer gets printed out.
18:36:07 <elliott> Also it might add an additional \n.
18:36:29 <elliott> rectangleToByteString :: FungeSpace -> Vector -> Vector -> ByteString
18:36:29 <elliott> rectangleToByteString fs (ox,oy) (sx,sy) = fst $ B.unfoldrN (fromIntegral ((sx*sy)+sy)) byte (0,0)
18:36:29 <elliott> | x >= sx = Just (lf, (0,y+1))
18:36:30 <elliott> | otherwise = Just (fromIntegral (fs !@ pos), (x+1,y))
18:36:43 <elliott> Deewiant: Unless I'm really misunderstanding this whole buffer thing.
18:36:56 <Deewiant> Methinks you want to use (ox,oy)
18:37:08 <Deewiant> And compile with -Wall more often
18:37:09 <elliott> Deewiant: You, uh, really need to test that in your o tests.
18:37:19 <elliott> Yes, I've been meaning to turn on the -Walls. :p
18:38:02 <Deewiant> elliott: The text-mode thing uses something other than (0,0)
18:38:28 <elliott> Warning: orphan instance: instance (Num a, Num b) => Num (a, b)
18:39:28 <elliott> I'd prefer something that stops it warning on "import Data.Map (Map); import qualified Data.Map as Map" :-P But without ignoring all redundant imports.
18:40:02 <elliott> Shiro/Fingerprints/ROMA.hs:22:2:
18:40:02 <elliott> Warning: Pattern match(es) are non-exhaustive
18:40:02 <elliott> In the definition of `fpRun':
18:40:10 <auger> elliott: edwardk is making new awesomesauce lenses
18:40:13 <elliott> Yeaaah, -Wall is maybe a bit much for this.
18:40:17 <auger> elliott: so you'll have awesomesauce soon
18:40:21 <elliott> auger: has he stolen my idea
18:40:33 <auger> elliott: not really
18:40:42 <elliott> auger: my lawyers will be in touch
18:40:47 <auger> he's using math mumbojumbo
18:40:56 <elliott> auger: he's edwardk, how is that surprising
18:41:11 -!- auger has changed nick to copumpkin.
18:41:47 <elliott> Deewiant: Welp, it's more working now.
18:41:49 <elliott> *** [Reflecting on IO exception: mycotemp.tmp: hSeek: invalid argument (Invalid argument)]
18:41:52 <Deewiant> elliott: -fno-warn-incomplete-patterns
18:42:23 <elliott> I only want to not warn incomplete patterns for fpRun :-P
18:42:35 <Deewiant> elliott: {-# OPTIONS_GHC #-} etc.
18:43:01 <elliott> Theorising that hSeek doesn't like to be sought backwards.
18:43:55 <elliott> Deewiant: Do you seek past the beginning of the file by any chance?
18:44:17 <fizzie> elliott: import qualified Data.Map as Map; type Map = Map.Map? Though that's a bit silly too.
18:44:25 <elliott> I wonder if perhaps writing to a Handle doesn't advance it.
18:44:41 <elliott> fizzie: The way I do it is the way everyone and the documentation does it :P
18:44:45 <Deewiant> elliott: It wrote bar\nbaz, no? So 7 back should be fine
18:44:53 <elliott> Deewiant: Well, in theory.
18:45:05 <fizzie> elliott: Yes, I noticed the Data.Map documentation says to do it too when double-checking.
18:45:06 <Gregor> !bfjoust flapping_turtle <
18:45:19 <EgoBot> Score for Gregor_flapping_turtle: 0.0
18:45:23 <Gregor> !bfjoust trapping_turtle <
18:45:37 <EgoBot> Score for Gregor_trapping_turtle: 0.0
18:45:58 -!- hiato has quit (Quit: underflow).
18:45:59 <Gregor> Thanks to cheating, crapping_turtle now has a 43.3 :P
18:46:06 <elliott> Not in scope: `recTangleToByteString'
18:46:41 <oerjan> <elliott> I'd prefer something that stops it warning on "import Data.Map (Map); import qualified Data.Map as Map" :-P But without ignoring all redundant imports. <-- what, isn't that giving a warning against a _recommended practice_?
18:46:50 <elliott> Shiro/Fingerprints/FILE.hs:81:16:
18:46:50 <elliott> Warning: Pattern match(es) are non-exhaustive
18:46:50 <elliott> Patterns not matched: #x with #x `notElem` [0#, 1#, 2#]
18:47:18 <elliott> oerjan: It basically says "hurr, dat's redundant".
18:47:21 <Deewiant> elliott: I've filed a report about that particular diagnostic
18:47:37 <elliott> Deewiant: I imagine it runs at a later stage or whatever
18:47:56 <elliott> GHC's error messages are pretty bad anyway
18:48:40 <elliott> I think I re-broke rectangleToByteString.
18:50:04 <lambdabot> forall b a. (b -> Maybe (a, b)) -> b -> [a]
18:50:07 <elliott> :t Data.ByteString.unfoldr
18:50:08 <lambdabot> forall a. (a -> Maybe (Word8, a)) -> a -> BSC.ByteString
18:50:10 <Gregor> !bfjoust fapping_turtle -(>+>-)*4>([(+)*128.+>]+>[(+)*128.->]->)*5(+)*128>([(+)*128.+>]+>[(+)*128.->]->)*5
18:50:11 <elliott> :t Data.ByteString.unfoldrN
18:50:12 <lambdabot> forall a. Int -> (a -> Maybe (Word8, a)) -> a -> (BSC.ByteString, Maybe a)
18:50:24 <EgoBot> Score for Gregor_fapping_turtle: 40.4
18:52:08 <Gregor> !bfjoust fapping_turtle -(>(+)*128>(-)*128)*15
18:52:26 <EgoBot> Score for Gregor_fapping_turtle: 7.0
18:52:27 <elliott> rectangleToByteString :: FungeSpace -> Vector -> Vector -> ByteString
18:52:27 <elliott> rectangleToByteString fs offset (sx,sy) = {-fst $ -}B.unfoldr{-N (fromIntegral ((sx*sy)+sy))-} byte (0,0) --(ox,oy)
18:52:27 <elliott> | x >= sx = Just (lf, (0,y+1))
18:52:29 <elliott> | otherwise = Just (fromIntegral (fs !@ (offset + pos)), (x+1,y))
18:52:53 <elliott> Oh, I think that chops stuff off >_>
18:53:24 <elliott> ("OKWRITING","bar\nbazv\n",9,"WHICHISFROM",(5,490),"BYTES",7)
18:53:50 <elliott> Wait, how did that even happen...
18:54:47 <elliott> ("OKWRITING","",0,"WHICHISFROM",(5,490),"BYTES",7)
18:57:08 <elliott> ("OKWRITING","bar\nbaz",7,"WHICHISFROM",(5,490),"BYTES",7)
18:57:10 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
18:57:17 <elliott> BAD: couldn't close file with C
18:57:22 <elliott> Deewiant: >_<, I can't use hGetLine
18:57:27 <elliott> Because it strips the trailing newline if there was one
18:59:16 <elliott> Deewiant: You just want to make us implementers suffer.
18:59:23 <elliott> Didn't you call FILE easy busywork?
18:59:38 <Deewiant> It would've been easy if you'd've used the FFI
18:59:59 <elliott> Deewiant: Sure, but that's so ugly.
19:02:22 -!- hagb4rd has quit (Quit: hagb4rd).
19:02:58 -!- hagb4rd has joined.
19:03:20 <elliott> I think that mergeByteString could be a lot faster than it is now.
19:06:30 <elliott> Deewiant: Does Mycology check that its bounds are correct before shrinking?
19:06:43 <elliott> I have a new, faster mergeByteString that bypasses the bounds code, but I don't know if it gets them right. :p
19:06:57 <elliott> That the greatest point, relative to that point, is ( 184 912 )
19:06:57 <elliott> BAD: should have been ( 183 911 )
19:07:00 <elliott> At least it's just an off-by-one
19:07:27 <elliott> Deewiant: Is that before it expands its fungespace?
19:08:03 <elliott> Seems to work and it's certainly faster.
19:08:40 <elliott> $ time ~/Code/shiro/shiro mycology.b98 >/dev/null 2>&1
19:08:50 <elliott> Once I have population counts in there it'll be more like 2 seconds.
19:09:48 <elliott> $ time ~/Code/shiro/shiro mycology.b98 >/dev/null 2>&1
19:09:51 <elliott> Hooray for strictness annotations.
19:12:14 <Gregor> Dang it, why is this ais jerk sweeping the top three.
19:12:43 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
19:13:01 <elliott> Gregor: btw i think a change of the rules _might_ be in order i've been having thoughts
19:13:06 <elliott> Gregor: the top competitors are very loop-light
19:13:14 <elliott> Gregor: I think the 2-cycle loops take too long
19:13:21 <elliott> making loops a very unattractive option
19:13:27 <elliott> and i think this might be decreasing the range of possible strategies
19:14:12 <Gregor> That's a pretty severe rule change.
19:14:57 <elliott> quintopia: so? ais has changed it once before
19:15:01 <elliott> I'm not sure how loops should be balanced
19:15:04 <elliott> but they're almost useless now
19:15:15 <elliott> especially since the cycle-count is low enough that you can remove like 70% of loops just with a long repeat
19:15:20 <quintopia> always were, if you think about it
19:15:56 <elliott> it was ais' changes that made loops take two cycles
19:16:00 <elliott> the previous system was broken
19:16:03 <elliott> because [] was a real tripwire
19:16:11 <elliott> but this system seems to strongly discourage loops
19:17:05 <quintopia> [] still only takes one cycle per iteration according to ais
19:17:24 <elliott> yes, but it also takes one to enter
19:17:58 <quintopia> so you want [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[+ to take one iteration to do the +?
19:18:42 <impomatic> So how many cycles does [-] on 10 take? 21 or 30?
19:18:55 <elliott> impomatic: [-]-]-]-]-]-]-]... is the trace
19:19:02 <elliott> quintopia: As I said, I don't know what the solution is.
19:19:20 <quintopia> that asshole. he added those programs specifically to beat me :P
19:20:02 <elliott> quintopia: I'll say it again when someone who might actually think about it (i.e. ais) is on :P
19:21:24 <quintopia> maybe you should say it again when *you've* thought about it enough to suggest an actual solution?
19:21:47 <elliott> Hey guys, this movie sucks. <quintopia> SHUT THE FUCK UP UNTIL YOU MAKE A BETTER MOVIE
19:22:38 <quintopia> more like SHUT THE FUCK UNTIL YOU CAN ARTICULATE EXACTLY WHAT IT IS THAT IS WRONG WITH THIS MOVIE
19:23:32 <quintopia> moreover, what if the movie doesn't suck and it's all you?
19:23:54 <elliott> quintopia: the only person more defensive of BF Joust's rules than Gregor
19:24:24 <Gregor> I'm not defensive of BF Joust's rules at all, I don't give one flying fuck, I just don't want to change it because that's not fair to existing programs.
19:27:12 <quintopia> elliott: more seriously though, i am interested in this potential rule change. i just really don't get what you want to change and you are so vague that i can't see myself anything that might help.
19:27:12 <Gregor> !bfjoust return_of_shortsword (>++>--)*2(>)*6([-[+]]>)*20
19:27:34 <elliott> quintopia: I want to change loops to make them a nicer proposition. beyond that i don't know
19:27:39 <EgoBot> Score for Gregor_return_of_shortsword: 23.3
19:28:23 <elliott> !bfjoust defend0 (+-)*100000
19:28:26 <Ilari> As far as I can tell, the amount of IPv4 addresses available to APNIC to allocate under normal rules (according to latest data) is 76 480 512 (4.56 blocks).
19:28:52 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
19:29:04 <elliott> Gregor_crapping_turtle.bfjoust vs elliott_defend0.bfjoust:
19:29:04 <elliott> ><><><><><><><><><><> <><><><><><><><><><>< <><><><><><><><><><>< ><><><><><><><><><><>
19:29:17 <elliott> ais523_defend10.bfjoust vs elliott_defend0.bfjoust:
19:29:17 <elliott> XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX
19:29:17 <elliott> ais523_defend12.bfjoust vs elliott_defend0.bfjoust:
19:29:17 <elliott> XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX
19:29:21 <EgoBot> Score for elliott_defend0: 12.6
19:29:25 <Gregor> !bfjoust dirk (>++>--)*2(>)*5((-)*9[-[+]]>)*20
19:29:32 <Gregor> Well of course defend-v-defend is a tie.
19:29:48 <Gregor> 12.6 is still the lowest legit score on the hill :P
19:30:10 <Gregor> (fapping_turtle I replaced with a crapchute 'cuz I wanted it off the hill)
19:30:10 <EgoBot> Score for Gregor_dirk: 15.1
19:30:43 <Gregor> !bfjoust dirk (>++>--)*2(>)*6([(-)*9[+]]>)*20
19:30:51 <elliott> !bfjoust tourettes (+-+---+-++++----+++-+-----+++-+-++--++++---+++-+-+)*2000
19:31:02 <Deewiant> Gregor: That's like 2 commands different to monorail
19:31:23 <Gregor> Deewiant: ORLY? I've never actually looked at monorail, didn't realize it was shortsword-derived :P
19:31:26 <elliott> That's violating copyright don'tchamaknow
19:31:33 <EgoBot> Score for Gregor_dirk: 23.4
19:31:36 <Deewiant> I don't know whether it's shortsword-derived
19:31:59 <elliott> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>
19:31:59 <elliott> elliott_tourettes.bfjoust wins
19:32:05 <Deewiant> But make the 2 a 4 and the 6 a 1 and you have exactly monorail
19:32:06 <EgoBot> Score for elliott_tourettes: 17.6
19:32:48 <elliott> !bfjoust barf (++..<>..>+>>>.+-+>>>.-+..++<++.><>...<+->.<>+->>+.)*2000
19:33:01 <EgoBot> Score for elliott_barf: 0.0
19:33:11 <elliott> $ cat /dev/urandom | tr -cd '+\-<>.' | head -c 50
19:33:11 <Deewiant> elliott: < at the start is a bit pointless
19:33:11 <elliott> ++..<>..>+>>>.+-+>>>.-+..++<++.><>...<+->.<>+->>+.
19:34:01 <elliott> !bfjoust farf (-->[.]-[<-.+.]-[[-..>]>++-.]+--[>>][+]>->)*2000
19:34:05 -!- augur has quit (Ping timeout: 240 seconds).
19:34:18 <EgoBot> Score for elliott_farf: 0.0
19:34:50 <Deewiant> elliott: [<-.+.] is another suicide
19:34:57 <Gregor> !bfjoust vomitorium (]-++>--.+[].-+]][]->-]]]>>[.>+.]+[[.[>[]++-[->.>[>>[+-[][[>>--.-[]>[[>+>-[++.>[--.-..-.[+.->+.+]-][.>].-->+-].-[[]>.>.--.[[+].>[+..>+[+++][>[>]-.+-+-[)*100
19:34:58 <elliott> !bfjoust farf (-->[.]-[>-.+.]-[[-..>]>++-.]+--[>>][+]>->)*2000
19:35:03 <elliott> Gregor: ...that is beyond terrible.
19:35:27 <elliott> Gregor_crapping_turtle.bfjoust vs Gregor_vomitorium.bfjoust:
19:35:27 <elliott> >><><><><><><><><><>> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> >><><><><><><><><><>>
19:35:27 <elliott> Gregor_vomitorium.bfjoust wins
19:35:35 <Gregor> Yesssssssssssssssssssssssssssssssssssss
19:35:40 <elliott> Gregor_snapping_turtle.bfjoust vs Gregor_vomitorium.bfjoust:
19:35:41 <elliott> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>
19:35:41 <elliott> Gregor_vomitorium.bfjoust wins
19:35:45 <elliott> All your programs are terrible XD
19:35:45 <Gregor> Yesssssssssssssssssssssssssssssssssssss
19:35:47 <elliott> Gregor_vomitorium.bfjoust vs Vorpal_shudder.bfjoust:
19:35:47 <elliott> XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX
19:36:07 <Gregor> elliott: It's mixing output from two runs >_>
19:36:09 <elliott> Bahahaha, vomitorium might actually get a few points
19:36:36 <EgoBot> Score for Gregor_vomitorium: 5.7
19:36:36 <EgoBot> Score for elliott_farf: 0.0
19:37:01 <elliott> !bfjoust SHEER_UNADULTERED_BEAUTY [.]>.>[><<.<][>+<..>[>+->+-]<.[.-<.+-<<>].>-+<+--]>+[+<-+[>+-[<<+++]]+-]]<[->>>-]+.[..[<[+++[[.+>[[<.-]]<][<]-[[-<<+..>>+<.<><--
19:37:21 <elliott> Vorpal_shudder.bfjoust vs elliott_SHEER_UNADULTERED_BEAUTY.bfjoust:
19:37:22 <elliott> XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX
19:37:27 <elliott> ais523_decoytuner.bfjoust vs elliott_SHEER_UNADULTERED_BEAUTY.bfjoust:
19:37:27 <elliott> >>>>>>>>>>>>>>>>>>><< >>>>>>>>>>>>>>>>>>><< >>>>>>>>>>>>>>>>>>><< >>>>>>>>>>>>>>>>>>><<
19:37:27 <elliott> elliott_SHEER_UNADULTERED_BEAUTY.bfjoust wins
19:37:35 <elliott> ais523_tripstridewire.bfjoust vs elliott_SHEER_UNADULTERED_BEAUTY.bfjoust:
19:37:35 <elliott> <>>>>>>>>>>>>>>>>>><< <>>>>>>>>>>>>>>>>>><< <>>>>>>>>>>>>>>>>>><< <>>>>>>>>>>>>>>>>>><<
19:37:35 <elliott> elliott_SHEER_UNADULTERED_BEAUTY.bfjoust wins
19:37:40 <EgoBot> Score for elliott_SHEER_UNADULTERED_BEAUTY: 7.1
19:38:37 <elliott> Gregor: quintopia: Challenge: Write a pair of almost-identical warriors, master and slave, that can detect each other, such that when the slave realises it's competing against the master, it suicides; when this is not the case, any strategy can be used. False suicides are of course inevitable.
19:38:53 <Gregor> !bfjoust vomitorium_deluxe (>>>.[->>-.+[->.-.>>[>.>--+++>+>-.>+-.>.>.+++-.-[[->>.-+++>>>[>-+[.[--[-[+>+->.-.+>-+[.[-+-.+-+--..-]-+]++]]>]-..>+]]>->+.-+.-.]]>-->]>].>+.].>--.+->.-)*1000
19:38:57 <elliott> A similar thing was done in the iterated-prisoner's-dilemma tournament that led to tit-for-tat
19:39:00 <elliott> Gregor: Is that... balanced?
19:39:04 <EgoBot> Score for Gregor_vomitorium_deluxe: 0.0
19:39:18 <Phantom_Hoover> elliott, have the master send a "BOW BEFORE ME" signal in its startup, then continue as usual.
19:39:37 <elliott> They should try and meet in the middle of the tape.
19:40:19 <quintopia> i remember that. they won by submitting a whole bunch of players that would all lose to one of them on purpose. For this to work, the losing program would have to *itself* be a really good program,
19:40:42 <quintopia> other than that, it doesn't sound too difficult. A very specific and uncommon decoy trail could be the single easily
19:42:39 <Gregor> !bfjoust vomitorium_grande_with_beans (+[.>-+-[++.>[--[+.>[.>]]+]].>[----]-[.>+]]+.>[.>-]-+-[-.>[.>--]]].>.>+[.>+-].>-.>+-]+]-.>.>+++][-[-.>-+]+].>[-.>[.>-]++[.>.>-[.>+.>--]][[.>--]]-][.>+]+++-[]+[.>[.>][[.>-[.>-[-]++)*1000
19:42:50 <EgoBot> Score for Gregor_vomitorium_grande_with_beans: 0.0
19:43:31 <elliott> !bfjoust vomit_with_liqueur http://sprunge.us/JffR
19:43:43 <EgoBot> Score for elliott_vomit_with_liqueur: 0.0
19:43:51 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
19:44:00 <elliott> 24 0.00 -45.48 elliott_vomit_with_liqueur.bfjoust
19:45:01 <elliott> !bfjoust vomitA http://sprunge.us/dHfE
19:45:03 <elliott> !bfjoust vomitB http://sprunge.us/ZYNS
19:45:10 <elliott> !bfjoust vomitC http://sprunge.us/GeTd
19:45:14 <EgoBot> Score for elliott_vomitA: 0.0
19:45:22 <EgoBot> Score for elliott_vomitB: 0.0
19:45:35 <EgoBot> Score for elliott_vomitC: 0.0
19:46:15 <Phantom_Hoover> So what's the problem with >[>][-] as a BFJoust contender?
19:46:56 <Gregor> All that does is zero the cell immediately next to your flag :P
19:47:15 <Gregor> Inverse-BFJoust would actually be kinda interesting.
19:47:19 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
19:47:46 <EgoBot> Score for Deewiant_trivial: 0.0
19:47:49 <elliott> That's like "My First BF Joust Program".
19:48:07 -!- nddrylliog has joined.
19:48:09 <Gregor> !bfjoust my_first_bfjoust_program >([-]>)*30
19:48:11 <quintopia> Gregor: so we set everything to 128, and player responsible for setting the only remaining nonzero cell to zero wins?
19:48:24 <EgoBot> Score for elliott_fuck: 7.2
19:48:41 <EgoBot> Score for Gregor_my_first_bfjoust_program: 9.2
19:48:44 <Gregor> quintopia: ... no, but something along that lines could be brilliant :P
19:48:54 <Gregor> quintopia: I was thinking the flags are zero, and you have to make them nonzero.
19:49:04 <Gregor> Everything else is nonzero
19:49:16 <elliott> !bfjoust steal (>)*9-<-<-<((-)*10<)*3((-)*128<)*2
19:49:25 <Gregor> So planting decoys is ... more expensive than just finding the other flag lol
19:49:26 <quintopia> Gregor: that's not inverse BF Joust. EXACTLY inverse BF Joust would involve setting the flags to 128
19:49:33 <elliott> Gregor: *and you have to make them 128
19:49:37 <elliott> And then it's _exactly_ inverse.
19:49:42 <elliott> And therefore almost the same game.
19:49:45 <elliott> Except that [>] now works.
19:49:46 <Gregor> But then that's impossible...
19:49:48 <elliott> And so it's rather trivial.
19:49:49 <EgoBot> Score for elliott_steal: 1.5
19:50:18 <Gregor> How about looping BFJoust instead X-P
19:50:25 <Gregor> Just have the tape connect in both directions.
19:50:34 <Gregor> (And swap those polarities too)
19:50:46 <quintopia> <(-)*128 is the only valid prgoram
19:50:54 <Phantom_Hoover> The deputy head of my old school appears to have made a fake Facebook account to spy on students and crush any dissent.
19:51:01 <Gregor> quintopia: I didn't say that you take the tape exactly as is and connect it X_X
19:51:14 <Gregor> quintopia: If it's ten cells right, make it ten cells left too.
19:51:26 <quintopia> but the other idea is more hilarious
19:51:27 <Gregor> That way you can't step over the edge, but if you get lost you can't tell your flag from theirs >: )
19:51:33 <elliott> Gregor: I know, how about BF Joust where every instruction is randomly placed with another instruction and occasionally you teleport to a random tape location
19:51:48 <elliott> I AM AN INVENTOR JUST LIKE YOU
19:52:07 <Gregor> How about ChutesAndLaddersJoust
19:53:10 <elliott> oerjan: do you remember how that Haskell game worked yet?
19:53:15 <elliott> not the one where you had to recognise your own function
19:53:31 <quintopia> but seriously, what if we were playing in a 2D space using a language that has little more power than BF? for example, it just adds ^ and v to go up and down?
19:54:08 <Gregor> quintopia: I think you'd just get horribly lost.
19:54:17 <elliott> Just do it in Funge-98 at that point.
19:54:48 <quintopia> esp since you can clear the flag in one instruction
19:55:07 <elliott> I was working on BeYorFunge at some point.
20:03:54 <elliott> Deewiant: I really have a beef with the way you treat G :-p
20:04:28 <elliott> Deewiant: I guess it's just that the spec is so vague because it says "like fgets" when fgets takes a bloody length and pointer as parameters.
20:04:48 -!- poiuy_qwert has quit (Quit: This computer has gone to sleep).
20:07:11 -!- hagb4rd has quit (Ping timeout: 240 seconds).
20:10:05 <quintopia> alright. i've got a program that beats decoybooster2 and decoytuner, but it no longer beats wiggle3...if i could do that, it'd be p high ranked
20:11:53 <Gregor> But don't beat Gregor_crapping_turtle kthx
20:11:58 <elliott> quintopia: Just do a conditional :P
20:12:37 <quintopia> elliott: if (fighting_wiggle3) { beat_it }
20:12:52 <elliott> quintopia: You might also want to beat defend13 :P
20:13:14 <Gregor> !bfjoust furry_furry_bondage_girls -(>+>-)*4>([(-)*9[+]]+>]+>[[(-)*9[+]]->]->)*11
20:13:15 <quintopia> elliott: i already was beating defend13
20:13:33 <EgoBot> Score for Gregor_furry_furry_bondage_girls: 2.5
20:13:46 <elliott> Furry furry bondage girls: NOT SO GOOD AT BRAINFUCK JOUST?
20:13:54 <Gregor> Did I fuck something up, it shouldn't have been THAT bad X-D
20:14:01 <Gregor> It's just crapping_turtle with offset clears!
20:14:46 <Gregor> !bfjoust furry_furry_bondage_girls -(>+>-)*4>([(-)*9[+]>]+>]+>[[(-)*9[+]>]->]->)*11
20:15:02 <EgoBot> Score for Gregor_furry_furry_bondage_girls: 12.8
20:15:09 <Gregor> DAMN YOU FURRY FURRY BONDAGE GIRLS
20:15:17 <elliott> YOU'RE TOO FURRY, AND TOO BONDAGE
20:15:43 <quintopia> i'm really not too sure what to do about wiggle3
20:15:52 <Gregor> wiggle3 cannot be defeated.
20:15:56 <Gregor> wiggle3 shall conquer all
20:15:57 <quintopia> Gregor: BREAKDOWNS IN SEPARATE FILES KTHX
20:16:13 <Deewiant> elliott: In general it's based on Rc/Funge-98's original behaviour so it's "as intended"
20:16:23 <Gregor> quintopia: SHUT YOUR WHORE MOUTH WHEN BILLY MAYS IS TALKING
20:17:06 <quintopia> lul, it's beating me in every polarity
20:19:03 <oerjan> <elliott> oerjan: do you remember how that Haskell game worked yet? <-- wasn't it something based on feeding each function's result [Bool] into the other one lazily (i.e. deadlock was possible) and they had to try and recognize whether it was themselves without deadlocking
20:19:39 <elliott> oerjan: But then how did they say that they recognised themselves?
20:20:00 <quintopia> Gregor: sorry i beat crapping_turtle D;
20:20:10 <Gregor> NOOOOOOOOOOOOOOOOOOOSE
20:20:26 <Gregor> At least I'm still >40
20:21:22 <Gregor> Out of 48 that's really not too bad :P
20:22:28 <elliott> Deewiant: You normalise newlines to \n in CCBI's G right?
20:22:36 <oerjan> elliott: i don't recall. hm one might perhaps simply do that by ending the output list...
20:22:47 <elliott> Deewiant: You certainly handle \n and \r IIRC.
20:22:50 <elliott> But probably just to find the end.
20:23:22 <oerjan> if you end your output list, it means you think you're against yourself.
20:23:46 <oerjan> hm but how to signal the opposite?
20:24:10 <oerjan> is there a way to deadlock the other function without deadlocking yourself...
20:24:44 <elliott> *** [Reflecting on IO exception: mycotemp.tmp: openBinaryFile: resource busy (file is locked)]
20:25:18 <oerjan> or maybe the last list element could say. and you had to give an answer before reading the other's last list element.
20:25:29 <elliott> Deewiant: BTW, my Mycology load takes like .1-.2 seconds now after OPTOMIZATION.
20:25:38 <elliott> Wow, I pass all the FILE tests now.
20:25:56 <elliott> OK, so my G is a hideously slow character-by-character loop, but who cares.
20:25:59 -!- Phantom_Hoover has quit (Ping timeout: 240 seconds).
20:26:53 <quintopia> I DO NOT UNDERSTAND WIGGLE3 IT IS SO COMPLICATED BLAH
20:27:01 <elliott> Now I'm going to do the population count stuff.
20:27:05 <elliott> quintopia: just try and tie with it
20:27:11 <elliott> quintopia: by detecting it, and doing the exact same things it does
20:27:28 <quintopia> if i could understand it, i could detect it
20:27:39 <quintopia> well, i suppose i could look for its decoys
20:28:56 <quintopia> elliott: give me a piece of BF code that does if(a[i]==128) in one cycle plox
20:28:57 <elliott> Deewiant: What cfunge does, i.e. keep track of the population of each line and column so that shrinking the bounds doesn't require iterating through the entirety of FungeSpace.
20:31:16 <elliott> Deewiant: I guess it has inefficiencies, but it's easier to do than AABB :P
20:31:23 <oerjan> elliott: something like play p1 p2 = (last l1, last l2) where l1 = p1 (init l2 ++ undefined); l2 = p2 (init l1 ++ undefined)
20:31:30 <elliott> Deewiant: And will take something like 0 seconds rather than the 4 seconds it takes me now to shrink bounds
20:31:46 <oerjan> you'd need some IO magic to check for deadlock/ending trap
20:31:52 <elliott> oerjan: I swear the lists were infinite
20:32:03 <elliott> I drafted up a thing and you even made a warrior
20:32:17 <oerjan> elliott: well that may be, i'm just running with this current idea
20:34:29 * oerjan downloaded a bfjoust hill from a few hours ago and notes that only 6 of the programs make use of unmatched [] in ()*
20:35:11 <oerjan> which is technically illegal of course
20:35:21 <oerjan> ais523_defend14.bfjoust impomatic_sexyghoul.bfjoust jix_wiggle3.bfjoust
20:35:21 <oerjan> ais523_defend9.bfjoust impomatic_spookygoth.bfjoust myndzi_careless.bfjoust
20:36:00 <Deewiant> Well, apart from defend9 they're all top 10
20:36:59 <impomatic> Illegal? Now what am I accused of! ;-(
20:38:07 <quintopia> wooo. wireless now has the most points!
20:39:15 <quintopia> i don't see why that should be illegal as long as you make them match in the end
20:40:14 <oerjan> quintopia: the thing is that it makes it harder to implement efficiently, should we decide to make a more efficient implementation
20:40:43 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
20:40:53 <elliott> you've been submitting it in private message?
20:41:00 <elliott> you're not allowed to do that any more
20:41:23 <quintopia> who cares about how hard it is for the referee implementer? the goal is to be as easy for the players as possible, and the ()* constructs are easier to read than the ()% ones
20:41:58 <oerjan> quintopia: not really, the ()% tell you where to find matching []'s
20:42:09 <elliott> ()% are much more efficient if coded properly
20:42:29 <quintopia> oerjan: but all them {} get in the way.
20:42:30 <oerjan> of course (x{y}z)%n _is_ equivalent to (x)*ny(z)*n
20:42:34 -!- Phantom_Hoover has joined.
20:42:57 <quintopia> oerjan: i should say easier to write. it's easier to just write the program and come back and compress it with ()* around long runs
20:42:58 <oerjan> impomatic: the wiki spec says [] have to match inside () and {}
20:43:22 <oerjan> quintopia: oh is that what you do
20:43:53 <impomatic> Ought to change the wiki I suppose...
20:44:12 <quintopia> i can't bear to see the program longer than it should be. that long string of >>>>>>> in taller_towers pains me.
20:45:31 <elliott> we don't want to encourage (x)*ny(z)*n with unmatched [] in x and z
20:45:37 <elliott> because an efficient implementation wouldn't be able to process that
20:45:58 <Deewiant> If you don't want to encourage it, don't accept it
20:45:59 <oerjan> elliott: now i actually _do_ have a vague idea of how to do that somewhat efficiently
20:46:11 <elliott> well you could translate it to (x{y}z)%n i suppose
20:46:22 <elliott> Deewiant: that they aren't rejected is a bug in egojoust
20:46:22 -!- cheater00 has quit (Ping timeout: 240 seconds).
20:46:23 <oerjan> no, more general than that
20:46:51 <elliott> ^ most horrific abomination ever
20:47:00 <Deewiant> Don't ais's programs do stuff like that
20:47:13 <EgoBot> Traceback (most recent call last):
20:47:15 <Deewiant> Of course you can just peel one until the counts match
20:47:24 <oerjan> Deewiant: two of his are on the list of 6 above
20:47:26 -!- cheater00 has joined.
20:47:39 <Deewiant> oerjan: Yes, but mismatched counts in particular
20:48:13 <Deewiant> oerjan: I.e. (...[...)*m...(...]...)*n where m ≠ n
20:48:41 <oerjan> Deewiant: hm i haven't yet checked those programs for whether they do that
20:48:49 <EgoBot> Tokenizer error: Tokenizer can't comprehend '^'
20:48:49 <quintopia> impomatic: chainmail is the losingest program i've ever seen to have such a high score!
20:48:53 <EgoBot> Tokenizer error: Tokenizer can't comprehend '$'
20:48:54 <EgoBot> Traceback (most recent call last):
20:48:56 <oerjan> i stripped off the counts when checking
20:49:35 <elliott> thing that isn't very efficient with Data.Maps:
20:49:43 <elliott> "give me the greatest key with a value >0"
20:49:48 <elliott> "give me the smallest key with a value >0"
20:49:55 <oerjan> <elliott> Gregor: disable that <-- now that's a bit harsh, might want to announce the result to the channel anyhow though
20:50:04 <elliott> oerjan: it's bad, i like to see people working :D
20:50:35 <elliott> ugh this shrinking code is going to be hideous
20:50:43 <elliott> Deewiant what's your amazing fungespace bound thing again
20:50:44 <Gregor> Hmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
20:51:10 <Deewiant> elliott: You can do that in log(n) time with Data.Map
20:51:34 <Deewiant> elliott: (minView &&& maxView) $ split 0 map
20:51:41 <elliott> Deewiant: You can? My current solution is "find minimum key O(log n), iterate through keys from minimum key downwards until... O(bad)"
20:52:01 <oerjan> elliott: fingertrees are very good for precisely that kind of query i think
20:52:03 <elliott> Deewiant: Wait, does that give you *both* of them?
20:52:11 <Deewiant> elliott: Er, you wanted >0, sorry
20:52:12 <elliott> oerjan: O(log n) is good in my book... I'll try finger trees later
20:52:24 <elliott> split :: Ord k => k -> Map k a -> (Map k a, Map k a)Source
20:52:24 <elliott> O(log n). The expression (split k map) is a pair (map1,map2) where the keys in map1 are smaller than k and the keys in map2 larger than k. Any key equal to k is found in neither map1 nor map2.
20:52:26 <oerjan> elliott: well they're also O(log n) i think
20:52:28 <elliott> Deewiant: Isn't split the right thing there then
20:52:29 <Deewiant> elliott: (minView &&& maxView) . snd $ split 0 map
20:52:59 <elliott> Deewiant: Neat. So that gives (minKeyValAbove0,maxKeyValAbove0) right?
20:53:27 <elliott> Deewiant: Nice. Now I just have to fight with my hideous control structure.
20:53:49 <Gregor> http://www.youtube.com/watch?v=6RpoMyMtrz0 OK, this is too good :P
20:55:10 -!- augur has joined.
20:55:14 <elliott> Deewiant: Hmm, the problem is that I can't just do
20:55:17 <elliott> fs{ minX = minView . snd $ split 0 (colPopulation fs') }
20:55:17 <elliott> fs{ maxX = maxView . snd $ split 0 (colPopulation fs') }
20:55:27 <elliott> because I also have to update the min/maxY, don't I?
20:56:00 <Deewiant> If the (x,y) hits an outlying point then you do
20:56:34 <elliott> Deewiant: Right. So I just need more clauses:
20:56:38 <elliott> if x == minX and y == minY then ...
20:56:52 <elliott> (I can make it elegant later.)
20:57:06 <elliott> I also need "x == minX && y == maxY", woo, explosion of conditions
21:00:27 <Deewiant> Can't you handle x and y separately
21:01:24 <elliott> Deewiant: I could, but that would require indenting and things
21:02:34 <impomatic> elliott: so you're saying I should recode ([+)*6[(-)*7([-)*5[(-)*122[-(])*14 as ([+{[(-)*7([-{[(-)*122[-]]}])%5]}])%6
21:02:50 <elliott> impomatic: Pretty much, yep :P
21:02:55 <elliott> It doesn't matter w/ egojoust.
21:03:01 <elliott> But don't get too into the habit of doing it.
21:03:08 <elliott> Since the latter can executed much more efficiently in principle.
21:03:19 <impomatic> That's longer and trickier to read! :-(
21:07:15 <impomatic> Besides if I reimplement everything with ({}) I'll kill Ego again :-P
21:08:02 <elliott> Deewiant: Looks like O(log n) just ain't fast enough, it's going slower on the bounds check.
21:08:26 <Deewiant> elliott: You might want to force the computation
21:08:42 <elliott> Deewiant: if x == minX && y == minY then
21:08:42 <elliott> newMinX `seq` newMinY `seq` fs'{ minCoords = (newMinX,newMinY) }
21:08:58 <elliott> Hmm, this seems suspiciously completely hung
21:10:37 -!- nddrylliog has quit (Ping timeout: 276 seconds).
21:12:05 <elliott> http://www.thinkgeek.com/stuff/41/snuznluz.shtml Best idea ever?
21:13:22 <elliott> Deewiant: Tentative conclusion: It's calculating the new bounds just fine, except they're totally wrong and the interpreter goes into a freaky wrapping loop.
21:15:39 <elliott> Yep, it laggs up figuring out the next position.
21:15:59 <oerjan> so why does ais523_defend9 contain *-160 twice...
21:16:07 <oerjan> and what does it actually _mean_...
21:20:13 <oerjan> 49 times = atoi(prog.buf + end + 2);
21:20:14 <oerjan> 50 if (times < 0 || times > 10000) times = 10000;
21:20:26 <oerjan> look like the relevant lines of egojoust.c
21:21:24 <EgoBot> Score for elliott_mogul: 15.0
21:22:34 <oerjan> elliott: and there are two *-160, one containing exactly one [ and one containing exactly one ], so the match even if it's interpreted as 10000 :D
21:23:11 <elliott> !bfjoust peacebringer >([)*-1-(])*-1<(+--)*-1
21:23:50 <EgoBot> Score for elliott_peacebringer: 9.8
21:24:01 * elliott copies BBC's digital tapes before they throw them out
21:25:14 <elliott> !bfjoust detrimental_dear_watson ([+)*-1>([-]])*-1
21:25:43 <EgoBot> Score for elliott_detrimental_dear_watson: 13.7
21:26:15 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
21:26:53 <elliott> did you just submit a program behind my back
21:26:59 <elliott> i was looking for the breakdown
21:27:08 <elliott> oerjan: say that you'll ban everyone who submits programs via /msg thx
21:28:38 <elliott> ((-10,-10),(180,909),(17,201))
21:28:49 <elliott> Deewiant: Does Mycology start at x=173? :-P
21:29:35 <elliott> fs' = FungeSpace m' minXY maxXY (modm (subtract 1) y popRow) (modm (subtract 1) x popCol)
21:29:35 <elliott> newMinX = fst . fromJust . Map.minView . snd $ Map.split 0 (colPopulation fs')
21:29:35 <elliott> newMaxX = fst . fromJust . Map.maxView . snd $ Map.split 0 (colPopulation fs')
21:29:36 <elliott> newMinY = fst . fromJust . Map.minView . snd $ Map.split 0 (rowPopulation fs')
21:29:38 <elliott> newMaxY = fst . fromJust . Map.maxView . snd $ Map.split 0 (rowPopulation fs')
21:29:40 <elliott> Perhaps gremlins are to blame
21:30:06 <Deewiant> Well, depends on how the names map to the semantics
21:30:42 <elliott> Deewiant: colPopulation is population-indexed-by-column
21:30:49 <elliott> FungeSpace (Map.insert k v m) (min x minX, min y minY) (max x maxX, max y maxY)
21:30:50 <elliott> (modm (+1) y popRow) (modm (+1) x popCol)
21:30:58 <elliott> modm f = Map.alter (\x -> Just $ f (maybe 0 id x))
21:31:32 <elliott> Maybe I do have them mixed up but it doesn't look like it to me
21:32:05 -!- Mathnerd314 has joined.
21:32:42 <elliott> Deewiant: Thank you, this isn't just a random piece of ugly code that I'm getting to work before cleaning up
21:32:52 -!- Tritonio has joined.
21:33:21 <Deewiant> I just always get confused with 'maybe x id' since I tend to read it as fromMaybe first
21:35:43 <elliott> Yeah I'm pretty sure I don't have a mixup there, so I suspect that I'm just doin it rong.
21:37:53 <elliott> lol defend13 is on top again
21:43:04 -!- MigoMipo has quit (Read error: Connection reset by peer).
21:43:50 <elliott> Sweet, now I can get it to break after "That = is implemented"
21:45:00 <elliott> maybe i forgot some seqqing
21:45:48 <elliott> That buffered I/O is being used
21:45:52 <elliott> Do anything to fungespace in-between those two?
21:47:05 <elliott> Deewiant: If I ever wrote a Befunge test suite I'd have a hard time forgetting the... experience.
21:47:30 <Deewiant> If you write over 100K of Befunge you might forget the details
21:47:58 <elliott> Passing out does that to people.
21:48:20 <Phantom_Hoover> INCIDENTALLY: I am being forced to leave civilisation for 10 days, starting on Saturday.
21:49:23 <elliott> Now shut up and fix my code.
21:49:48 -!- Tritonio has quit (Quit: Leaving).
21:54:23 <elliott> Phantom_Hoover: O Oracle, why is my code broken seriously.
21:56:22 <elliott> *Shiro.Interpreter> Map.split 0 $ Map.fromList [(1,5),(2,5),(3,5),(999,0)]
21:56:23 <elliott> (fromList [],fromList [(1,5),(2,5),(3,5),(999,0)])
21:56:42 -!- nescience has joined.
21:56:43 <elliott> Deewiant: ...split is based on *keys*.
21:56:45 <elliott> Deewiant: ...split is based on *keys*.
21:56:50 <elliott> "O(log n). The expression (split k map) is a pair (map1,map2) where the keys in map1 are smaller than k and the keys in map2 larger than k. Any key equal to k is found in neither map1 nor map2."
21:57:03 <elliott> Deewiant: Which is why I was sceptical >_<
21:57:11 <elliott> Deewiant: I did say "minimum key _whose value_ is less than 0"
21:57:19 <nescience> I can't get any work done because my brain is full of brainfuck and tetris
21:57:53 -!- myndzi\ has joined.
21:57:57 <elliott> OK, new plan: Make modm remove the key entirely if its value is 0; then I just need the minimum/maximum key.
21:57:59 <Deewiant> elliott: Maybe you'll at some point learn to test or read docs before wondering why stuff doesn't work? :-P
21:58:04 -!- impomatic has quit (Quit: ChatZilla 0.9.86 [Firefox 3.5.16/20101130074636]).
21:58:10 <elliott> Deewiant: Stop speaking with such an authoritative voice then :P
21:59:23 <nescience> !bfjoust trapwire [[]-+---[]+-+++]
21:59:34 <elliott> Deewiant: Yes yes yes, I'll use it later.
21:59:58 <EgoBot> Score for nescience_trapwire: 7.1
22:00:21 <elliott> BAD: after spacing top-left corner, y should report least point as ( -2 -1 ), not ( -10 -10 )
22:00:22 <elliott> BAD: after spacing top-left corner, y should report greatest point as ( 182 910 ), not ( 190 919 )
22:00:22 <elliott> BAD: after spacing right edge, least point reported by y should remain ( -2 -1 )
22:00:22 <elliott> BAD: after spacing right edge, y should report greatest point as ( 181 910 ), not ( 189 919 )
22:00:22 <elliott> BAD: after spacing bottom edge, y should report greatest point as ( 181 909 ), not ( 189 918 )
22:00:31 <elliott> Shrinking: TOTALLY BROKEN???
22:00:42 <elliott> That "not ( -10 -10 )" thing worries me a bit ...
22:00:44 <nescience> if a cell is 0 and one program executes ] and another -, does the first loop?
22:00:46 -!- myndzi has quit (Ping timeout: 240 seconds).
22:01:03 -!- Behold has joined.
22:01:05 <elliott> nescience: Yes, it does. Or... I think it takes one cycle and then stops looping.
22:01:12 <elliott> You can't use [] to detect when a cell hits 0, by design.
22:01:37 <elliott> nescience: well, i think you can
22:01:38 <elliott> nescience: but not your flag
22:01:42 <elliott> because in the time it takes for the loop to finish
22:02:09 <nescience> I thought that if [ fails it skips to after ]
22:02:15 <Deewiant> !bfjoust trapwire_ >[[]-+---[]+-+++]
22:02:34 <elliott> nescience: It's []]]]]]]]]]]
22:02:41 <EgoBot> Score for Deewiant_trapwire_: 7.0
22:02:52 <nescience> that is what I thought it would be
22:03:12 <nescience> does it test the cell before or after the cell changes?
22:04:05 <elliott> we fleshed all this out ages back
22:04:14 -!- BeholdMyGlory has quit (Ping timeout: 265 seconds).
22:04:27 -!- hagb4rd has joined.
22:05:39 <Deewiant> !bfjoust spring (>)*8-<+<-<+<-<+<-<+<(+-+)*170(>)*9([(-)*9[+]]>)*20
22:06:04 <EgoBot> Score for Deewiant_spring: 19.2
22:06:53 <oerjan> further investigation shows that only two of those programs use mismatched [] in a way that isn't obviously convertible to matching ({})
22:07:19 <oerjan> impomatic_spookygoth.bfjoust
22:07:20 <oerjan> impomatic_sexyghoul.bfjoust
22:08:01 <oerjan> for the others, there is always a precisely matching other ()* that it can be combined with
22:08:12 <elliott> that impomatic, always breaking things
22:08:21 <Deewiant> !bfjoust spring (>)*8-<+<-<+<-<+<-<+<(+-+)*200(>)*9([(-)*9[+]]>)*20
22:08:56 <nescience> !bfjoust trapwire (-)*127>+[]<.---
22:09:45 <EgoBot> Score for Deewiant_spring: 19.2
22:09:52 <EgoBot> Score for nescience_trapwire: 16.9
22:10:03 <Deewiant> !bfjoust spring (>)*8-<+<-<+<-<+<-<+<(+-+)*250(>)*9([(-)*9[+]]>)*20
22:10:30 <EgoBot> Score for Deewiant_spring: 18.4
22:11:57 <nescience> !bfjoust trapwire (-)*127>+[]<-(>)*9(>[[-]])*21
22:12:37 <EgoBot> Score for nescience_trapwire: 16.1
22:12:56 <nescience> !bfjoust trapwire (-)*127>+[]<--+++(>)*9(>[[-]])*21
22:14:20 <EgoBot> Score for nescience_trapwire: 15.9
22:14:54 <nescience> !bfjoust trapwire (-)*127>+[]<.--+++(>)*9(>[[-]])*21
22:15:16 <elliott> do you just keep tweaking programs until they get a high score? :D
22:15:36 <nescience> not exactly, I just have a queue of ideas to try usually
22:15:43 -!- augur has quit (Ping timeout: 276 seconds).
22:15:59 <nescience> this one should have kept the delay but I was curious if there were more single loops
22:16:27 <elliott> !bfjoust nightingale >>>>>>>>>-[](>[-]>[+])*10
22:16:49 <EgoBot> Score for nescience_trapwire: 17.4
22:17:09 <Deewiant> !bfjoust spring (>)*8-<+<-<+<-<+<-<+<(+-+)*320(>)*9([(-)*9[+]]>)*20
22:17:12 <nescience> the idea was just to try and get double loops to fall through by not starting
22:17:22 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
22:17:30 <EgoBot> Score for elliott_nightingale: 2.2
22:17:47 <EgoBot> Score for Deewiant_spring: 19.2
22:18:06 <nescience> I have more to do to careful but I can't do it via rdp from my phone
22:18:30 <elliott> has anyone ever done a defend strategy that after like 90000 ticks gives up and does a dumb attack? i guess so
22:18:37 <elliott> i think the max tick count is too high for the tape lengths
22:18:48 <elliott> because you can waste so much time in a lot of cases
22:19:27 <nescience> yes, impomatic wrote some defenders that don't wait forever
22:20:19 <Deewiant> !bfjoust spring (>)*8-<+<-<+<-<+<-<+<(+-+)*347(>)*9([(-)*9[+]]>)*20
22:20:43 <EgoBot> Score for Deewiant_spring: 18.5
22:21:16 <elliott> ais's "make small decoys so I have more time to make larger decoys" strategy seems good
22:21:33 <elliott> maybe if you put some kind of []-trip just after your last normal decoy, and then went and attacked
22:22:18 <quintopia> it wouldn't work against programs that leave decoy trails as they clear
22:22:46 <elliott> well, i guess you could tie with them
22:22:52 <elliott> but unless they make all their decoys = 128
22:22:59 <quintopia> by the time you got back to check your trip, it would not be zero, but the opponent would already have passed it
22:23:21 <elliott> quintopia: fine, set your trip after the first few decoys
22:24:01 <quintopia> most programs don't leave decoy trails though, and those that do just leave size-1s
22:24:09 <quintopia> so you could still benefit probably
22:24:40 <Deewiant> !bfjoust maglev (>+>-)*4-(>[(-)*9[+]])*21[(+)*9[-.]](+..)*1000
22:24:48 -!- augur has joined.
22:25:06 <EgoBot> Score for Deewiant_maglev: 31.3
22:25:45 <nescience> so [ checks before cells are altered that cycle right?
22:26:40 -!- augur has quit (Remote host closed the connection).
22:26:49 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*8([(-)*9[+]])*20[(+)*9[-.]](+..)*1000
22:27:30 <EgoBot> Score for Deewiant_maglev: 1.9
22:27:32 <nescience> I think I should have written a backwards decoy before talking about it.. then I could take credit :P
22:28:03 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*8([(-)*9[+]]>)*20[(+)*9[-.]](+..)*1000
22:28:25 <elliott> Deewiant: Do you think if I paste you the relevant part of my code and act like I've found the bug and say "spot my bug" you'll notice it? :-)
22:28:36 <EgoBot> Score for Deewiant_maglev: 43.5
22:28:48 <elliott> Deewiant: But you always do!
22:29:10 <elliott> Admittedly always for really stupid bugs
22:29:15 <nescience> loops, loops! check 0 before or after?
22:29:52 <Deewiant> !bfjoust monorail (>+>-)*4(>[(-)*9[+]])*21[(+)*9[-.]](+..)*1000
22:30:25 <EgoBot> Score for Deewiant_monorail: 32.5
22:31:00 <Deewiant> !bfjoust monorail (>+>-)*4(>[(-)*9[+]])*21
22:31:06 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*8([(-)*9[+]]>)*20
22:31:30 <EgoBot> Score for Deewiant_maglev: 43.5
22:31:31 <EgoBot> Score for Deewiant_monorail: 32.5
22:31:46 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(-)*9[+]]>)*19
22:32:12 <EgoBot> Score for Deewiant_maglev: 3.7
22:32:14 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(-)*9[+]])*19
22:32:43 <EgoBot> Score for Deewiant_maglev: 33.5
22:32:50 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(-)*9[+]])*20
22:32:50 <elliott> Phantom_Hoover: Adverts... for Wikipedia... ontributors?
22:33:10 -!- nescience has quit (Remote host closed the connection).
22:33:24 <Phantom_Hoover> I just know that I am not unable to move due to crap lining every available surface.
22:33:25 <EgoBot> Score for Deewiant_maglev: 38.5
22:33:27 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(-)*9[+]])*21
22:34:05 <EgoBot> Score for Deewiant_maglev: 43.5
22:34:45 -!- nescience has joined.
22:35:01 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(-)*9[+]])*21[(+)*9[-.]](+..)*1000
22:35:32 <EgoBot> Score for Deewiant_maglev: 43.5
22:35:53 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(+)*9[-]])*21
22:36:09 <quintopia> !bfjoust tripwall (>+)*5>>+<-<++++[](<(+)*128)*4(>)*8([+[--[(+)*10[-]]]]>)*20
22:36:28 <EgoBot> Score for Deewiant_maglev: 44.8
22:37:11 <EgoBot> Score for quintopia_tripwall: 20.8
22:37:56 <quintopia> !bfjoust tripwall (>+)*5>>+<-<++++[](<(+)*127)*4(>)*8([+[--[(+)*10[-]]]]>)*20
22:38:44 <EgoBot> Score for quintopia_tripwall: 20.3
22:39:07 <quintopia> !bfjoust tripwall (>+)*5>>+<-<++++[](<(+)*128)*4(>)*8([+[--[(+)*10[-.]]]]>)*20
22:39:53 <EgoBot> Score for quintopia_tripwall: 19.4
22:40:00 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(+)*11[-]])*21
22:40:02 <Gregor> Glad to see crapping_turtle is still up there.
22:40:28 <EgoBot> Score for Deewiant_maglev: 44.0
22:40:47 <Gregor> quintopia: Because it had a big lunch and the bathroom at work was closed for repairs.
22:40:59 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(+)*12[-]])*21
22:41:14 <nescience> !bfjoust trapwire (-)*127>+>+[]<.-<(-+)*1000(>)*9[[-]]
22:41:18 <quintopia> you should make a new one called crapping_turtle_hanging_dirigible
22:41:19 <Gregor> quintopia: Snapping turtle just went for the flag under the assumption you left it at 128, trapping turtle was similar but left a few simple decoys, crapping turtle leaves a trail of "decoys"
22:41:26 <EgoBot> Score for Deewiant_maglev: 42.3
22:41:39 <elliott> OK... wtf. this code should be working perfectly.
22:41:53 <nescience> hey gregor; does [ test before or after + or - is applied?
22:41:59 <quintopia> Gregor: variations on (>(-)*128)*29?
22:42:02 <EgoBot> Score for nescience_trapwire: 17.1
22:42:06 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(+)*8[-]])*21
22:42:15 <Gregor> quintopia: A bit less stupid than that, but yes :P
22:42:28 <EgoBot> Score for Deewiant_maglev: 41.9
22:42:48 <Gregor> quintopia: Read it for yourself X-P
22:42:55 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(+)*7[-]])*21
22:43:05 <quintopia> !bfjoust how_stupid_is_it (>(-)*128)*29
22:43:25 <Gregor> Well that's particularly stupid 'cuz it'll lose even if it wins.
22:43:28 <EgoBot> Score for Deewiant_maglev: 42.6
22:43:31 <Gregor> You need to put a wait in.
22:43:35 <nescience> !bfjoust trapwire (-)*127>+[]<(-+)*1000(>)*9[[-]]
22:43:45 <Gregor> But even so you're wasting a lot of time on frames you could've checked and verified were zero.
22:43:45 <EgoBot> Score for quintopia_how_stupid_is_it: 1.5
22:44:05 <quintopia> Gregor: OR AM I LEAVING GIANT DECOYS?
22:44:17 <Gregor> quintopia: That one will step off the end of the tape if it zeros the flag.
22:44:30 <EgoBot> Score for nescience_trapwire: 18.9
22:44:44 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(+)*9[-]])*21
22:45:03 <nescience> !bfjoust trapwire (-)*127>+[]<(-+)*5000(>)*9[[-]]
22:45:04 * Gregor is just glad to have some survivors on the hill for once :P
22:45:12 <quintopia> !bfjoust how_stupid_is_it (>(-)*128.)*29
22:45:35 <EgoBot> Score for Deewiant_maglev: 45.2
22:46:27 <elliott> !bfjoust turtle_fucker (-)*127[.]
22:46:54 <EgoBot> Score for nescience_trapwire: 18.9
22:46:54 <EgoBot> Score for quintopia_how_stupid_is_it: 20.5
22:47:14 <nescience> !bfjoust trapwire (-)*127>+[]<(-+)*500(>)*9[[-]]
22:48:16 <EgoBot> Score for elliott_turtle_fucker: 16.5
22:48:17 <EgoBot> Score for nescience_trapwire: 18.5
22:48:39 <nescience> !bfjoust trapwire (-)*127>+[]<(-+)*1000(>)*9[[-]]
22:48:42 <quintopia> !bfjoust a_bit_less_stupid >>>>>>>>>([+[--[(-)*128]]]>)*20
22:48:49 -!- Mathnerd314 has quit (Ping timeout: 255 seconds).
22:49:23 <EgoBot> Score for nescience_trapwire: 19.2
22:49:41 <EgoBot> Score for quintopia_a_bit_less_stupid: 8.2
22:50:31 <quintopia> !bfjoust a_bit_less_stupid (>(+)*128)*4(>)*5([+[--[(-)*128]]]>)*20
22:51:05 <EgoBot> Score for quintopia_a_bit_less_stupid: 5.6
22:51:29 <Phantom_Hoover> http://www.smbc-comics.com/index.php?db=comics&id=2151
22:51:39 <quintopia> maybe doing it in reverse would help
22:51:51 <Phantom_Hoover> I can't look at that template without thinking that the underline makes it into a falling power, which makes no sense.
22:52:23 <quintopia> !bfjoust a_bit_less_stupid (>)*4((+)*128<)*4(>)*9([+[--[(-)*128]]]>)*20
22:53:02 <EgoBot> Score for quintopia_a_bit_less_stupid: 5.6
22:59:55 <elliott> This is ridiculous, it should be working.
23:02:24 -!- BeholdMyGlory has joined.
23:02:30 -!- BeholdMyGlory has quit (Changing host).
23:02:30 -!- BeholdMyGlory has joined.
23:03:32 -!- Mathnerd314 has joined.
23:04:58 -!- Behold has quit (Ping timeout: 250 seconds).
23:07:04 <elliott> Phantom_Hoover: O Oracle, is it possible for a Haskell progrma to have bugs?
23:07:45 <Phantom_Hoover> elliott, verily, my child, only if thou hast been faithless and allowed impure imperative thoughts to enter thine head.
23:08:47 <Phantom_Hoover> For thy sins thou must rewrite the Wikipedia article on the lambda calculus to be more in line with the principles of LaTeX and the words of the prophet Church.
23:08:54 <Gregor> Whoot, crapping_turtle still >40 in spite of clearly being garbage :P
23:09:41 -!- nescience has changed nick to myndzi.
23:10:06 <elliott> Phantom_Hoover: Has TV Tropes always... had an entire... namespace for Disney?
23:10:43 <Gregor> elliott: NUH UH IT HAS PI POINTS
23:11:06 <Phantom_Hoover> elliott, I suspect it's the stupid approach they have to disambiguation.
23:11:44 <Phantom_Hoover> So if there's something which has been adapted into a normal film and a Disney film, they can only put one into the Film namespace.
23:13:59 -!- FireFly has quit (Quit: swatted to death).
23:15:17 -!- BeholdMyGlory has quit (Remote host closed the connection).
23:15:28 <elliott> Phantom_Hoover: Nope: "The Disney Animated Canon is slowly being moved to its own namespace. Find out how you can help here."
23:15:36 <elliott> They need HELP to move a few pages?
23:16:53 <elliott> Phantom_Hoover: I clicked the link. It told me "Sorry, no discussion with that id exists.".
23:17:41 <oerjan> NO ONE CAN AID THE NUFFS
23:18:54 <oerjan> except for their godmother
23:18:57 <elliott> fs' = FungeSpace m' minXY maxXY (modm (subtract 1) y popRow) (modm (subtract 1) x popCol)
23:18:58 <elliott> newMinX = fst . Map.findMin $ colPopulation fs'
23:18:58 <elliott> newMaxX = fst . Map.findMax $ colPopulation fs'
23:18:58 <elliott> newMinY = fst . Map.findMin $ rowPopulation fs'
23:18:58 <elliott> newMaxY = fst . Map.findMax $ rowPopulation fs'
23:19:08 <elliott> in newMinX`seq`newMinY`seq`newMaxX`seq`newMaxY`seq`fs'{minCoords=(newMinX,newMinY),maxCoords=(newMaxX,newMaxY)}
23:20:09 <oerjan> er.. tricky. does it compile?
23:21:29 * oerjan didn't know you could leave out space there
23:21:31 <elliott> oerjan: but it doesn't shrink the bounds properly
23:21:46 <elliott> the idea is that, if we decrease a row or column population to 0, we remove the key
23:21:51 <elliott> and then get the new minimum/maximum keys
23:21:56 <elliott> which will exclude the newly-removed key
23:21:59 <elliott> and thus be our new tightest bounds
23:22:48 -!- hagb4rd has quit (Quit: hagb4rd).
23:23:05 -!- hagb4rd has joined.
23:23:08 <elliott> oerjan: but it doesn't work, for instance
23:23:15 <elliott> BAD: after spacing top-left corner, y should report least point as ( -2 -1 ), not ( -10 -10 )
23:23:16 <elliott> BAD: after spacing top-left corner, y should report greatest point as ( 182 910 ), not ( 190 919 )
23:23:16 <elliott> BAD: after spacing right edge, least point reported by y should remain ( -2 -1 )
23:23:16 <elliott> BAD: after spacing right edge, y should report greatest point as ( 181 910 ), not ( 190 919 )
23:23:16 <elliott> BAD: after spacing bottom edge, y should report greatest point as ( 181 909 ), not ( 190 918 )
23:23:26 <elliott> (-10, -10) is in fact the _old_ minimum bound
23:23:34 <elliott> so i don't know why it doesn't see the smaller bound now that the value there is gone
23:25:06 <lambdabot> Data.IntMap alter :: (Maybe a -> Maybe a) -> Int -> IntMap a -> IntMap a
23:25:06 <lambdabot> Data.Map alter :: Ord k => (Maybe a -> Maybe a) -> k -> Map k a -> Map k a
23:25:07 <lambdabot> Control.Applicative class Applicative f => Alternative f
23:25:44 <elliott> oerjan: takes (Just value) or Nothing if the key doesn't exist
23:25:52 <elliott> or (Just value') to update
23:28:41 -!- Sgeo has joined.
23:29:02 <elliott> oerjan: figured it out yet? :D
23:29:56 * Sgeo steals a pint of blood from elliott
23:30:17 <elliott> Phantom_Hoover: More evidence of Sgeo's sick furry blood fetish ^
23:30:27 <elliott> oerjan: but i was relying on you, i can't figure it out.
23:30:58 <Sgeo> I couldn't donate, because my dad needed to hurry up and pick me up due to family emergency
23:31:03 <Sgeo> I am royally ticked off
23:31:12 <Sgeo> I even way 111.4 lbs right niw
23:31:52 <oerjan> elliott: i note you are not actually using oldMin{X,Y} and oldMax{X,Y} anywhere...
23:32:08 <elliott> oerjan: yeah that's intentional
23:35:24 <elliott> and here i thought oerjan was a bug solving wizard
23:36:17 <oerjan> elliott: what happens if you replace minXY and maxXY with undefined in the above?
23:36:45 <Sgeo> elliott, donation limit is 110 lbs. I've been fluctuating over and under it
23:36:59 <elliott> oerjan: It runs without crashing.
23:37:08 <elliott> So the fields are definitely being replaced.
23:37:25 <elliott> (I have a fancy conditional that only conditionally replaces them but I've slimmed it down to this until I fix the bug
23:38:57 <oerjan> well i don't think i can solve this without more context
23:39:46 <lambdabot> Data.IntMap findMin :: IntMap a -> a
23:39:46 <lambdabot> Data.IntSet findMin :: IntSet -> Int
23:39:46 <lambdabot> Data.Map findMin :: Map k a -> (k, a)
23:40:10 <elliott> oerjan: http://sprunge.us/hdae is the whole function
23:40:20 <elliott> oerjan: dunno how much more context I could give without giving you the whole code
23:40:46 <oerjan> um and is the key what you want to minimize?
23:42:15 <elliott> oerjan: the key is y and x
23:42:18 <oerjan> i recently heard you muttering about it actually being the value...
23:42:29 <oerjan> so you have reversed the map?
23:42:36 <elliott> just forget what i said :D
23:42:45 <elliott> oerjan: basically, rowMap is a map from "y" values to the number of values in fungespace with coordinate (x,y) for some x
23:42:50 <elliott> same for colMap just x instead of y
23:43:07 <elliott> oerjan: so once we remove the current maximum or minimum from the map, we can use minKey/maxKey to find the smallest populated x or y
23:43:17 <elliott> because we remove population-0 entries
23:43:30 <elliott> but this...isn't working, totally inexplicably
23:43:35 <elliott> (that function is the place where we remove the entry)
23:46:08 <elliott> to repaste the errors from before so i can see them easier :D
23:46:09 <elliott> <elliott> BAD: after spacing top-left corner, y should report least point as ( -2 -1 ), not ( -10 -10 )
23:46:09 <elliott> <elliott> BAD: after spacing top-left corner, y should report greatest point as ( 182 910 ), not ( 190 919 )
23:46:09 <elliott> <elliott> BAD: after spacing right edge, least point reported by y should remain ( -2 -1 )
23:46:09 <elliott> <elliott> BAD: after spacing right edge, y should report greatest point as ( 181 910 ), not ( 190 919 )
23:46:09 <elliott> <elliott> BAD: after spacing bottom edge, y should report greatest point as ( 181 909 ), not ( 190 918 )
23:46:12 <elliott> <elliott> (-10, -10) is in fact the _old_ minimum bound
23:46:13 <elliott> <elliott> so i don't know why it doesn't see the smaller bound now that the value there is gone
23:46:29 <elliott> <elliott> BAD: after spacing right edge, least point reported by y should remain ( -2 -1 )
23:46:39 <elliott> so it thinks that the least point changes even when we're affecting the greatest point
23:46:46 <elliott> if it wasn't obviously the case i'd suspect mixed up min/max
23:47:21 -!- pikhq_ has joined.
23:47:59 -!- pikhq has quit (Ping timeout: 276 seconds).
23:48:12 <oerjan> elliott: oh hm one thing. that test Map.lookup k m == Just space what if that is Nothing instead?
23:48:26 <elliott> oerjan: then, as per the guard, you're trying to replace a space with space
23:48:33 <elliott> and so by definition nothing happens and we just skip all the checks
23:48:41 <elliott> otherwise, we're replacing something that isn't a space with a space, and so removing something
23:48:44 <elliott> so we have to do all the bounds trickery
23:49:27 <oerjan> elliott: um i mean aren't Just space and Nothing equivalent in that circumstance?
23:50:02 <elliott> oerjan: hmm. that's true, but there's no harm in running the else branch always
23:50:05 <elliott> it is just an optimisation
23:50:22 <oerjan> i guess the delete has no effect in that case
23:52:39 <elliott> good to know the person who wrote the entire haskell 98 report is on the case of my broken code
23:53:37 <Phantom_Hoover> It is widely believed in South Korea that electric fans can kill you if you leave them on for too long.
23:54:30 <elliott> Phantom_Hoover: http://en.wikipedia.org/wiki/Fan_death is possibly the best article.
23:54:33 -!- pikhq_ has changed nick to pikhq.
23:54:36 <Phantom_Hoover> elliott, what if his MOTHER was killed by a fan accident?
23:55:05 <Phantom_Hoover> Nuclear fission: a simple matter of consumer electronics.
23:55:45 <Phantom_Hoover> [[This explanation violates mass conservation and well-known properties of molecules and gases, particularly that known breakdown energy of oxygen molecules lies in the ultraviolet range, far above the energy produced by a fan.]]
23:55:49 <oerjan> elliott: are you sure the popRow is before the popCol in the actual data type definition? just checking...
23:55:57 <Phantom_Hoover> The way they take it entirely seriously is the funniest bit.
23:56:07 <oerjan> (that y before x makes me suspicious)
23:56:24 <elliott> oerjan: even if it wasn't, it's initialised to Map.empty and I only update it in that function which uses it consistently as you can see, so it would not matter; however to humour you :P:
23:56:28 <elliott> data FungeSpace = FungeSpace { spaceMap :: Map Vector Value
23:56:29 <elliott> , rowPopulation :: Map Value Value
23:56:29 <elliott> , colPopulation :: Map Value Value }
23:58:09 <pikhq> Y'know, the real reason for that rumor is *probably* that Korea doesn't usually have air conditioning, and they actually *need* it.
23:58:35 -!- myndzi has changed nick to nescience.
23:58:55 <pikhq> (unlike much of Europe, where >30°C is exceptional, >30°C isn't too unusual there.)
23:59:21 <elliott> pikhq: Thank you for you insight on this matter. If you want to add that information to the main article, you are quite welcome to. Did you know that Koreans also believe you can die from the air-conditioner in your car by the same method? I was always taught (I am not Korean by the way; I am Canadian of English decent, but i am living in South Korea) to close the car windows when the air-conditioner is on because if the windows are open, you let
23:59:22 <elliott> the hot air in. Koreans leave the windows of their cars open when the air-conditioner is on to avoid 'Fan Death'. This also applies to air-conditioners in houses. They make sure windows are open when the air-conditioner is on. Masterhatch