00:07:04 <elliott> @pl do x <- pop; push (if x == 0 then 1 else 0)
00:07:05 <lambdabot> expecting letter or digit, variable, "(", "`", "!!", ".", operator or end of input
00:07:08 <elliott> @undo do x <- pop; push (if x == 0 then 1 else 0)
00:07:08 <lambdabot> pop >>= \ x -> push (if x == 0 then 1 else 0)
00:07:11 <elliott> @pl pop >>= \ x -> push (if x == 0 then 1 else 0)
00:07:11 <lambdabot> push . flip (flip if' 1 . (0 ==)) 0 =<< pop
00:07:20 <elliott> @pl pop >>= \ x -> push (FOOP x)
00:07:36 <elliott> Deewiant: It's how you selectively disable point-freeing!
00:07:39 <elliott> PRETEND IT'S A CONSTRUCTOR
00:07:43 <Lymia> What does "pl" have to do with "Haskell
00:07:48 <Deewiant> I know, I was just amused by "FOOP"
00:07:51 <elliott> Lymia: Point-free code. Or point-less.
00:08:17 <lambdabot> Overlapping instances for GHC.Show.Show
00:08:23 <elliott> > (fromEnum . not . toEnum) 34
00:08:25 <lambdabot> *Exception: Prelude.Enum.Bool.toEnum: bad argument
00:08:31 <elliott> > (fromEnum . not . (==0)) 34
00:08:37 <elliott> > (fromEnum . not . (/= 0)) 34
00:08:40 <elliott> > (fromEnum . not . (/= 0)) 1
00:08:42 <elliott> > (fromEnum . not . (/= 0)) 0
00:08:45 <Deewiant> You can just drop the not, you know.
00:09:00 <elliott> doCharIns '!' = push . fromEnum . (== 0) =<< pop
00:09:09 <Lymia> !bfjoust evob +->>>--+.-..<>>-+--<>->-+-..--.->+++>>++++>>+>>(>--<>[+])*51-+.><++.+----.
00:09:15 <EgoBot> Score for Lymia_evob: 6.1
00:09:41 <elliott> Couldn't match expected type `Value' against inferred type `Int'
00:09:41 <elliott> In the second argument of `(.)', namely `fromEnum . (== 0)'
00:09:41 <elliott> In the second argument of `(>>=)', namely
00:09:41 <elliott> `push . fromEnum . (== 0)'
00:09:41 <elliott> In the expression: pop >>= push . fromEnum . (== 0)
00:09:48 <elliott> @hoogle Enum a => a -> Int32
00:09:52 <lambdabot> Prelude enumFrom :: Enum a => a -> [a]
00:09:52 <lambdabot> Prelude enumFromThen :: Enum a => a -> a -> [a]
00:09:56 <lambdabot> Prelude fromEnum :: Enum a => a -> Int
00:10:33 * elliott just writes enumValue instead
00:10:52 <lambdabot> forall b a. (Num b, Enum a) => a -> b
00:11:02 <elliott> That's the implementation.
00:11:14 <elliott> Deewiant: Let me guess: # isn't as simple as pos <- pos + delta.
00:11:27 <Deewiant> It should be, if your wrapping stuff works sensibly. :-P
00:15:00 <elliott> IS REMAINDER MODULO OR REMAINDER
00:15:18 <elliott> the % "Remainder" instruction, which pops two values, divides the second by the first using integer division, and pushes the remainder, of those. Remainder by zero is subject to the same rules as division by zero, but if either argument is negative, the result is implementation-defined.
00:15:25 <elliott> I forgot that there was a long table too.
00:15:57 <Lymia> !bfjoust evoc ...->-+----->+..>---->-+>--+>-..--.-.->->>>---+>+...(>---.-[+])*54->->>>+.>.><.
00:16:03 <EgoBot> Score for Lymia_evoc: 10.9
00:16:47 <Lymia> !bfjoust evoc_optimized ->----->+>---->>->----->->>>-->+(>[+])*1024
00:16:50 <EgoBot> Score for Lymia_evoc_optimized: 2.0
00:17:39 <Lymia> !bfjoust evoc_optimized ->----->+>---->>->----->->>>-->+(>[+].)*1024
00:17:43 <EgoBot> Score for Lymia_evoc_optimized: 1.7
00:18:17 <ais523> Lymia: that actually looks like a decent early program
00:18:29 <Lymia> It's generation 2200 or something.
00:18:37 <ais523> that's the sort of thing we were coming up with near the start of BF Joust play
00:18:39 <elliott> you really need breeding, I think
00:18:44 <elliott> Lymia: you could try it on an old hill
00:18:50 <ais523> the only reason it's doing badly on our hill is that all the programs are designed to beat that sort of thing
00:18:54 <Lymia> elliott, that might help.
00:19:00 <elliott> Lymia: although not the report, just the program set
00:20:00 <elliott> heh, how on earth did that first one parse
00:20:02 <lambdabot> forall t a. (Num ((a -> a -> a) -> t), Integral a) => t
00:20:15 <lambdabot> Couldn't match expected type `GHC.Types.Int'
00:20:21 <elliott> :t \pop -> flip rem <$> pop <*> rem
00:20:23 <lambdabot> forall a. (Integral (a -> a), Integral a) => (a -> a -> a) -> a -> a -> a
00:20:28 <lambdabot> forall a. (Integral a) => a -> a -> a
00:20:30 <elliott> :t \pop -> (flip rem) <$> pop
00:20:31 <lambdabot> forall a (f :: * -> *). (Integral a, Functor f) => f a -> f (a -> a)
00:20:58 <elliott> @hoogle f (a -> b) -> f a -> f
00:20:59 <lambdabot> Prelude (.) :: (b -> c) -> (a -> b) -> a -> c
00:20:59 <lambdabot> Data.Function (.) :: (b -> c) -> (a -> b) -> a -> c
00:20:59 <elliott> @hoogle f (a -> b) -> f a -> f b
00:20:59 <lambdabot> Control.Applicative (<*>) :: Applicative f => f (a -> b) -> f a -> f b
00:21:00 <lambdabot> Control.Monad ap :: Monad m => m (a -> b) -> m a -> m b
00:21:01 <lambdabot> Control.Applicative (<**>) :: Applicative f => f a -> f (a -> b) -> f b
00:21:05 <elliott> :t \pop -> flip rem <$> pop <*> pop
00:21:06 <lambdabot> forall a (f :: * -> *). (Integral a, Applicative f) => f a -> f a
00:21:21 <Lymia> I really need to learn Haskell.
00:21:23 <elliott> I should probably have a "binary rem" for that.
00:21:41 <Lymia> More haskell than "general syntax"
00:24:25 <elliott> Deewiant: &~ should give 42 and 10 when provided with "42\n", right?
00:24:33 <elliott> I'd try Mycology but I'm nowhere near running it yet.
00:24:36 <elliott> i.e. does & consume a newline?
00:24:53 <Sgeo> What testsuites exists for other languages?
00:25:17 <elliott> Deewiant: Ah, I see, you want me to get it to Mycology-level before asking questions :-P
00:25:47 <Deewiant> No, I actually do forget. I spent some time messing with that.
00:26:01 -!- Behold has quit (Remote host closed the connection).
00:26:04 <elliott> I have a feeling the \n actually is consumed.
00:29:01 <Lymia> hg clone *repo* right?
00:29:51 <Lymia> !bfjoust evod +>((+>.--+<)*6<+>+>+>-.--.>+<+>)*3<>.<<>>.+>--+.++<.->+>>+><>(>--[+])*55>+<>->.+>++
00:29:55 <EgoBot> Score for Lymia_evod: 9.3
00:30:21 <elliott> for so little thinking time (a couple thousand generations aren't much)
00:30:28 <elliott> after all, it has no good strategies
00:30:48 <Lymia> Currently, it's picking the best fighter from within itself.
00:30:59 <Lymia> I could make it also count how well it does on the current hill for scoring.
00:31:20 <elliott> That pushes the character ' forever, right? :D
00:31:35 <Deewiant> Conceptually, your program is embedded in an infinite sea of spaces
00:31:50 <Deewiant> And ' fetches the next cell, not instruction.
00:32:42 <elliott> Deewiant: So no wrapping there.
00:32:52 <elliott> doCharIns '\'' = advance *> (push <$> peekHere)
00:33:46 <Deewiant> Note that this is also why # over the edge of the program shouldn't skip anything on the other side, IMO. (Mycology calls it an UNDEF because I haven't bothered to change it, and Vorpal might get pissed at me.)
00:34:37 <elliott> Deewiant: You might be right. I'll add that as a TODO.
00:34:47 <Deewiant> I have "advance" and "go to next instruction" as separate functions. :-)
00:36:16 -!- cheater- has joined.
00:36:23 <elliott> IP (x,y) (dx,dy) <- ip <$> get
00:36:23 <elliott> push =<< peek (x+dx, y+dy)
00:36:27 <elliott> This is easier than I expected.
00:36:49 <Deewiant> Redundant computation of x+dx and y+dy!!
00:39:35 -!- cheater00 has quit (Ping timeout: 240 seconds).
00:39:45 <elliott> @do flip f <$> pop <*> pop >>= push
00:39:45 <lambdabot> do { a <- flip f <$> pop <*> pop; push a}
00:40:09 <elliott> Deewiant: Hang on, what happens on underflow/overflow?
00:40:20 <elliott> Please tell me I don't have to saturate or something.
00:40:27 <elliott> I was just checking whether it parsed right.
00:40:40 <Deewiant> I thought you were wondering whether the <$> and <*> do the right thing
00:40:48 <elliott> I knew that part was right :)
00:40:50 <Deewiant> What do you mean, underflow/overflow
00:41:22 <elliott> Deewiant: i.e. (2^32 - 1) + 1
00:41:26 <elliott> 46.Output Integera writeint(a)
00:41:49 <elliott> I forgot this has an actual spec.
00:42:20 <Deewiant> But, under/overflow is, if not specced, either UNDEF or universally enough agreed to be 2's complement that it might as well be defined
00:42:40 <elliott> [[These instructions will act as r does, should the standard output fail for any reason.]]
00:43:06 <Deewiant> `catch` \(_ :: IOException) -> reflect
00:44:17 <Sgeo> Is it worth it to uninstall OOo and install LibreOffice?
00:44:37 <Sgeo> Too late anyway, but still
00:45:12 <ais523> Sgeo: it'll make basically no difference either way atm
00:45:21 <ais523> they'll be a bit more different in a bit
00:45:24 <elliott> Deewiant: Now I get to write ;.
00:45:32 <elliott> Deewiant: I'm really scared of k because I'll have to handle ; too :P
00:45:37 <elliott> Maybe I should have a nextSemicolon function.
00:45:54 <elliott> Deewiant: behaviour of fungespace ";" = ?
00:45:57 <Deewiant> "goto next instruction" as I said :-D
00:46:03 <Deewiant> Same as fungespace "", infloop
00:46:39 <Lymia> !bfjoust evoe >>((+<->>->>.>>)*1.+<->>+->[].>+.>+.)*1-+<+<+>..>-...+>>.+--->>-(.+>[+])*61..<-..>.--.<
00:46:49 <EgoBot> Score for Lymia_evoe: 0.4
00:47:10 * Lymia kills the evolver process
00:49:13 <elliott> Deewiant: Fingerprint draft: Floating-point delta
00:49:21 <olsner> "would you mind letting me in?" "Yeah, sure." and then they let them in, just after saying they'd mind...
00:49:47 <Sgeo> "20 minutes" "You've got 10"
00:49:56 <Sgeo> I wonder how many managers get ideas from that sort of thing
00:50:15 * Sgeo answers the OOo uninstaller survey. I just put "LibreOffice" for everything
00:50:20 <elliott> Err, don't [ and ] actually rotate by 45 degrees?
00:51:41 <Deewiant> If you can't do it in your head, get a piece of paper, draw triangles and compute sines and cosines. :-D
00:53:46 <elliott> Deewiant: it sets dx = -dy, dy = dx, right? sorry i'm not going to get out a piece of paper, that would be surrendering to my 1am-brain
00:53:50 <elliott> which is like my normal brain but _even stupider_
00:54:41 <olsner> it's a stupider brain, but it would have paper
00:54:42 <elliott> unless i'm really mistaken
00:55:14 -!- jcp has quit (Excess Flood).
00:56:56 <elliott> @undo do x <- pop; y <- pop; push x; push y
00:56:56 <lambdabot> pop >>= \ x -> pop >>= \ y -> push x >> push y
00:57:02 <elliott> @pop pop >>= \ x -> pop >>= \ y -> push x >> push y
00:57:04 <elliott> @pl pop >>= \ x -> pop >>= \ y -> push x >> push y
00:57:04 <lambdabot> (pop >>=) . (. push) . (>>) . push =<< pop
00:57:06 <Lymia> How long does hg clone usually take?
00:58:06 -!- jcp has joined.
00:59:34 <elliott> @undo do x <- pop; if x == 0 then go east else go west
00:59:34 <lambdabot> pop >>= \ x -> if x == 0 then go east else go west
00:59:38 <elliott> @pl pop >>= \ x -> if x == 0 then go east else go west
00:59:38 <lambdabot> flip (flip if' (go east) . (0 ==)) (go west) =<< pop
01:00:11 <Deewiant> @pl pop >>= \x -> go (if x == 0 then east else west)
01:00:12 <lambdabot> go . flip (flip if' east . (0 ==)) west =<< pop
01:00:49 <Deewiant> @pl pop >>= \x -> go ([east,west] !! (fromEnum (x /= 0)))
01:00:49 <lambdabot> go . ([east, west] !!) . fromEnum . (0 /=) =<< pop
01:01:38 <olsner> aww, was just about to suggest the (... !!).fromEnum solution
01:04:01 <elliott> lambdabot could replace everyone at Galois
01:04:17 <olsner> maybe lambdabot is just galois' shared irc account
01:04:19 <elliott> Deewiant: Does h do nothing or reflect in Befunge
01:04:41 <ais523> the only things that do nothing in Befunge are things specifically specced to do nothing
01:04:51 <elliott> Deewiant: So is j a minetrap like k is?
01:05:09 <Deewiant> j is just like a generalized #
01:05:28 <lambdabot> forall (m :: * -> *) a. (Monad m) => Int -> m a -> m [a]
01:05:37 <elliott> doCharIns 'j' = pop >>= flip replicateM advance
01:06:35 <lambdabot> forall (m :: * -> *) a. (Monad m) => Int -> m a -> m ()
01:07:10 -!- hagb4rd has quit (Ping timeout: 240 seconds).
01:12:49 <elliott> Shiro/Interpreter.hs:127:16:
01:12:49 <elliott> Couldn't match expected type `()' against inferred type `FM ()'
01:12:49 <elliott> In the first argument of `(<$>)', namely `flip poke'
01:12:49 <elliott> In the first argument of `(<*>)', namely `flip poke <$> pop'
01:15:59 -!- poiuy_qwert has quit (Quit: This computer has gone to sleep).
01:16:25 <elliott> @hoogle (a -> b) -> m a -> m b
01:16:26 <lambdabot> Data.Traversable fmapDefault :: Traversable t => (a -> b) -> t a -> t b
01:16:26 <lambdabot> Prelude fmap :: Functor f => (a -> b) -> f a -> f b
01:16:26 <lambdabot> Control.Applicative (<$>) :: Functor f => (a -> b) -> f a -> f b
01:16:37 <elliott> @hoogle m (a -> b) -> m a -> m b
01:16:37 <lambdabot> Control.Applicative (<*>) :: Applicative f => f (a -> b) -> f a -> f b
01:16:38 <lambdabot> Control.Monad ap :: Monad m => m (a -> b) -> m a -> m b
01:16:38 <lambdabot> Control.Applicative (<**>) :: Applicative f => f a -> f (a -> b) -> f b
01:18:22 <olsner> yes, there are at least 3 functions for doing that :)
01:19:19 <elliott> 115sStore Character/98c store-funge-space(position+delta,v)
01:19:53 <elliott> The u "Stack under Stack" instruction pops a count and transfers that many cells from the SOSS to the TOSS. It transfers these cells in a pop-push loop. In other words, the order is not preserved during transfer, it is reversed.
01:22:55 <elliott> 119wCompare/98/2Da b if (a>b) ']' elsif (a<b) '[' else 'z'
01:32:26 <elliott> $ runhaskell Shiro/Interpreter.hs
01:32:26 <elliott> Interpreter.hs: WTF? Executed 32. (Infinite wrapping loop?)
01:33:18 <olsner> good me, now I can postpone sleep for however long I want, it's on the TODO
01:34:58 -!- elliott has left (?).
01:39:45 -!- variable has quit (Quit: Daemon escaped from pentagram).
01:42:42 -!- variable has joined.
02:10:20 -!- Lymia_ has joined.
02:10:45 -!- ais523 has quit (Remote host closed the connection).
02:11:20 -!- Lymia has quit (Disconnected by services).
02:11:21 -!- Lymia_ has changed nick to Lymia.
02:11:21 -!- Lymia has quit (Changing host).
02:11:22 -!- Lymia has joined.
02:25:12 -!- poiuy_qwert has joined.
02:26:00 <Lymia> !bfjoust darwin-49-0 +>((-.><-<>->+)*1+<-.>+->[].++.>)*3-..-+>+++>->..---..+->>>--(><>-[+])*58+.>+-.>>->>-.<
02:26:56 <EgoBot> Score for Lymia_darwin-49-0: 1.2
02:36:32 -!- TLUL has quit (Read error: Connection reset by peer).
02:36:58 -!- TLUL has joined.
02:45:45 -!- sftp has quit (Ping timeout: 250 seconds).
02:49:13 <Lymia> !bfjoust darwin-151-0 +>(-(---<-+>->+)*1+<-->->.->[].++.>)*2>-.>-+<>..>->>+.-++..>-.>---(><>(-)*5[+])*57+<>>-+.<<>>>+.<
02:49:17 <EgoBot> Score for Lymia_darwin-151-0: 5.9
02:50:17 <quintopia> what does the number mean? fitness score?
02:51:48 <Lymia> The second is ranking within the generation.
02:54:36 <Gregor> My music build setup is now 100% repeatable :)
02:55:10 <quintopia> Lymia: so 0 is the highest ranking?
02:55:16 <Gregor> When I type 'make', I get bit-per-bit identical FLAC files every time.
02:55:46 <Gregor> Not a lot, but enough *shrugs*
02:55:56 <Gregor> Not noticeably of course, but I want `cmp` to say they're the same :P
03:02:38 <Sgeo> I hate hate hate the way everyone teaches percents
03:02:52 <Sgeo> The formula for XYZ is whatever% times this divided by 100
03:03:38 -!- poiuy_qwert has quit (Read error: Connection reset by peer).
03:03:46 <quintopia> i do not know what you are talking about
03:03:56 <quintopia> and i don't remember ever being taught percent
03:04:53 <Sgeo> Or is it *100? I don't even remember, because it's such a STUPID way to think about things with percents
03:05:15 -!- poiuy_qwert has joined.
03:08:05 <Lymia> !bfjoust darwin-232-0 +>(.-(---<.+>-->+)*1+<--<>->.>>[]-.->>)*1>-.>++<>...->>+..-+.+->>.>---(+>(-)*9[+])*61+<>.<>.+<+>><-.
03:08:15 <EgoBot> Score for Lymia_darwin-232-0: 11.8
03:10:25 <Gregor> Are their only competitors themselves?
03:13:36 <quintopia> but that one answers my question about getting rid of ()* in the evolution code :P
03:14:38 <Lymia> I'll do that sometime later
03:15:16 <Lymia> !bfjoust darwin-264-0 .>(-(----<.+>-.->+)*1+<--<>->.->[].--<>)*1>-.>-+<><..->>+..++.+<>>>>---(.>(-)*9[+])*58.<>...+<+>>+-.
03:15:24 <EgoBot> Score for Lymia_darwin-264-0: 18.6
03:15:33 <Lymia> !bfjoust darwin-264-7 .>(-(----<.+>-.->+)*1+<--<>->.->[].--<>)*1>-.>-+<><..->>++..++.+<>>>--+(+.>(-)*9[+])*58.<>...+<+>>+-.
03:15:54 <EgoBot> Score for Lymia_darwin-264-7: 14.4
03:21:46 <Lymia> Gregor, hill is being climed.
03:22:23 <quintopia> so it's purely "take the top performers on each generation and mutate them slightly"?
03:22:34 -!- TLUL has changed nick to TLUL|afk.
03:23:23 <quintopia> you make me want to write a bfj ga and try to do it better >_>
03:26:21 <Lymia> I don't exactly have a single number for mutation.
03:26:31 <Lymia> quintopia, if you want to try, good luck.
03:26:41 <Lymia> It'd be an intresting compitition.
03:27:58 <quintopia> i'd feel bad about it tho because i could be using that time working on an assignment i'm already way behind on anyway...
03:32:50 <Lymia> !bfjoust darwin-341-0 ++>(-(---<---.>-->-)*4>-..<.+-<<-+-+-<-)*4+++>>>->..+<>+++>--+--.>>---(>(-)*6[+])*58>+>..-->++<.+-<
03:32:55 <EgoBot> Score for Lymia_darwin-341-0: 27.7
03:33:04 <Lymia> !bfjoust darwin-341-7 >>(-(--<--.>-->-)*4><...<+-+<-<-+-<>)*5<+.>>+>>..+><>+>+>+-+--.>>--.(>(-)*8[+])*57+->..-<><+>.+-<
03:33:17 <EgoBot> Score for Lymia_darwin-341-7: 10.0
03:33:36 -!- poiuy_qwert has quit (Read error: Connection reset by peer).
03:35:15 -!- poiuy_qwert has joined.
03:38:27 <Lymia> The Darwin series rises.
03:38:54 <Lymia> If you can't make them, grow them.
03:44:11 -!- azaq23 has joined.
03:46:02 -!- azaq231 has quit (Ping timeout: 246 seconds).
03:46:24 <Lymia> !bfjoust darwin-403 >(-(----<--.>--->-)*6><..<+-<<.<-+-<-)*4++..>+>+..+>>><>++.->--.>>>-<(>(-)*4[+])*60++<..+><+>.>-<
03:46:31 <EgoBot> Score for Lymia_darwin-403: 22.2
03:48:49 -!- Lymia_ has joined.
03:48:54 -!- Lymia has quit (Disconnected by services).
03:48:56 -!- Lymia_ has changed nick to Lymia.
03:48:58 -!- Lymia has quit (Changing host).
03:48:58 -!- Lymia has joined.
03:50:43 <Lymia> How's your evolver going?
03:50:49 <Lymia> If you're working on it at all.
03:52:19 <Lymia> private def runEgojoust(a:String, b:String) = rt.exec(Array[String](egojoustExecutable,a,b)).waitFor
03:53:36 -!- poiuy_qwert has quit (Read error: Connection reset by peer).
03:55:14 -!- poiuy_qwert has joined.
03:56:06 <quintopia> yes. i didn't know the existence of this executable
03:57:37 -!- nrkn has joined.
03:57:47 <Lymia> !bfjoust darwin-454-0 >(-(----<--->--->-)*5><..<+-<><.<-+--)*4>+..>+<+..+>>><>++..>--<>>>-<(>(-)*5[+])*59++<..+><+>.>-<
03:57:51 <EgoBot> Score for Lymia_darwin-454-0: 14.0
03:58:05 <Lymia> !bfjoust darwin-454-7 >((----<--->---->-)*5><..<+<>><.<-+--)*3>+.--><+..>>><++..>--<>>.<(>(-)*3[+])*61++<..>><.-.>->
03:58:09 <EgoBot> Score for Lymia_darwin-454-7: 12.1
03:59:12 <quintopia> Lymia: what's the command for checking out the bfjoust?
04:00:09 <quintopia> i'm sure it's in gregor's hg repos somewhere but i don't know anything about hg
04:09:15 <Lymia> !bfjoust darwin-507-0 >((----<--->--->-)*5><..<<-<><.<--)*3>+.-+><++.>.>.++..>--.>>>-<(>(-)*1[+])*60++<..><<+-.>->
04:09:22 <EgoBot> Score for Lymia_darwin-507-0: 14.6
04:13:35 -!- poiuy_qwert has quit (Read error: Connection reset by peer).
04:15:16 -!- poiuy_qwert has joined.
04:20:03 <quintopia> okay, got the executable and the hill downloaded...maybe it won't take as long now
04:20:07 <Lymia> quintopia, oh, I forgot to ask.
04:20:10 <Lymia> What language are you using?
04:20:24 <quintopia> to make it a fair battle of wits, what size generation are you using?
04:21:01 <Lymia> I would use more if it wasn't so expensive to battle the bots agienst eachother.
04:22:35 * pikhq cleans the live autotune out of his ears.
04:24:59 <pikhq> Would it kill them to get *competent* musicians for a broadcast watched by a third of the country?
04:24:59 <quintopia> 8? wow. yeah. that's low. i'll do it that way anyway :P
04:25:34 <pikhq> Oh, wait. That would require there to be a competent and highly popular musician that's fairly recent.
04:25:37 <quintopia> pikhq: meh, it's only one third of one country, and it's the third we don't care about so...
04:25:41 <pikhq> Which ain't happening.
04:26:02 <pikhq> quintopia: I actually like football.
04:26:13 <Lymia> We are programmers!
04:26:18 <Lymia> Why would we like anything of that nature?
04:26:22 <quintopia> pikhq: watching sports on tv does not have the hacker nature
04:26:29 <pikhq> quintopia: No, no it doesn't.
04:26:32 <pikhq> quintopia: I'm weird, mmkay?
04:27:25 <pikhq> quintopia: But, anyways, Fergie should be banned.
04:27:28 <quintopia> i like watching high school football though...i just can't be arsed to care about these people who get paid millions
04:27:47 <pikhq> Lymia: Raping the ears of a third of the nation.
04:28:45 <pikhq> She couldn't even hit a note *with autotune*.
04:31:21 <Lymia> It would be a quick modification to make this evolver work for FYB.
04:33:34 -!- poiuy_qwert has quit (Read error: Connection reset by peer).
04:34:23 <quintopia> Lymia: what parameters is ./egojoust expecting?
04:34:39 <Lymia> ./egojoust [program 1] [program 2]
04:34:44 <Lymia> It's return value is the number of wins program 2 had.
04:35:04 <Lymia> It's return value is the number of times program two won minus the number of times program 1 won.
04:35:15 -!- poiuy_qwert has joined.
04:35:33 <quintopia> how do i run a program against the entire hill in /programs?
04:35:55 <Lymia> What programming language are you using.
04:36:16 <Lymia> Figure out the solution
04:36:23 <quintopia> is it not done already in some program?
04:36:24 <Lymia> There isn't a builtin function for that.
04:36:43 <Lymia> The code I wrote does target the JVM, but it's in Scala.
04:36:53 <Lymia> It also uses alot of functional programming concepts.
04:36:59 <Lymia> i.e. dosn't translate well into java at all
04:43:40 <Lymia> !bfjoust darwin-667-0 >-(----<--->--->-)*7<>+.-..<.<<-+<<->.>>>+>..-.>>+-++>-<><>.>---(>-[+])*59.++-><->..+<>-
04:43:47 <EgoBot> Score for Lymia_darwin-667-0: 18.2
04:44:01 <Lymia> !bfjoust darwin-667-7 >-(----<--->--->-)*7.>+....<.<<-+<<->.>->+>..-.>>+-++>-<><>.>---(>--[+])*59.+--><-<..<<>-
04:44:05 <EgoBot> Score for Lymia_darwin-667-7: 14.9
04:44:09 -!- azaq23 has quit (Ping timeout: 240 seconds).
04:52:38 <quintopia> found the command for running the whole tournament
04:57:15 <quintopia> well i'm gonna. beats computing scores myself :P
04:58:16 <Lymia> !bfjoust dawkings-50-0 >(-(----<--->--->-)*7<<+.<.+<..<<+-<-)*7>.>->+>.-+>>>>->+>>><.+>>>>+.->(.>-[+])*59+++.>+>>-<><-<
04:58:20 <EgoBot> Score for Lymia_dawkings-50-0: 3.5
04:58:30 <Lymia> I'm going to restart the entire sim.
04:58:37 <Lymia> And see if it comes up with something different.
05:00:45 <quintopia> annnnnnd...i'm not gonna write this program right now :P
05:01:38 -!- azaq23 has joined.
05:01:59 <Lymia> You have any idea how to?
05:02:26 <Lymia> (It's not that hard. Mine is 308 lines of code, but.. well... you're using Java)
05:03:12 <quintopia> i know exactly how i'd do it, but i already feel guilty i'm not working on that other thing
05:03:40 <quintopia> and it would be many more than 308 lines the way i conceived it
05:04:49 <Lymia> quintopia, it might have alot to do with the langauge I'm using too.
05:05:14 <Lymia> programs = select(new File(outputDir,"generation-"+i),targets,(programs map mutate) ++ programs)
05:05:40 <Lymia> This line binds the selection code, the mutation code, and handles part of preventing regressions.
05:09:42 <myndzi> ohay, i'm still second on the hill haha
05:09:51 <myndzi> though it looks like there's a new first
05:10:02 <Lymia> myndzi, I intend on pushing you off.
05:10:35 <myndzi> wow i have a lot of losses now
05:10:39 <Lymia> With the power of <s>natrual</s>artifical selection.
05:10:41 <myndzi> it used to be 100% wins or something
05:10:53 <myndzi> with the exception of wiggle or whatever but he just kept counteroptimizing and that was boring
05:11:24 <Lymia> myndzi, I'm using an evolotionary algorithm to optimize agienst the entire hill.
05:11:57 <Lymia> That's one outcome of it!
05:12:02 <myndzi> if your entries have an edit distance of like 3, i think that's a little stupid :P
05:12:25 <Lymia> I'm going run it for a night, and maybe a school day and see what comes out.
05:12:26 <quintopia> myndzi: you're actually in 3rd place now
05:12:38 <Lymia> 8 62.94 10.33 ais523_defend7.bfjoust
05:12:39 <Lymia> 19 56.86 7.50 myndzi_slowrush.bfjoust
05:12:39 <myndzi> i don't really care much though, i mean, i wrote that like years ago
05:12:41 <Lymia> That is third place?
05:12:53 <myndzi> there's only one above me?
05:13:06 <quintopia> 1st is patashu_rushpolarity, and 2nd is nescience_shade
05:13:15 <myndzi> what link are you looking at
05:13:25 <myndzi> i'm looking here -> http://codu.org/eso/bfjoust/report.txt
05:13:27 <quintopia> a report i generated myself on my own machine
05:13:34 <myndzi> well i'm nescience too
05:13:37 <quintopia> from the files on the hill at present
05:13:42 <myndzi> and patashu's is just mine but reversed
05:13:55 <myndzi> +s for -s and vice versa
05:14:04 <myndzi> he kept submitting "polar" opposites of existing entries
05:14:16 <myndzi> actually i don't know if i wrote 'rush', maybe rushpolarity is different from slowrush
05:14:59 <myndzi> well, polarity shouldn't matter anymore
05:15:04 <myndzi> the program tries programs both ways
05:15:08 <myndzi> against all starting positions
05:15:15 <myndzi> so every combination and one simple alteration
05:15:18 <Lymia> !bfjoust cirno (>+)*10([-]+>)*20
05:15:22 <EgoBot> Score for Lymia_cirno: 10.5
05:15:23 <myndzi> rushpolarity does look different from slowrush
05:15:29 <myndzi> i don't remember if i wrote rush though or not haha, it's not on there anymore
05:15:30 <Lymia> Was it submitted because of that person?
05:15:47 <myndzi> most of the entries took on the same appearance after a while
05:15:56 <myndzi> and really to win you just rearranged until you got wins
05:15:59 <Lymia> !bfjoust cirno (>+>-)*5([-]+>[+]->)*5
05:16:00 <myndzi> then someone else did the same
05:16:15 <Lymia> !bfjoust cirno (>+>-)*5([-]+>[+]->)*10
05:16:17 <myndzi> i'm not surprised defend7 is on top, because i don't think any of the entries are new
05:16:28 <EgoBot> Score for Lymia_cirno:
05:16:29 <myndzi> though defend had a unique strategy
05:16:36 <myndzi> compared to the rest of the hill at the time i remember playing it
05:16:39 <Lymia> myndzi, it tried to make rushes fall off the edge, no?
05:16:51 <myndzi> the original one basically sat on its own flag
05:16:55 <myndzi> and decreased it repeatedly
05:16:59 <myndzi> so that it couldn't be put to 0 in one turn
05:17:06 <myndzi> something like that anyway
05:17:12 <myndzi> and then it got more complex
05:17:24 <myndzi> like, in the later ones he tries to detect the speed of decrementing of whatever is attacking
05:17:29 <myndzi> so as to optimally defend against it
05:17:45 <EgoBot> Score for Lymia_cirno: 0.0
05:17:59 <myndzi> he used a tripwire on the original one, and people began 'jumping' over the first thing they encountered instead of zeroing it
05:17:59 <quintopia> it's not that intelligent as to how to increase its own
05:18:04 <myndzi> that kind of thing went back and forth for a while
05:18:10 <quintopia> it just does (+)*128 every now and then
05:18:22 <myndzi> yeah, it probably wasn't worth the effort of what i mentioned
05:18:22 <quintopia> while going through the board and zeroing everything else
05:18:41 <myndzi> anyway, he got the constants right for the current hill makeup
05:18:48 <myndzi> and it probably works well against simple programs too
05:18:48 <Lymia> !bfjoust cirno [](+)*128(>+>-)*5([-]+>[+]->)*10
05:19:01 <myndzi> but all the defend ones could be countered fairly simply if you did it specifically against them
05:19:04 <Lymia> myndzi, so, optimize until everything else drops?
05:19:06 <myndzi> wiggle wound up being quite an interesting program in how it worked
05:19:11 <EgoBot> Score for Lymia_cirno: 5.6
05:19:11 <myndzi> haha basically that's how it went
05:19:15 <myndzi> not as robust as like, corewars
05:19:24 <Lymia> Not as bad as FYB.
05:19:26 <myndzi> if you take the best few programs
05:19:30 <myndzi> you could make any of them be on top
05:19:46 <myndzi> so i guess a better gauge of "goodness" is if it can stay on against a wide variety
05:19:49 <quintopia> so you think that there can never be a tomcat in bfj? it'll always be people building programs to specifically counter other programs and no one will ever be on top?
05:19:53 <myndzi> which is why spam annoys me
05:20:01 <quintopia> maybe they should get rid of the hill idea
05:20:06 <myndzi> well, you don't exactly "specifically counter"
05:20:10 <quintopia> all programs survive even if they suck
05:20:17 <myndzi> but the way to make your program win is just to adjust the constants a little
05:20:25 <myndzi> so that you get a set that wins against all the bots on the hill
05:20:36 <myndzi> then new ones come on and you start to lose if they are good
05:20:46 <myndzi> and usually whoever puts it up on the hill is doing the same thing - optimizing it to win
05:20:49 <quintopia> so it'd be better without the hill right?
05:20:57 <myndzi> i don't know, what would you use in its place
05:21:04 <myndzi> like i said, it seems that the programs mostly took the same shape
05:21:13 <myndzi> i think defend is an exception, and probably also wiggle
05:21:17 <myndzi> it's been so long i don't remember well
05:21:28 <myndzi> i guess what i'm saying is that the logic of the program doesn't play an important enough role
05:21:35 <myndzi> you can't get a program that will always win by using only better logic
05:21:39 <myndzi> the game is too simplistic
05:21:56 <Lymia> Corewars has the SPL instruction.
05:21:58 <myndzi> so basically, if you keep this up lymia
05:22:04 <myndzi> you're just gonna spam everything off
05:22:04 <Lymia> How would something similar work on BF Joust.
05:22:08 <myndzi> and it won't even be partially interesting
05:22:08 <nrkn> Anybody know of a high-level esolang with an emphasis on terseness? ie. get a lot done in very little chars, sorta opposite of brainfuck, get a little done in a shitload of chars. Also hi :) Just asking because I'm writing one
05:22:17 <myndzi> because you'll just wind up with a bunch of extremely similar programs each that is slightly different
05:22:34 <myndzi> eventually you'll hit a group that trumps the top ones and that "species" will take over
05:22:37 <myndzi> that's what i think will happen anyway
05:22:53 <Lymia> I wrote an evolover because it seemed intresting.
05:22:55 <Lymia> quintopia, make a new 'thread'
05:23:07 <Lymia> It would alternate through the threads every tick.
05:23:07 <myndzi> Lymia: yeah, i'm just suggesting you stop spamming the hill with the results
05:23:14 <myndzi> at least when they are very similar variants
05:23:21 <quintopia> i think fyb should have gone that rout
05:23:21 <myndzi> thank you, that is kind :)
05:23:26 <nrkn> Lymia: Haha yeah perl, mine is terser :)
05:23:31 <nrkn> Looking at golfscript now
05:23:36 <Lymia> quintopia, FYB had a big screwup.
05:23:55 <Lymia> It's worse than that.
05:24:04 <Lymia> If you eliminate each ! in the enemy code.
05:24:06 <Lymia> They're sitting ducks.
05:24:11 <Lymia> Let that sink in for a moment.
05:24:34 <Lymia> You can directly target a bot agienst another.
05:24:37 <Lymia> And expect very good results.
05:26:07 <quintopia> so did you ever read that paper where they created a language and a self-replicating program and put it in a limited memory buffer, then added mutation, and let the programs copying themselves serve to handle natural selection (implicitly selecting for space efficiency and maintaining control of the cpu)
05:26:10 <Lymia> myndzi, I guess "once every 100 generations" would be spam?
05:26:16 <nrkn> OK golfscript works quite a lot like mine except it's still a lot more verbose. Aiming for terseness/does a lot as primary feature. But I'm going to play with it a bit more, probs a lot I can steal
05:26:21 -!- sftp has joined.
05:26:43 <Lymia> quintopia, sounds kinda like CoreWars.
05:27:07 <Lymia> Except it's an orgy.
05:27:11 <quintopia> i think they language they used would make a great battle language
05:27:11 <myndzi> Lymia: eh, i don't know. with human written code you can tell when it's a different intent
05:27:16 <myndzi> maybe you should check edit distances :P
05:27:46 <Lymia> I don't expect the general method to change once one has set in, at least without massive amounts of time.
05:27:57 <Lymia> I expect this general method to be a rush
05:28:00 <myndzi> that's kind of what i think too, which is why i said something about it
05:28:11 <myndzi> but you know, it's not like anyone plays the hill, i just thought it would be unfortunate to see it become all one t hing
05:28:51 <Lymia> What the crap is this?
05:28:52 <quintopia> myndzi: how about a random tournament instead of the hill. each new program plays a random subset of ALL programs ever submitted, and an average score for each program is maintained over time?
05:29:04 <Lymia> Yet it has something to the effect of decoy making?
05:29:53 <quintopia> myndzi: that way you cannot target specific programs and try to beat them, because you don't know who you'll be playing
05:30:35 <Lymia> myndzi, that would have the effect of making a decoy, no?
05:30:36 <myndzi> is that a program on the current hill?
05:30:45 <Lymia> If the initial cell wasn't 0.
05:31:00 <Lymia> I killed off the last batch.
05:31:39 <myndzi> well yeah, it wouldn't win unless the other program ran off the edge
05:31:48 <Lymia> It's optimal among the programs.
05:31:51 <myndzi> your flag starts at 128, so it wouldn't do anything really?
05:31:56 <myndzi> which actually makes sense
05:32:01 <myndzi> since you don't lose if you run out of code
05:32:04 <myndzi> you just don't do anything
05:32:13 <myndzi> the other programs are just killing themselves
05:32:53 <myndzi> quintopia: i don't like the random thing because really, it's just gonna noisy up the results; maybe just make an infinite hill
05:33:10 <myndzi> i'd think that would have the effect at least of logic triumphing over specifics
05:33:15 <myndzi> 'cause it could have lots of variants ;P
05:33:27 <myndzi> true enough, but random sampling? not everyone's gonna get something good lol
05:33:45 <Lymia> Main issue I see with my current code is that only one strain is in the system at one time.
05:33:54 <Lymia> I have no clue how to fix this.
05:34:10 <myndzi> i probably don't even belong in this channel ;)
05:34:18 <myndzi> in fact i started idling because i was here from bf joust haha
05:34:25 <myndzi> which i learned about from impomatic in #corewars
05:34:27 <quintopia> myndzi: over time it'll all even out though
05:34:43 <myndzi> yeah, after each program has played almost everything, which is basically "infinite hill" anyway
05:34:58 <quintopia> no, each program will never play everything :P
05:35:11 <myndzi> given a long enough time, it will!
05:35:20 <quintopia> they only get an opportunity to play new programs after they are first entered
05:35:45 <myndzi> so if you submit a program after a good one you don't have to play it? o_O
05:36:17 <quintopia> but it will over time get higher scores than you anyway because it's better
05:36:49 <myndzi> i forget what the length range on bf joust is
05:36:57 <myndzi> 10 to 40 or something?
05:37:13 -!- nrkn has quit (Quit: Page closed).
05:37:14 <myndzi> ok, so that's 44 runs per pair
05:37:25 <myndzi> corewars hills run way more than that, and isn't there an infinite corewars hill?
05:38:26 <myndzi> i guess the biggest difference is that corewars players uhh.. spend a lot of time on one submission and enter it
05:38:26 <quintopia> it takes like 3 or 4 seconds already to run the current hill size
05:38:30 <myndzi> rather than submit like 20 variants
05:38:36 <quintopia> which means...16 seconds if you double the hill size
05:38:59 <quintopia> is there still cw activity these days?
05:39:13 <myndzi> i did see a couple new guys who got into it
05:39:23 <myndzi> it's a land of diminishing returns
05:39:31 <myndzi> i like the game but doing anything fun doesn't really net real results
05:39:45 <myndzi> it seems the only way to do that is to do boring things
05:39:57 <myndzi> and i have little enough motivation to spend that it's infeasible for me to really participate ;)
05:40:14 <Lymia> One thing I could do is to completely scamble a program every once in a while.
05:40:27 <Lymia> Given that there's a small chance that it comes out different, but still workable.
05:40:41 <myndzi> i don't really know, i have little experience with evolvers
05:40:47 <myndzi> the code is so dependent on position though
05:40:58 <myndzi> completely scrambling a program would certainly ruin it
05:41:06 <myndzi> besides brackets not necessarily matching up etc.
05:41:14 <Lymia> Scrambling to mean means running the mutation routine on it a few times.
05:41:15 <myndzi> i don't know how i would approach this
05:41:32 <Lymia> Basicly scrambling it enough to maybe get it out of a local minima.
05:41:33 <myndzi> well don't most genetic algorithms do something like
05:41:34 <Lymia> With enough time that is.
05:41:48 <myndzi> populate the pool with mutations of the best N, and also some random ones?
05:41:51 <Vorpal> <elliott> Please tell me I don't have to saturate or something. <-- iirc you do for input!
05:42:10 <Lymia> myndzi, that's a horrible idea.
05:42:39 <myndzi> it starts out randomly yeah?+
05:42:42 <Lymia> You know how the sim always seems to start out, right?
05:42:47 <myndzi> so you just keep throwing randoms into it?
05:43:01 <myndzi> on the off chance you get something worthwhile and fresh
05:43:22 <Lymia> Phase 1) Which one manages to live the longest before killing itself.
05:43:37 <Lymia> Phase 2) Programs with [] or something similar sticking it in one place
05:43:44 -!- p_q has joined.
05:43:54 <Lymia> Phase 3) Programs getting better and better at rushing the enemy flag
05:44:09 <Lymia> (And setting decoys I guess)
05:44:23 <myndzi> i don't know how you would evolve something like defend, haha
05:44:41 <myndzi> so then, keep running from phase 1 and when you get something phase 3-worthy, mix em up
05:44:57 <Lymia> [+] on your home cell
05:45:01 <myndzi> no, i mean the Defend series of programs
05:45:07 <myndzi> which behave in some pretty specific ways
05:45:18 <Lymia> If that is set up, and works, it might start expanding on the idea...
05:45:23 <Lymia> Then die out because it beats all the rushers.
05:45:45 <myndzi> you're the one writing an evolver, not me ;)
05:45:47 <myndzi> i'll take your word for it
05:46:04 <Lymia> It might work better with a larger hill.
05:46:11 <Lymia> But I'm battling everything agienst everthing.
05:46:18 <Lymia> That's O(n^2) to hill size.
05:46:28 <myndzi> nobody ever claimed evolution was fast :)
05:46:37 -!- poiuy_qwert has quit (Ping timeout: 240 seconds).
05:46:45 <Lymia> Well, evolotion is counted in generations.
05:48:48 <myndzi> you might try evolving simple units and concatenating them, actually
05:48:56 <myndzi> or, defining simple units
05:49:06 <Lymia> 5376 battles per generation.
05:49:14 <Lymia> myndzi, in Brainfuck?
05:49:19 <Lymia> Would work better in FYB or CoreWars.
05:49:38 <myndzi> the programs i wrote tended to have separate distinct sections
05:49:39 <Lymia> The modules wouldn't fit together.
05:49:50 <Lymia> Depends on how you do it guess.
05:49:54 <myndzi> sometimes looping through them all etc.
05:50:04 <Lymia> If you define it as three seperate program segments [start][middle][end] or something, it could work.
05:50:08 <myndzi> but i mean things like [-] or >+*(10) and whatever
05:50:20 <Lymia> myndzi, those ould be made pesudoopcodes.
05:50:30 <Lymia> [-] and [+] in particular.
05:50:51 <myndzi> i just mean that there are some simple strategies that work against simple opponents
05:50:57 <myndzi> and they can be incorporated into more complex strategies
05:51:31 <myndzi> also i am thinking about the interpreter and if it ever wound up implementing my solution for the * loops
05:51:36 <myndzi> so that it didn't have to expand things
05:51:44 <myndzi> maybe there are some slow programs in your hill
05:51:54 <Lymia> 15 times longer time per generation.
05:51:56 <myndzi> i sorta forget how it all worked anymore
05:51:56 -!- p_q has changed nick to poiuy_qwert.
05:52:00 <Lymia> I'll leave it on for a long time though.
05:52:02 <Lymia> Hopefully this changes things.
05:52:17 <myndzi> but speeding up the interpreter would probably be a good idea for you if you want to run lots of battles
05:52:34 <myndzi> can you tell if it expands all the programs in memory before running them?
05:53:25 -!- Mathnerd314 has quit (Remote host closed the connection).
05:53:52 <myndzi> ah, never got implemented then
05:54:02 <myndzi> what about the ones you are fighting against
05:54:09 <myndzi> or you are just running evolved vs evolved right now
05:54:20 <myndzi> so i guess it's a moot point
05:54:32 <myndzi> you don't really need to evolve ({}) anyway
05:54:32 <Lymia> egojoust is a C program, compiled to native code
05:54:43 <Lymia> My evolver is a Scala program, compiled to Java bytecode.
05:54:47 <Lymia> Figure out how that works.
05:55:29 <myndzi> obviously both should be rewritten in brainfuck
05:55:33 <myndzi> and compiled to the game of life
05:55:41 <Lymia> I just had an amusing idea.
05:56:25 <Lymia> Start the evolver... with the hill programs as the starting state.
05:57:36 <myndzi> that's only a good idea if one of my programs evolves to be the ruler
05:58:38 <Lymia> private val numPrograms = 32
05:58:45 <Lymia> I should make this 1024 and have it be real life evolotion speed.
05:58:59 <Lymia> Hopefully this isn't a completely bad idea.
05:59:53 <Lymia> By my cacluations, each generation should now be 15 times or so longer than before.
06:00:00 <Lymia> Hopefully I didn't underestimate.
06:03:01 <Lymia> [] popped up in /one generation/
06:03:04 <Lymia> Looks like it was a good idea.
06:04:38 -!- azaq23 has quit (Quit: Leaving.).
06:06:38 <quintopia> what is the return value of var*=2?
06:07:35 -!- asiekierka has joined.
06:20:39 <Lymia> It's identical in meaning to var = var * 2
06:21:27 <Lymia> It seems to act exactly identical to var = var * 2
06:21:32 <Lymia> Therefore, it should return var * 2
06:22:34 -!- TLUL|afk has quit (Quit: *disappears in a puff of orange smoke*).
06:33:51 <Lymia> !bfjoust i_would_rather_kill_myself []<
06:34:13 <EgoBot> Score for Lymia_i_would_rather_kill_myself: 5.6
06:34:36 -!- poiuy_qwert has quit (Read error: Connection reset by peer).
06:35:26 <EgoBot> Score for quintopia_____: 0.0
06:36:11 -!- poiuy_qwert has joined.
06:41:52 -!- asiekierka has quit (Ping timeout: 240 seconds).
06:43:30 -!- nrkn has joined.
06:45:04 <nrkn> So I looked at golfscript, what other langs are good for golf? Making my own, some good stuff in golfscript but I feel can be improved upon for terseness. Au fait with lisp, perl etc., still too verbose. Also trying to do something that's reasonably mnemonic, ie short but not toooo cryptic
06:47:46 <fizzie> There's goruby, but that's I guess mostly just a identifier-shortened Ruby.
06:48:25 <nrkn> J seems like a terrible thing to google haha. I'll try esolang first?
06:48:36 -!- oerjan has joined.
06:48:38 <nrkn> And goruby. Know a bit of Ruby
06:48:50 <nrkn> OK FlogScript, will look at
06:50:06 <quintopia> z80 also seems to result in small bytecodes for a lot of things :P
06:51:07 <fizzie> http://golf.shinh.org/lranking.rb may give some sort of a golfability indication, though I think it's more about language popularity.
06:51:36 -!- asiekierka has joined.
06:52:06 <fizzie> Would be more useful if it were sorted by the "Avg." column.
06:52:59 <quintopia> i feel like people use the best language for each problem
06:53:06 <quintopia> and don't use it if it's gonna be long
06:53:50 <fizzie> Well, or alternatively choose only moderately popular languages and take the set of problems solved in all of them.
06:54:49 <quintopia> some people just always use the same language tho
06:55:01 <fizzie> I always just use Befunge. :p
06:55:29 <nrkn> Yeah if it's a matter of how many chars you use measured in bytes you have so many operators available where in unicode it's only one byte, provided you use the letter chars (including accented etc) as vars, and then mapping the most common symbols to operators
06:55:34 <quintopia> how is the size of befunge determined? non-whitespace?
06:55:51 <nrkn> But it has to be reasonably high level to get a lot done, definitely not the case with brainfuck etc.
06:56:01 <fizzie> At least at anagolf it's determined like the others, which means it's a very bad idea to leave whitespace at the beginning of lines.
06:56:14 <Lymia> Generation 12 running.
06:56:17 <quintopia> oh so all whitespace is significant?
06:56:19 <Lymia> God a hill size of 32 is slow.
06:56:32 <Lymia> I'm supposed to be.
06:56:39 <fizzie> quintopia: All bytes count, even the terminating newline if you sillily leave one in.
06:56:45 <nrkn> I don't use whitespace at all except that newlines are equiv to statement terminators, also semicolons, all whitespace ignored except in string literals
06:56:54 <quintopia> Lymia: find someone to cuddle you to sleep eh?
06:57:04 -!- zzo38 has joined.
06:57:16 <Lymia> I'm not even in college yet. Extrapoliate from that why I'm supposed to be asleep.
06:57:20 <zzo38> Have you ever heard of Purple Motion of Future Crew?
06:57:56 <zzo38> Purple Motion is a single person who is part of the group Future Crew.
06:58:35 <zzo38> Using .MOD and .S3M formats, mostly.
06:58:54 <fizzie> I don't think Future Crew does really anything nowadays.
06:59:11 -!- asiekierka has quit (Ping timeout: 260 seconds).
06:59:17 <fizzie> They made Second Reality, it's pretty famous.
07:00:57 <fizzie> They also made Scream Tracker itself.
07:01:21 <fizzie> It's a demoscene group. Well, "was".
07:01:32 <zzo38> Yes I know they made Scream Tracker.
07:01:48 <fizzie> I was just trying to think about what they'd be known for.
07:03:03 <nrkn> I guess my goals are a) terse, b) high level, c) mnemonic. I mean, you could just look at the classes of problems that are most commonly solved and map value types and operators to unicode chars according to most used, but it would be really hard to remember how to do anything, so the mnemonic part is important
07:03:03 <fizzie> This was in 1993; it was for DOS.
07:03:20 <fizzie> And it's the tracker .s3m is the format of.
07:03:25 <zzo38> Yes I have heard of the demo
07:03:45 <quintopia> yeah i don't really follow ancient history
07:03:58 <fizzie> You're making me feel old, and I'm not even all that old.
07:04:09 <fizzie> Demoscene doesn't imply Windows anyway; we just took a look, and pouet has something like six or seven Solaris demos.
07:04:15 <zzo38> Demoscene is not always for Windows (or necessarily any other system). These demos have been written for many different systems, including NES and Pokemon Mini.
07:05:16 <nrkn> Interesting how much demoscene stuff in the last (x) years has relied on OS API calls though
07:05:17 <pikhq> Isn't the demoscene *older* than Windows?
07:05:34 <pikhq> nrkn: Just certain forms of demos.
07:05:48 <pikhq> nrkn: You can still find stuff like, say, C64 demos.
07:06:17 <quintopia> zzo38: it pretty much implies windows nowadays tho. i had thought we were talking about a modern group
07:06:21 <zzo38> Demos are still written for various old systems.
07:06:43 <fizzie> pikhq: I don't think there's an exact "starting date" for demoscene; Windows 1 seems to be from 1985, I'd say demoscene is mostly from around the same age.
07:06:54 <fizzie> quintopia: Uh, err, 27, I think.
07:07:05 <nrkn> Yeah is true. But uh what was the nice Quake, Q2ish one done in 64k? But with windows apis. kkreiger or whatevs
07:07:18 <zzo38> quintopia: No, even today, there are often a lot of other demos for other systems, including ones which are no longer in production (and sometimes (but rarely) non-existent systems).
07:07:28 <quintopia> fizzie: so you were 10 years old in 93? yeah, i'm sure that was kinda before your time too :P
07:07:30 <pikhq> quintopia: Perhaps some of the stuff *you* notice is for Windows. Probably because a lot of that is positively *stunning*.
07:07:50 <fizzie> nrkn: .kkrieger was 96k, which is a strange in-between size.
07:07:51 <quintopia> pikhq: it's the stuff that gets high traffic youtube vids
07:08:00 <quintopia> it's the stuff that wins prizes at demoscene cons
07:08:24 <pikhq> quintopia: You do realise that demoscene cons tend to be categorised by system, right? :P
07:08:39 <zzo38> quintopia: Maybe those two things are true. But demoscene is still done with many other systems too.
07:08:40 <quintopia> oh they don't have a best in show? :P
07:09:04 <pikhq> Okay, I'd imagine they also have best in show, but the point still stands that there's demos done for a lot of systems.
07:09:06 <nrkn> fizzie: Yeah they had a cool procedural texturing thing around perlin noise if I remember correctly
07:09:07 <fizzie> quintopia: Well, 1993 perhaps a bit; but DOS demos definitely weren't "before my time", though; I don't think Windows was really a serious demo platform before '98 or so.
07:09:13 <quintopia> are there still demoscene cons? didn't they run out of money? :P
07:09:40 <nrkn> Man i haven't been on irc for years, this is great
07:09:53 <fizzie> nrkn: They've released the cool procedural texturing bit (werkkzeug) for everyone: http://www.theprodukkt.com/werkkzeug_3_te
07:10:08 <zzo38> (BytePusher is such a system that has no hardware implementation, only emulators exist)
07:10:34 <fizzie> Assembly (from 1992 onwards) still gets organized, and every year people gripe about how it's all about gamers nowadays.
07:10:37 <quintopia> it would be so light and efficient
07:10:53 <pikhq> fizzie: Which is why it's now two different cons, one of which is for gamers. :P
07:11:02 <nrkn> fizzie: yeah I remember looking at that years ago but haven't for a while. carmac is big on procedural. why i'm aways impressed by his engines more than ones that look better but are hardcore manually scripted rather than procedural
07:11:26 <fizzie> pikhq: Yes, well, that's just "in theory"; there's still quite a lot of gamers in the "summer" event too.
07:11:45 <pikhq> Shame it's hard to get to most of those for me.
07:12:16 <pikhq> Damned Europe having all the *interesting* programmers.
07:12:23 <fizzie> Many other big ones are still going, I guess; at least Breakpoint, the Gathering, Evoke were organized in 2010.
07:12:29 <fizzie> And Altparty, of course.
07:12:36 <zzo38> wAMMA has sent a demo disk to Alex Papadimoulis in 2008; I looked at the files and most are DOS except one which is a .NES ROM file. In NTSC mode it executes invalid CPU instructions and crashes. In PAL mode it works.
07:12:40 <fizzie> Which is at least different.
07:12:43 <quintopia> also, i should really get a arduino(clone) and make cool shit. if only i had the willpower to get things done when i need to...
07:13:57 <fizzie> Admittedly the list of directories in http://www.scene.org/dir.php?dir=%2Fparties%2F2010/ is quite a lot shorter than in http://www.scene.org/dir.php?dir=%2Fparties%2F1996/
07:14:25 -!- augur has quit (Remote host closed the connection).
07:15:13 <fizzie> Yeah, I guess they decided not to continue.
07:16:12 <nrkn> going, you're all good quality, be back
07:17:18 <zzo38> If/when I make the new computer system (codenamed POWERXY), I might try to make a demoscene of it.
07:17:26 <fizzie> Assembly 2011 is going to be the 20th year for them, and it still has the same main organizers; wonder when they're going to get fed up. (A 20-year anniversary could be a "natural" point to stop, but they haven't at least said anything about it.)
07:17:47 -!- Sgeo has quit (Ping timeout: 240 seconds).
07:17:52 -!- augur has joined.
07:18:26 <fizzie> (The same people keep winning, too.)
07:18:40 <nrkn> fizzie: 20 years is almost nothing in history of asm tho :) sure there's life in that dog yet
07:18:43 <nrkn> seeya al anyways
07:18:44 <quintopia> they could hand it over to someone else at any time, and that's the kind of announcement you save for the event yes?
07:19:13 -!- nrkn has quit (Quit: Page closed).
07:20:01 <quintopia> "FloatingPoint - demoparty on a boat!"
07:21:24 <fizzie> That sounds a bit... hazardous. :p
07:23:39 -!- augur has quit (Remote host closed the connection).
07:25:16 -!- augur has joined.
07:34:34 -!- cheater- has quit (Ping timeout: 240 seconds).
07:35:40 -!- cheater- has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:09:17 -!- zzo38 has quit (Remote host closed the connection).
08:17:55 -!- Lymia_ has joined.
08:20:57 -!- Lymia has quit (Ping timeout: 240 seconds).
08:25:06 -!- impomatic has joined.
08:25:22 <EgoBot> Score for impomatic_simple: 9.9
08:28:49 -!- Lymia__ has joined.
08:28:58 <EgoBot> Score for impomatic_simple: 9.9
08:30:52 <EgoBot> Score for impomatic_simple: 5.6
08:31:10 <EgoBot> Score for impomatic_smile: 9.9
08:32:08 -!- Lymia_ has quit (Ping timeout: 240 seconds).
08:49:51 <Ilari> APNIC: 1 735 168 addresses (0.103 blocks) IPv4 addresses allocated/assigned this month. 1 769 480 IPv4 /48s allocated/assigned (25.75ppm of a block). Granted, there's not a lot of activity, probably because of Chinese new year...
08:50:24 <EgoBot> Score for impomatic_ink: 0.0
08:50:42 <Ilari> One would expect it to pick pace again after this week.
08:52:08 -!- impomatic has quit (Quit: ChatZilla 0.9.86 [Firefox 3.5.16/20101130074636]).
08:58:00 <Ilari> Inetcore now has X-day estimate of 1st August.
09:04:04 <Ilari> Except that the Huston prediction which it is based looks seriously buggered base on the graphs.
09:19:47 -!- maximum_yellow has quit (Ping timeout: 240 seconds).
09:21:52 -!- maximum_yellow has joined.
09:46:39 -!- oerjan has quit (Quit: Lost terminal).
10:02:53 -!- Lymia_ has joined.
10:06:06 -!- Lymia__ has quit (Ping timeout: 240 seconds).
10:13:42 -!- BeholdMyGlory has joined.
10:19:13 -!- Behold has joined.
10:19:53 -!- BeholdMyGlory has quit (Ping timeout: 255 seconds).
10:46:45 -!- BeholdMyGlory has joined.
10:47:11 -!- Behold has quit (Read error: Operation timed out).
10:57:41 -!- Lymia__ has joined.
11:00:52 -!- Lymia_ has quit (Ping timeout: 240 seconds).
11:05:51 -!- elliott has joined.
11:05:57 <elliott> 04:54:29 <Lymia> What programming language are you using.
11:06:22 -!- ais523 has joined.
11:06:24 <elliott> 05:23:25 <Lymia> quintopia, it might have alot to do with the langauge I'm using too.
11:06:24 <elliott> 05:23:49 <Lymia> programs = select(new File(outputDir,"generation-"+i),targets,(programs map mutate) ++ programs)
11:06:30 <elliott> Lymia__: you _would_ really like Haskell
11:06:42 <elliott> it's like Scala's functional parts, except even moreso
11:07:09 <ais523> also, every programmer deserves to know at least a moderate amount of Haskell even if they never use it
11:07:50 <Deewiant> elliott: Through sanity.bf without crashing yet?
11:08:10 <elliott> Deewiant: dude, i'm not even awake yet
11:08:27 <elliott> Deewiant: i realised what the problem is when i was trying to sleep and failing, though
11:08:41 <elliott> basically, if we're not at an edge, advance just gives the new coords. which can be spaces
11:08:47 <elliott> conclusion: I need nextIns like you said
11:10:19 <elliott> ais523: to explain this conversation, I've given in to the INTENSE BEFUNGE-98 FEVER.
11:10:44 <ais523> elliott: I figured that out from your talk yesterday
11:11:02 <ais523> still, it's an understandable fever, befunge-98 is atm the only practical esolang
11:11:33 <elliott> oh, it's more that the test suite and performance things Deewiant made are so hilariously comprehensive that how could you not try and win?
11:11:50 <elliott> also, uh, I'm tired of cfunge's reign of fixed-initial-size-copterror
11:11:56 <Deewiant> elliott: I expect a full pass on mycotrds by tomorrow
11:11:56 <elliott> *coupled-with-hash-map-of-slowness terror
11:12:15 <elliott> Deewiant: Actually TRDS should not be that hard considering that a tick is pretty solidly defined as an atomic action in this code.
11:12:27 <Deewiant> "TRDS should not be that hard" :-D
11:12:40 <elliott> Deewiant: LET ME LIVE IN TRANQUILITY
11:12:58 <elliott> Deewiant: I've also fleshed out a plan to do fingerprints nicely.
11:13:09 <Deewiant> Of course since you're living in Haskell-land you can just remember all old fungestates
11:13:30 <Deewiant> Wonder how much memory that would end up using
11:13:30 <elliott> No wait, that's just ContT StateT, I think.
11:13:57 <elliott> 05:23:25 <Lymia> quintopia, it might have alot to do with the langauge I'm using too.
11:13:57 <elliott> 05:23:49 <Lymia> programs = select(new File(outputDir,"generation-"+i),targets,(programs map mutate) ++ programs)
11:14:01 <elliott> Notes to time travelling ips:
11:14:01 <elliott> Usage of time travel can be very punishing on the performance of the funge interpreter. If travel is performed to the past, the interpreter must be capable of reproducing all conditions that existed at the destination time, which includes all ips, stacks, and funge space cells. Some interpreters may only store time snapshots from only so far back (The furthest point in the past that can be jumped to can be determined with the P command).
11:14:30 <Deewiant> CCBI does what I think is reasonable: it allows you to travel back up to the time when you loaded TRDS, but not before
11:14:49 <Deewiant> That way TRDS has very little performance impact unless you actually use it.
11:15:51 <elliott> Deewiant: Think I'll have a --trds-very-slow for going before that. :P
11:16:19 <Deewiant> I suppose I could add that too.
11:16:37 <Deewiant> You know, because it's an important use case.
11:17:07 <elliott> Deewiant: BTW, I expect a test for -2kabcd jumping to c in Mycology, stat.
11:17:10 <ais523> all you /actually/ need to do is store past input up to that point
11:17:20 <ais523> then, if TRDS is loaded, you can rerun the program from scratch to see what it did
11:17:36 <elliott> ais523: *</Computer Scientist>
11:17:43 <elliott> *Theoretical Computer (ok, that's the only kind)
11:17:43 <ais523> (note: Feather's name has the property that it starts with a capital F even on IRC)
11:17:49 <Deewiant> All you /actually/ need to do is store the initial state.
11:17:55 <ais523> elliott: well, that's what Feather does for /everything/
11:18:01 <Deewiant> But that's expensive, which is why it's not done at the start. :-P
11:18:31 * elliott renames the FM monad to Shiro
11:18:42 <elliott> Deewiant: Does sanity.bf use \r\n newlines?
11:19:04 <Deewiant> elliott: Run 'file sanity.bf' and see!
11:19:15 <elliott> Actually I'll just fix my parse.
11:19:46 <Deewiant> Dude, you were gone for over 9 hours, how can you be tired
11:19:59 <elliott> I spent like two of those sleeping.
11:20:09 <elliott> The others were spent being unable to sleep and thinking way more about Befunge than I wanted to.
11:20:27 <elliott> As such, I've practically got a few hours of code buffered up in my head, but am barely in any state to write it at all.
11:21:07 <ais523> am I right in thinking that a 1-counter nondeterministic Minsky machine is not just TC, but so far from TC that it doesn't even resemble it?
11:21:31 <ais523> (the "nondeterministic" bit makes it not quite obvious)
11:21:43 <elliott> -- these functions should arguably go in Shiro.Monad
11:21:43 <elliott> this is my way of telling myself that these really belong in Shiro.Monad and to move them
11:22:03 <ais523> is Shiro going to end up almost as overengineered as jettyplay?
11:22:15 <elliott> not really, I already have the basic instructions down
11:22:18 <elliott> and fungespace and all that
11:22:24 <elliott> I'm starting out really simple and stupid until I pass Mycology
11:22:27 <elliott> and only then will I optimise in any way
11:22:33 <elliott> unless I really need it to execute all of Deewiant's tests
11:22:50 <elliott> (got a rather nice typeclass system for those :P)
11:23:25 <ais523> in jettyplay, I had to start the optimisations pretty early
11:23:34 <ais523> because it used to leak enough memory to crash after a few minutes
11:23:53 <ais523> it turned out the memory leak bug was actually in the Java stdlib (arguably not a bug, but an insane restriction)
11:23:57 <ais523> but I figured out how to work around it
11:24:14 <ais523> before I discovered that, though, I'd optimised the memory usage for all the rest of the code first
11:24:22 <elliott> mergeByteString (ox,oy) fs = snd . foldl' line (oy,fs) . B8.lines . B.filter (/= ff)
11:24:22 <elliott> where line (y,fs) s = (y+1, snd $ B.foldl' (byte y) (ox,fs) s)
11:24:22 <elliott> byte y (x,fs) w = (x+1, if w == space then fs else insertFS (x,y) (fromIntegral w) fs)
11:24:30 <elliott> make this the most insane fold ever
11:25:24 <ais523> hmm, seeing that on my IRC client gives me the idea of writing code in a proportional-width font, and using all the whitespace characters in Unicode to make it line up perfectly anyway
11:25:39 <ais523> except vertical tab, because nobody seems to know what it's meant to do any more, and it's normally just interpreted as newline
11:27:37 <elliott> mergeByteString :: Vector -> FungeSpace -> ByteString -> FungeSpace
11:27:38 <elliott> mergeByteString (ox,oy) fs = snd . foldl' byte ((ox,oy),fs,False)
11:27:38 <elliott> where byte (p@(x,y),fs,lastWasCR) w
11:27:38 <elliott> | w == ff || (w == lf && lastWasCR) = (p, fs, False)
11:27:38 <elliott> | w == cr || w == lf = ((x,y+1), fs, w == cr)
11:27:38 <elliott> | w == space = ((x+1,y), fs, False)
11:27:40 <elliott> | otherwise = ((x+1,y), insertFS p (fromIntegral w) fs, False)
11:27:53 <elliott> that uses special characters to make it line up in mIRC
11:28:03 <ais523> no wonder it never seems to line up for me
11:28:12 <elliott> ais523: well, no, it's for monospaced mIRC users
11:28:14 <elliott> ais523: also, IIRC the Emacs source code has ^Ls in it
11:28:22 <ais523> elliott: those are page breaks
11:28:41 <elliott> ais523: that's still pretty crazy, though
11:28:44 <ais523> they have various semantic value in code
11:28:51 <ais523> page breaks between functions are natural, if you think about it
11:29:01 <elliott> indeed, but still quite insane
11:29:04 <ais523> and they're "whitespace", so C-like langs should ignore them
11:29:04 <elliott> I wonder what it looks like in Emacs itself?
11:29:11 <ais523> and it just shows ^L, in red
11:29:14 <elliott> "Why doesn’t this exist yet: Syntax-aware merge" helloooo, Scapegoat!
11:29:31 <elliott> (title of blog post by founder of Freenet who also does a lot of other things seemingly)
11:29:43 <elliott> "Well, just such a problem has been floating around for several years, and is as-yet unanswered. I proposed it two years ago, and others have suggested it several years before that." it's because we're all waiting for scapegot
11:29:47 <Deewiant> elliott: snd works on pairs, not triples
11:29:55 <ais523> anyway, my lecture this morning made me internally facepalm a bit
11:29:57 <elliott> Deewiant: fucking fuck >_<
11:30:06 <elliott> you can't see it, but my eyes are drooping
11:30:41 <elliott> mergeByteString :: Vector -> FungeSpace -> ByteString -> FungeSpace
11:30:41 <elliott> mergeByteString (ox,oy) fs s = fs'
11:30:42 <elliott> where (_,fs',_) = B.foldl' byte ((ox,oy),fs,False) s
11:30:42 <elliott> byte (p@(x,y),fs,lastWasCR) w
11:30:42 <elliott> | w == ff || (w == lf && lastWasCR) = (p, fs, False)
11:30:42 <elliott> | w == cr || w == lf = ((x,y+1), fs, w == cr)
11:30:44 <elliott> | w == space = ((x+1,y), fs, False)
11:30:48 <elliott> | otherwise = ((x+1,y), insertFS p (fromIntegral w) fs, False)
11:30:50 <elliott> even supports \r<FF>\n as two newlines, I think
11:31:02 <ais523> to start with, they were showing code samples on a projector, but the interesting part is that the projector was connected to a Mac laptop, connected via a wireless network to two levels of ssh -X (one to get inside a firewall, one to get to the actual target machine which was just one of the machines in the undergraduate computing labs) and used to run xterm
11:31:19 <elliott> N-tuples: the quick-and-dirty state monad!
11:31:21 <ais523> just so that the code would work exactly the same way as it did for the undergrads
11:31:57 <elliott> ok, now to move things outside of Interpreter.hs
11:32:01 <elliott> then write nextInsPos / goToNextIns
11:33:07 <ais523> then, actually using the terminal, there were similar insanities
11:33:15 <ais523> the most minor was using control-Z followed by bg to exit less
11:33:34 <ais523> (control-Z on less can make sense, but not this time, as the same file was immediately opened in an editor; bg on less can't)
11:34:07 <ais523> and then the rest of the session he put & on everything but make and running the resulting executables, to background it
11:34:14 <ais523> including cd, which of course doesn't work very well backgrounded
11:34:16 <elliott> "that would depend on how you define 'proprietary'. I consider the GNU ecosystem code lock-in to be a form of proprietary (since the BSD's, anything under MIT, Illumos, etc can't take advantage of it)"
11:34:27 <elliott> every fucking time on /r/programming someone mentions that the gpl is Free in any way
11:34:28 <ais523> elliott: they can, by converting to GPL
11:34:58 <elliott> I even basically agree with them but they're all annoying [expletive]s about it >_<
11:35:03 <ais523> elliott: it's interesting hearing that from someone who thinks BSD > GPL, anyway
11:35:22 <ais523> btw, I wonder what would happen if someone made a career about making GPLed improvements to BSDed code?
11:35:29 <elliott> I think the GPL is perfectly Free, I just don't use it myself, and therefore dislike GPL libraries because I can't use them at all
11:35:39 <elliott> ais523: probably the FSF would love them and the projects would hate them
11:35:44 <ais523> and if the people who owned the BSDed code complained, said that their license was specifically designed to let them do that?
11:36:18 <ais523> I'm a little annoyed because I often end up choosing GPLv2 out of practicality (existing libraries, and not annoying GPLv3 haters)
11:36:26 <ais523> even though it's a crazy license in that it has known bugs
11:36:35 <ais523> which people have taken to be features, somehow
11:36:39 <elliott> ais523: If I was satisfied with my software before and someone releases an improved version under an incompatible license, it doesn't really matter
11:36:45 <elliott> I'm almost certainly going to be able to implement the same improvements
11:36:52 <ais523> elliott: in that case, BSD possibly is the right license for you
11:37:01 <elliott> And I don't really code for having the perfect piece of software, anyway, fun takes priority usually.
11:37:42 <elliott> ais523: it's like when a third-party seller started selling Mark Pilgrim's Creative Commons-licensed-but-traditionally-published book, without giving him any of the money, he just wrote a blog post about it saying he didn't care :-P
11:38:06 <ais523> indeed, and I don't even see why he should
11:38:06 <elliott> Deewiant: Weird how the only comparison functions are z and `.
11:38:30 <ais523> it's like Red Hat publishing my improvements to the Nibbles AI
11:38:31 <elliott> Deewiant: Those aren't really comparisons. :P
11:38:52 <ais523> (although, only as part of a mass import of other things, really)
11:39:00 <Deewiant> -| is like checking for equality.
11:39:17 <elliott> AESTHETICALLY PLEASING, TOO!
11:39:22 <ais523> hmm, Gnome seem not to require copyright assignment, at least I don't remember any legal papers wrt that when I submitted patches to them
11:39:27 <elliott> Deewiant: If I start talking about nested k will you run away?
11:39:35 <ais523> in fact, I don't even think I explicitly remembered to mark the patches GPL, perhaps they thought it was obvious
11:39:38 <Deewiant> No, but I won't talk about it much either
11:39:54 <elliott> Deewiant: Because I'm totally convinced that all nested ks see the same instruction, which will be a k.
11:40:06 <elliott> ...unless you change IP direction half-way through, but I'm not even going to think about that.
11:40:17 <ais523> elliott: so you think kk is /always/ an infinite loop, except if given 0 as an arg?
11:40:27 <elliott> ais523: _not_ an infinite loop
11:40:34 <ais523> ah, wait, it'd exhaust the stack eventually
11:40:53 <elliott> after five ticks, 34kk56 yields the stack "5 6"
11:41:03 <elliott> Deewiant's seems to differ, but that's because he's wrong :-)
11:41:04 <ais523> hmm, I think you're right there, actually
11:41:14 <ais523> given that k is always run at the k itself
11:41:16 <elliott> ais523: the ambiguity is easily traceable to one sentence
11:41:24 <elliott> The k "Iterate" instruction pops a value n off the stack. Then it finds the next instruction in Funge-space in the path of the IP (note that this cannot be a marker such as space or ;), treats it as an instruction, executing it n times. This takes only one tick with respect to concurrent operation.
11:41:29 <elliott> ais523: "Then it finds the next instruction in Funge-space in the path of the IP"
11:41:37 <elliott> ais523: is this the next instruction after the k, or the next instruction after the IP?
11:41:43 <elliott> because of the previous sentence
11:42:16 <ais523> wait, isn't the IP always treated as being at the k anyway?
11:42:20 <ais523> so it doesn't make any difference?
11:42:30 <elliott> ais523: because the second k
11:42:48 <elliott> does it look at the instruction to the right of the IP (itself, "k") or to the right of the k ("5")?
11:42:58 <ais523> so for kk, the question is which k has its location treated as containing the IP?
11:43:06 <elliott> ais523: apparently, Vorpal special-cases nested "k"s, which suggests to me that his interpretation is probably objectively wrong, so I'm not going to try and find out what it is :P
11:43:13 <elliott> the IP is objectively on the first k
11:43:24 <ais523> and that's true no matter what instruction you execute
11:43:25 <elliott> but the question is whether the sentence tells you to look for the first instruction after the IP
11:43:29 <ais523> e.g. ^ turns upwards from the first k
11:43:37 <ais523> so the "current k" is always the first one
11:43:39 <elliott> ais523: oh, and here's some fun for you
11:43:45 <ais523> whether it's executing ^ or k or # or whatever
11:43:47 <elliott> ais523: what happens if you change IP direction half-way through the "k"s?
11:43:52 <ais523> elliott: I'm not sure you /can/
11:44:12 <elliott> ais523: if we go by the next-instruction-after-the-k, then consider 22kk<
11:44:14 <ais523> oh, you mean like 4k] or whatever, nothing to do with nested k?
11:44:35 <ais523> elliott: "next instruction after the k" is the second k, because "the k" is always the first one
11:44:40 <elliott> with | before the thing that will be executed next
11:44:45 <elliott> ais523: erm, I mean after the current k
11:44:48 <ais523> Deewiant: what does 4k" do?
11:44:50 <elliott> "The k "Iterate" instruction pops a value n off the stack. Then it finds the next instruction"
11:44:56 <ais523> elliott: the "current k" is always at the location of the first k
11:44:59 <elliott> "The k "Iterate" instruction pops a value n off the stack. Then it finds the next instruction"
11:45:06 <elliott> Then it finds the next instruction [after the k]
11:45:11 <ais523> what location will the y command push onto the stack?
11:45:17 <elliott> ais523: no, you don't understand
11:45:21 <elliott> ais523: where the IP is might be irrelevant
11:45:22 <ais523> elliott: no, /you/ don't understand
11:45:33 <ais523> elliott: what I'm saying is, the /y is in the same position as the k/
11:45:36 <ais523> when running inside the loop
11:45:45 <ais523> say k took the command to loop from the stack, rather than fungespace
11:45:46 <elliott> ais523: the IP is where the k is
11:45:58 <elliott> ais523: an instruction at (x,y) can execute at a place that is not (x,y)
11:46:05 <elliott> this does not mean that instructions are at that location for their execution!
11:46:12 <elliott> Deewiant: tell him he's insane :P
11:46:13 <ais523> elliott: the fact that the instruction is at (x,y) is completely irrelevant
11:46:25 <elliott> "The k "Iterate" instruction pops a value n off the stack. Then it finds the next instruction in Funge-space [...]"
11:46:32 <ais523> it's as irrelevant as the fact that the instruction's at 0x12400 or whatever
11:46:47 <ais523> I need to make that look like a legitimate pointer!
11:47:29 <ais523> what k doesn't do is cause the instruction to run itself displaced, somehow, but remembering where it is in fungespace
11:47:36 <ais523> as there's nothing in the spec that implies that that makes sense at all
11:47:43 <ais523> it looks at fungespace to see which instruction to run
11:47:49 <ais523> not "which instruction and its location and all its metadata"
11:47:55 <elliott> stop and try and understand the alternate position for a second
11:48:16 <elliott> rather than defending your interpretation because of the tautological "it's what the spec says!"
11:48:23 <elliott> "The k "Iterate" instruction pops a value n off the stack. Then it finds the next instruction in Funge-space [...]"
11:48:30 <elliott> ais523: consider this sentence
11:48:33 <ais523> the alternate position is, I suppose, that instructions intrinsically memorise where they are in fungespace, so that if you run them indirectly, via k or an eval fingerprint or whatever, they remember where they were just to make the definition of k ambiguous
11:48:40 <elliott> ais523: We take an instruction. Then we take the next instruction, in the path of the IP.
11:48:52 <elliott> ais523: to me, the latter sentence could _easily_ be referring to the next instruction after the _first one_ in the path of the IP
11:48:55 <ais523> where's the "we take an instruction"
11:49:01 <ais523> you're implying that into the spec, it doesn't say that at all
11:49:12 * elliott bashes his head into the brick wall that is ais523.
11:49:13 <ais523> the spec says what k does, not what k at (5,10) does
11:49:32 <elliott> ais523: some instructions in Funge-98 make no fucking sense and require pieces of state that no other part of the language does
11:49:37 <elliott> this should not surprise you.
11:49:43 <ais523> it's defining the concept of k instructions (think class in OO programming), not a specific k instruction individually (think object in OO programming)
11:49:44 <elliott> and it's not a reason to discount an interpretation
11:49:55 <ais523> I'm just reading the plain language of what it says
11:49:55 <elliott> the fact that doing it that way is insane is irrelevant
11:49:59 <elliott> the question is what the spec literally says
11:50:02 <elliott> which is ambiguous in this instance
11:50:10 <ais523> hmm, what are instructions defined /as/?
11:50:36 <elliott> All standard instructions are one character long and range from ASCII 32 (space) to ASCII 126 (~). There are no multicharacter instructions in Funge.
11:50:41 <elliott> ais523: it tells you a lot of things about instructions
11:50:44 <elliott> but not what an instruction actually is
11:50:47 <elliott> An instruction is executed by an IP every tick. The IP executed is the one at the current position of the IP. Only after that does the IP moves by its delta to a new position.
11:51:11 <ais523> hmm, why is the funge-98 spec not linked from the wiki?
11:51:23 <ais523> elliott: they range from 32 to 126
11:51:28 <ais523> do any of those numbers contain position metadata?
11:51:55 <elliott> Where the k is is part of execution state, not instruction state. The specification creates plenty of tracking of additional state without explicitly stating that it is doing so.
11:52:03 <ais523> elliott: you can't claim that "instruction" includes "position in the source"
11:52:06 <elliott> It does so with off-hand notes, e.g. fields of y that require whole-interpreter tracking to satisfy.
11:52:25 <elliott> The spec is incredibly ambiguous and you're basically saying "don't be silly, that would require things to be insane to make sense", but they _are_.
11:52:26 <elliott> ais523: http://catseye.tc/projects/funge98/doc/funge98.html
11:52:48 <ais523> what I'm saying is, that "next instruction" can't have an implied "after the original position in the fungespace that that copy of the instruction was copied from", because "instruction" is specified not to include that data
11:53:14 <elliott> Deewiant: I'm actually curious to the answer to ais523's question, what does 5k" do?
11:53:33 <elliott> Deewiant: also, /please/ tell me that "hello;bar;quux" is the same as "helloquux"
11:53:45 <elliott> Deewiant: i fucking hate stringmode. :)
11:53:46 <ais523> Deewiant: but what does being in stringmode do to the subsequent "s?
11:53:56 <ais523> as in, does it cause them to quote themselves? or to toggle stringmode?
11:53:57 <elliott> ais523: in stringmode, " still toggles stringmode
11:53:57 <Deewiant> In stringmode, " turns off stringmode.
11:54:24 <ais523> hmm, doesn't b98 have a quote-one-char command? ' or something like that?
11:54:42 <elliott> There is also a ' "Fetch Character" instruction in Funge-98. This pushes the Funge character value of the next encountered cell (position + delta) onto the stack, then adds the delta to the position (like #), skipping over the character (in no ticks). For example, the following two snippets perform the same function, printing a Q:
11:54:45 <ais523> so 5k' is similarly interesting
11:54:55 <elliott> I think there's a note about k' in the Mycology readme.
11:54:57 <ais523> and you've even got a definition of "next encountered cell" there
11:55:16 <elliott> Deewiant: What does k' do.
11:55:17 <ais523> it's also an insane one
11:55:28 <elliott> ais523: except for not wrapping
11:55:30 <ais523> elliott: it doesn't allow for wrapping
11:55:38 <ais523> what does '; do, for instance?
11:55:55 <elliott> ais523: pushes space forever
11:56:06 <ais523> I'm inclined to say "pushes 32", but that's one of the ambiguities that Mycology has as UNDEF, IIRC
11:56:09 <elliott> I love how much longer the TRDS extended spec is than the TRDS spec.
11:56:29 <elliott> ais523: a lot of Mycology actually-bads are UNDEFs to shut Vorpal up
11:57:08 <ais523> anyway, what 1k' does is clearly to push ' onto the stack at the k, and then execute the ' again (because k doesn't skip it) and push the next char onto the stack too
11:57:22 <ais523> the position+delta specification makes that completely unambiguous regardless of what k actually does, even to you
11:57:45 <elliott> ais523: hey, I *support* your interpretation of k
11:57:49 <elliott> I just think that the other one is basically as valid
11:57:53 <ais523> oh, "skipping over the character", hmm
11:58:00 <ais523> that does seem to imply position metadata
11:58:13 <ais523> so does 5k' jump 5 chars forwards? or to just after the '?
11:58:38 <elliott> the first time, the ' pushes '
11:58:41 <elliott> and therefore skips over the '
11:58:52 <ais523> yep, I think I agree with that
11:58:57 <ais523> but 2k'xy instantly becomes insane
11:59:06 <ais523> the first time, ' pushes ', then skips over the '
11:59:07 <elliott> and therefore skips over the '
11:59:11 <Deewiant> elliott: Nested k debug printfs, figure it out
11:59:19 <Deewiant> Except that you need to shut up for the pastespam
11:59:23 <elliott> skipping over the ' took one tick
11:59:33 <Deewiant> IP hit k at (2,0); moved to (3,0)
11:59:33 <Deewiant> Moved to next instruction at (3,0) and found 107
11:59:33 <Deewiant> Executing 'k' 4 times at (2,0)...
11:59:33 <Deewiant> IP hit k at (2,0); moved to (3,0)
11:59:33 <Deewiant> Moved to next instruction at (3,0) and found 107
11:59:35 <ais523> the thing is, there's a contradiction in the spec here
11:59:35 <Deewiant> Executing 'k' 3 times at (2,0)...
11:59:37 <Deewiant> IP hit k at (2,0); moved to (3,0)
11:59:40 <Deewiant> Argument is zero or negative: skipping instruction, position left as (3,0)
11:59:42 <Deewiant> IP hit k at (3,0); moved to (4,0)
11:59:45 <Deewiant> Argument is zero or negative: skipping instruction, position left as (4,0)
11:59:47 <elliott> Deewiant: I'm just asking about 5k'
11:59:47 <Deewiant> IP hit k at (4,0); moved to (5,0)
11:59:50 <Deewiant> Argument is zero or negative: skipping instruction, position left as (5,0)
11:59:52 <ais523> hmm, the location at which the k executes is not the location at which the IP is
11:59:53 <Deewiant> Done executing 'k' 3 times at (5,0)
11:59:53 <elliott> I'm trying to work out 2k'
11:59:55 <Deewiant> IP hit k at (5,0); moved to (6,0)
11:59:58 <Deewiant> Argument is zero or negative: skipping instruction, position left as (6,0)
12:00:00 <Deewiant> IP hit k at (6,0); moved to (7,0)
12:00:03 <Deewiant> Argument is zero or negative: skipping instruction, position left as (7,0)
12:00:05 <Deewiant> IP hit k at (7,0); moved to (8,0)
12:00:08 <Deewiant> Argument is zero or negative: skipping instruction, position left as (8,0)
12:00:08 <elliott> couldn't you have pastebinned that rather than doing it right as i try and trace an execution
12:00:10 <Deewiant> Done executing 'k' 4 times at (8,0)
12:00:14 <ais523> obviously, in the case of, say, 5k#
12:00:27 <elliott> <elliott> and therefore skips over the '
12:00:40 <elliott> so k looks one right of the IP
12:00:45 <Deewiant> k' is like k# except that you push the chars
12:00:53 <elliott> ais523: (that's with the k-is-based-on-IP interpretation)
12:01:12 <elliott> Deewiant: Yes; I believe your interpretation of k is wrong.
12:01:18 <elliott> although I think it's not wrong
12:01:21 <elliott> I think it's legitimately ambiguous
12:01:32 <elliott> Deewiant: [[The k "Iterate" instruction pops a value n off the stack. Then it finds the next instruction in Funge-space in the path of the IP]]
12:01:32 <ais523> elliott: k definitely remembers the instruction it's executing, based on the stack
12:01:37 <Deewiant> In the spec, it is a bit ambiguous
12:01:39 <elliott> Deewiant: does it mean the literal /next instruction in the path of the IP?
12:01:43 <Deewiant> But it's been discussed and there's consensus
12:01:44 <ais523> e.g. 5k' always runs ' five times
12:01:45 <elliott> Deewiant: or the instruction after the k?
12:01:47 <ais523> even though the IP's moving
12:01:54 <Deewiant> And we brought Pressey in on it so it's not wrong :-P
12:02:10 <elliott> Deewiant: but I don't see any justification of your interpretation, it seems less literal than mine
12:02:17 <ais523> elliott: actually, what k does is finds the next instruction and treats it as an instruction
12:02:21 <elliott> Deewiant: also, that requires special-casing k
12:02:24 <Deewiant> elliott: What part of "my interpretation"
12:02:33 <ais523> does treating an instruction as an instruction change anything about it?
12:02:34 <elliott> Deewiant: the bit where "the next instruction" means "after the k"
12:02:45 <elliott> Deewiant: then it means "after the IP"
12:02:47 <Deewiant> I was wrong and tired last time.
12:02:48 <ais523> also, the definition of k isn't actually a sentence
12:02:53 <Deewiant> The inner k finds itself, the first time.
12:02:53 <elliott> Deewiant: and since the IP is on the k for the entire duration of k execution
12:02:56 <ais523> the subordinate clauses don't nest properly
12:03:00 <elliott> Deewiant: the /first/ time?
12:03:08 <elliott> Deewiant: wait, does k move the IP somehow???
12:03:10 <Deewiant> elliott: See the execution trace I pasted.
12:03:16 <elliott> Deewiant: yes, it doesn't make any sense
12:03:34 <ais523> Deewiant: why is the inner execution moving the IP forwards each time?
12:03:35 <elliott> Deewiant: I don't want an execution trace, I want a justification of it, because as far as I can tell implementing that in my k would be non-trivial because it makes no sense at all
12:03:50 <Deewiant> The IP moves forward to get to the next cell.
12:03:53 <ais523> because all instructions move the IP forwards when executed?
12:04:08 <Deewiant> If the argument is nonzero, it finds the next instruction and executes it N times.
12:04:11 <ais523> oh, you're treating "finds the next instruction in the path of the IP" as actually moving the IP?
12:04:13 <Deewiant> If the argument is zero, it instead does nothing.
12:04:23 <Deewiant> Because 0kx is specced as skipping the x.
12:04:26 <elliott> I didn't even realise that was a valid interpretation
12:04:35 <Deewiant> It doesn't matter whether it actually moves the IP or not.
12:04:44 <ais523> Deewiant: oh, you're right
12:04:45 <Deewiant> The IP moves back before anything can tell the difference.
12:04:56 <ais523> that bit of the spec is completely contradictory to anything else in it, and I remember you complaining about it at the time
12:05:09 <ais523> so were you just trying to find an interpretation that complied with everything the spec said, somehow?
12:05:20 <Deewiant> But the thing with nested k is that when the stack runs out and you start hitting zeroes, every execution of the inner k will move the IP forward like a #.
12:05:38 <Deewiant> Pretty much, yes, that's been the idea. :-P
12:05:43 <ais523> because k, for some reason, acts like # if it pops a 0
12:05:52 <ais523> and you're treating that as a special case because the spec says so?
12:06:02 <ais523> in that case, I don't think you actually disagree with elliott in anything
12:06:11 <elliott> Deewiant: I think I've figured out why Vorpal wanted to make a new specification.
12:06:11 <ais523> other than that elliott missed one insane special case that ends up coming up quite a lot
12:06:14 <elliott> Deewiant: Because he hates FUN LIKE THIS.
12:06:28 <ais523> (that I completely forgot about)
12:06:50 <fizzie> Oh, it's k-time again?-)
12:06:55 <Deewiant> elliott: For the record, this behaviour follows from the impl "move IP; if (arg==0) return; get next instruction; move IP back; while (arg--) execute instruction;"
12:06:59 <ais523> hmm, where does the spec say that k executes at itself anyway?
12:07:13 <elliott> Deewiant: You're SO IMPERATIVE.
12:07:14 <Deewiant> There's no reason to think it moves the IP
12:07:35 <Deewiant> elliott: It matches CCBI so it was already in my head :-P
12:07:38 <ais523> but with elliott's alternative reading, it'd execute the instruction at itself, I think
12:08:03 <elliott> fungeStateWithFungeSpaceFromByteString :: ByteString -> FungeState
12:08:06 <elliott> I really need a better name for that.
12:08:10 <ais523> btw, I think I've deduced what the intended semantics of k probably were, although they contradict the spec: k transforms the next instruction temporarily into a copy of itself
12:08:37 <ais523> as in, 4k5 changes the 5 into a "push four 5s" instruction until the next time it starts executing
12:09:05 <ais523> that also has sane semantics wrt everything in Befunge, and fits the given examples
12:09:28 <elliott> seriously, rename that function X-D
12:09:39 <fizzie> I was under the impression that 1kv was unambiguously defined to start going down from the k (not the v), but I can't find it in the spec.
12:09:42 <ais523> elliott: initializeFungeStateFromString
12:10:00 <ais523> it's shorter, and just as clear
12:10:03 <Deewiant> fizzie: It's unambiguously not defined as something else
12:10:05 <elliott> ais523: (1) a ByteString is not a String in the slightest, they are two very different things, that is _not_ clear,
12:10:06 <ais523> (mostly because it's easier to parse)
12:10:21 <elliott> ais523: (3) it's initialising the fungespace _in the funge state_ from a string
12:10:38 <elliott> ais523: there are any number of items of state that could be bytestrings
12:10:39 <ais523> elliott: it's creating a new FungeState, and initialising the fungespace in it from a bytestring
12:10:57 <elliott> for comparison, the function that actually does the fungespace loading is
12:11:00 <elliott> mergeByteString :: Vector -> FungeSpace -> ByteString -> FungeSpace
12:11:03 <elliott> called with (0,0) and emptyFungeSpace
12:11:21 <Deewiant> BTW, you'll need to amend that to return the end Vector when you do i
12:11:31 <elliott> Deewiant: Easy enough, at least
12:11:36 <ais523> hmm, it could be kind-of tricky for sg to handle Befunge and Trefunge (Unefunge would be easy enough, except for possibly a need to correct jump offsets)
12:12:44 <elliott> initialFungeState{ fungeSpace = snd $ mergeByteString (0,0) emptyFungeSpace s }
12:12:48 <elliott> Over 80 fucking columns :P
12:13:10 <Deewiant> You don't need the word 'funge' in 'fungespace'
12:13:29 <elliott> Deewiant: The type is called FungeSpace :P
12:13:36 <Deewiant> You don't need to call it that :-P
12:13:43 <elliott> Deewiant: I already have :P
12:13:54 <elliott> modifyFungeSpace :: (FungeSpace -> FungeSpace) -> FM ()
12:13:54 <elliott> modifyFungeSpace f = modify $ \st -> st{ fungeSpace = f (fungeSpace st) }
12:13:54 <elliott> modifyStackStack :: (StackStack -> StackStack) -> FM ()
12:13:54 <elliott> modifyStackStack f = modify $ \st -> st{ stackStack = f (stackStack st) }
12:14:03 <elliott> how would these functions align perfectly in a monospaced font if I didn't call it FungeSpace?
12:14:07 <ais523> what's with the braces?
12:14:11 <elliott> oops, that should be Shiro ()
12:14:15 <elliott> ais523: Haskell's record system
12:14:22 <elliott> ais523: if you haven't seen it before, it's because it sucks major ass
12:14:23 <ais523> ah, it's a syntax I was unaware of
12:14:32 <ais523> is that basically "make a copy with one value changed"?
12:14:44 <elliott> FungeState { stackStack :: StackStack
12:14:44 <elliott> , fungeSpace :: FungeSpace
12:14:46 <elliott> , ip :: IP } -- TODO: Multiple IPs
12:14:57 <ais523> and laziness causes that to not be inefficient because the intermediate copies are never actually constructed
12:15:03 <ais523> as they're only accessed fieldwise
12:15:19 <elliott> ais523: Well, ostensibly. :p
12:15:56 <ais523> hmm, looking at links from the Befunge page on the wiki, I came across Spunge, which is a Scheme-subset to Befunge compiler written in Common Lisp
12:16:13 <ais523> I'm commenting mostly because who uses Scheme as an input to a Common Lisp program? that's like using vim to edit .emacs
12:16:34 <elliott> ais523: because Scheme is a tiny useless toy language good for compiling to an esolang ;-)
12:16:57 <elliott> it's clearly Yet Another Blatant Attack As Part of the Lisp Wars That Have Plagued McCarthy For A Very Long Time Now.
12:17:35 <Deewiant> Your capitalization makes no sense.
12:17:43 <elliott> "iPod touch. The perfect Valentine's Day gift." <-- Apple, you're coming really close to my "unsubscribe from spam" threshold, and that's _really_ high.
12:17:46 <elliott> Deewiant: That's what she said.
12:17:52 <elliott> Deewiant: I did it on the fly, okay :P
12:18:20 <elliott> doCharIns 'p' = do -- Doesn't work, don't know why: flip poke <$> pop <*> popVec
12:18:22 <Deewiant> What, you think an iPod is a poor Valentine's Day gift?
12:18:48 <elliott> I use :-D like 10x more when Deewiant is talking, even if he's not saying :-D.
12:18:48 <Deewiant> ?. pl undo do val <- pop; pos <- popVec; poke pos val
12:18:50 <elliott> I think my brain is broken.
12:20:02 -!- cheater- has quit (Ping timeout: 240 seconds).
12:20:21 <Deewiant> ?. pl unpl flip poke `liftM` pop `ap` popVec
12:20:21 <lambdabot> (popVec >>=) . (return .) =<< fmap (flip poke) pop
12:20:37 <ais523> oh, it lets you chain @-commands?
12:20:45 <Deewiant> ais523: I got used to typing ? at some point.
12:20:50 <elliott> Deewiant: Oh. Fix it then. :p
12:21:02 <elliott> I think join $ might fix it, but _eh_.
12:21:04 <ais523> how dare lambdabot take up two punctuation mark prefixes, there's only a finite supply
12:21:06 <Deewiant> Probably back when my keyboard required alt gr to press @, but shift for ?.
12:21:19 -!- cheater- has joined.
12:21:21 <ais523> presumably we'll have to shift to Unicode (bot prefix v6) when ASCII (bot prefix v4) runs out
12:21:37 <ais523> or move to letters, so we can have bots respond on random sentences that happen to begin with v or whatever
12:22:06 <Deewiant> elliott: liftM2 (flip poke) pop popVec
12:23:44 <elliott> Couldn't match expected type `()' against inferred type `Shiro ()'
12:23:44 <elliott> In the first argument of `liftA2', namely `(flip poke)'
12:23:44 <elliott> In the expression: liftA2 (flip poke) pop popVec
12:24:06 <ais523> IDC = I don't care, perhaps the IT was just copying ITYM?
12:24:28 <Deewiant> Oh right, lift* does a lift and not just the binary op
12:24:53 <Deewiant> @hoogle (a -> b -> m c) -> m a -> m b -> m c
12:24:54 <lambdabot> Control.Monad zipWithM :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m [c]
12:24:54 <lambdabot> Control.Monad zipWithM_ :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m ()
12:24:54 <lambdabot> Control.Monad foldM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a
12:25:25 <Deewiant> elliott: Isn't the <$> usually in the end position anyway
12:25:41 <elliott> :t \f x y -> f <$> x <*> y
12:25:42 <lambdabot> forall a a1 b (f :: * -> *). (Applicative f) => (a -> a1 -> b) -> f a -> f a1 -> f b
12:26:28 <elliott> I tend to prefer the <$><*>y way for some reason.
12:27:28 -!- BeholdMyGlory has quit (Ping timeout: 240 seconds).
12:27:33 <elliott> Now to write nextInsPos. :p
12:28:04 <elliott> Deewiant: BTW, say this line starts at (-1,0), and the IP starts at the location after the imaginary marker |:
12:28:29 <elliott> If the delta is (2,0), then after hitting the d, does the IP end up at a or b?
12:28:34 <elliott> I can kind of see arguments for both.
12:31:13 -!- cheater- has quit (Ping timeout: 240 seconds).
12:31:34 -!- cheater- has joined.
12:33:01 <elliott> # is go to next instruction, not advance, right? :p
12:33:31 <ais523> # skips one cell, not one instruction
12:33:38 <ais523> i.e. # space does the same as space space
12:34:11 <ais523> # off the edge of fungespace is vaguely insane for that reason, as it's unclear what sort of wrapping should be used
12:34:14 <elliott> What about '? The same I think.
12:35:01 <ais523> (I had to look it up to check, but it's cell-based too)
12:35:18 <ais523> so you can use # or ' to jump over a ;
12:36:18 <elliott> Couldn't match expected type `IP'
12:36:18 <elliott> against inferred type `(Value, Value)'
12:37:10 <elliott> "The name plays on the fungal theme that has attached itself to Befunge" Oh yes Deewiant, that totally wasn't a one-man crusade.
12:37:28 <elliott> (I'm just reading to see how AWESOMELY FAST my interpreter is going to be.)
12:37:37 <elliott> Deewiant: Who do we blame, then? :-)
12:37:37 -!- cheater- has quit (Ping timeout: 240 seconds).
12:37:40 <Deewiant> Fungus was the original third-party test suite.
12:38:18 <Deewiant> And now we've got stinkhorn and whatnot.
12:38:42 <elliott> He seems to have fallen of the face of the earthterwebs.
12:39:37 <Deewiant> ais523: I've come to think that # off the edge is pretty easy, just think of the program as surrounded by spaces on all sides
12:39:50 -!- BeholdMyGlory has joined.
12:39:56 -!- BeholdMyGlory has quit (Changing host).
12:39:56 -!- BeholdMyGlory has joined.
12:40:02 <Deewiant> Then # just skips one of the 2^31-ish spaces and you arrive on the other side normally
12:40:03 <elliott> Deewiant: "Think of"; it IS :P
12:40:22 <Deewiant> Well, you still need to think of it
12:40:43 <ais523> Deewiant: indeed; although arguably, the bounding box stuff in y implies that # past the bounding box should wrap
12:40:48 <elliott> http://d.puremagic.com/issues/show_bug.cgi?id=3001 <-- This issue is well attended-to
12:41:14 <elliott> what does y on positive do?
12:41:28 <elliott> The y "Get SysInfo" instruction, only available in Funge-98, pops one value off the stack. If the value is zero or negative, y tells you far more than you ever really want to know about the underlying Funge interpreter, operating system, and computer (and is thus usually followed soon after by a n instruction).
12:42:06 <elliott> I wonder what fun fun thing I can make = do.
12:42:17 <elliott> Ooh, maybe interpret it as elisp and start Emacs with it.
12:43:03 <ais523> y on positive is a pick instruction
12:43:11 <ais523> which can even pick below the sysinfo, if you can somehow work out how big it is
12:43:39 <elliott> most inefficient pick ever?
12:43:52 <elliott> 1 cell containing the number of bytes per cell (global env).
12:43:53 <elliott> aka cell size. Typically 4, could also be 2, 8, really really large, infinity, etc.
12:44:00 <elliott> I like how it states you have to put it in a cell, and then tells you it might be infinity.
12:44:16 <elliott> Deewiant: What is that team number crap anyway :-P
12:44:18 <elliott> More precisely, wtf is NetFunge.
12:44:24 -!- poiuy_qwert has quit (Read error: Connection reset by peer).
12:44:29 <ais523> elliott: I think efunge pushes -1 for bignum
12:44:31 <Deewiant> Something that never really got anywhere
12:44:38 <elliott> Deewiant: You mean like Befunge?
12:44:50 <elliott> ais523: no, clearly that's for a TURKEY BOMB Funge-98 interpreter
12:45:26 -!- invariable has joined.
12:45:36 <elliott> Deewiant: I like how it says that y can push basically anything for what = does, so long as it's in the registry. Chris should have used the tired-and-tested route of burdening IANA with handling the assignments.
12:46:01 -!- poiuy_qwert has joined.
12:46:09 <Deewiant> BeGlad is Befunge Gladiators, NetFunge I don't think I've heard anything else about
12:46:15 <ais523> elliott: isn't IANA's sole purpose to handle random assignment registries for the IETF?
12:46:34 <ais523> thus, burdening them with it is what you're meant to do, they exist to stop other people being burdened with them
12:47:11 <elliott> ais523: I bet when they gave the IPv4 space to IANA they were like "yeah, manage our toy until we get a production-ready implementation"
12:47:36 <ais523> what about DNS, though?
12:47:51 -!- variable has quit (Ping timeout: 260 seconds).
12:47:55 <elliott> The word "Befunge" started life as a typographical error for the word "before," typed by Curtis Coleman at 4AM on a BBS chat system.
12:47:56 <elliott> Was changed by User:Aardwolf (by moving the comma) to:
12:47:56 <elliott> The word "Befunge" started life as a typographical error for the word "before", typed by Curtis Coleman at 4AM on a BBS chat system.
12:47:56 <elliott> And then reverted by Graue, who suggested that Aardwolf 'leave the pedantry to those of us who know the rules'.]] --Talk:Befunge
12:47:59 <ais523> I'm not entirely clear on how ICANN vs. IANA works on that
12:48:08 <elliott> Maybe Graue should leave the pedantry to those of us who realise that the British exist.
12:48:16 -!- invariable has quit (Read error: Operation timed out).
12:48:24 <elliott> ais523: isn't ICANN controlled by IANA?
12:48:36 <ais523> that's why I said I wasn't entirely clear on it
12:48:39 <elliott> The Internet Corporation for Assigned Names and Numbers (ICANN, pronounced /ˈaɪkæn/ EYE-kan) is a non-profit corporation headquartered in Marina del Rey, California, United States that was created on September 18, 1998, and incorporated on September 30, 1998[1] to oversee a number of Internet-related tasks previously performed directly on behalf of the U.S. government by other organizations, notably the Internet Assigned Numbers Authority (IAN
12:48:39 <Ilari> Er, isn't it just the opposite way around?
12:48:55 <elliott> "The technical work of ICANN is referred to as the IANA function."
12:50:35 -!- cheater- has joined.
12:52:19 <elliott> my interpreter now goes into a loop on sanity.bf!!
12:52:26 <Ilari> Looking at IPv6 hall of shame (sites with AAAA records that just plain can't work):
12:52:53 -!- variable has joined.
12:52:53 <elliott> Deewiant: That's GREAT news!!!!!!
12:53:18 <ais523> Ilari: how does that happen? sites wanting to look IPv6 compatible?
12:54:02 <elliott> Deewiant: Oh, I see the problem.
12:54:09 <elliott> The problem is that I'm retarded, if anyone wants to know.
12:54:53 <elliott> *** Exception: ExitSuccess
12:55:42 <elliott> Deewiant: What has four legs, three arms, and hangs on mycology.b98?
12:56:23 <fizzie> ais523: Perhaps they're anti-IPv6, and want to avoid being connected by people with IPv6 connectivity. Perhaps the AAAA records contain v6 addresses full of nasty messages.
12:56:29 <Deewiant> Is it just taking five minutes to load the file?-)
12:56:38 <elliott> Deewiant: Nope, took less than a second for that, I checked :P
12:56:55 <ais523> fizzie: or INTERCAL programs
12:57:00 <elliott> Deewiant: It, uh, isn't executing instructions, though.
12:57:03 <ais523> esr was working on a spec to encode INTERCAL into IPv6 addresses
12:57:04 <elliott> My debug prints aren't running.
12:57:10 <elliott> I conclude that toNextIns is bugged or something.
12:57:16 <Ilari> Mainly addresses from 6bone range (6bone is DEAD), ULA addresses, link-local addresses, loopback, addresses in compat ranges, addresses in IETF-reserved ranges (obviously made up), etc...
12:57:19 <Deewiant> elliott: It took less than a second for it to start loading the file, but it hasn't evaluated it yet
12:57:41 <Deewiant> `seq` on something like a Map doesn't help much ;-)
12:57:45 <ais523> Ilari: hmm, do any sites have v4 addresses for loopback?
12:57:53 <ais523> and would browsers respect them if they did?
12:57:54 <fizzie> I used to have a 3ffe::/16 address.
12:57:55 <Deewiant> You need rnf or Map.size or whatever
12:58:07 <elliott> print (elems (fungeSpace st))
12:58:10 <elliott> Hmm, right, Map.size should do it.
12:58:22 <Ilari> Some do, but probably not those.
12:58:23 * elliott decides to not do it with runhaskell.
12:59:09 <fizzie> ais523: Quite a lot of "internal" zones have a A record of 127.0.0.1 for the host "loopback", to make the word "loopback" always work even if some piece of code appends a domain search suffix in. I wouldn't be surprised if some of those records would be Internet-visible too.
12:59:11 <Ilari> There's also some site that has AAAA nameservers set to ::1, which causes trouble.
12:59:24 <elliott> elliott@elliott-MacBookAir:~/Code/shiro$ ./shiro
12:59:27 <elliott> Deewiant: That's... not right.
12:59:57 <elliott> $ tr -d ' \n' < mycology.b98 | wc -c
12:59:58 <Deewiant> I don't know, sed away the spaces and wc it
13:00:16 <elliott> Okay, so it's definitely toNextIns probably.
13:00:27 <elliott> Oh wait, at the start I want "toNextInsOnlyIfIt'sASpace".
13:00:37 <Deewiant> If you'd added \r to that you might have got pretty close
13:00:39 <fizzie> The "definitely -- probably" construction, one of my favourite parts of natural languages.
13:01:15 <Deewiant> elliott: It's much handier if toNextIns can be called unconditionally :-P
13:01:33 <elliott> Deewiant: Yes, but then it'd skip over the _valid_ first instruction.
13:01:40 <elliott> Because you call it from the previous instruction.
13:01:52 <Deewiant> $ tr -d ' \f\r\n' < mycology.b98| wc -c
13:01:56 <ais523> why don't you start the IP at the end of the first line?
13:02:00 <ais523> to avoid the special case?
13:02:06 <Ilari> There are programs that use unified IPv4/IPv6 space. Disable IPv6 support on host and these just plain break (they don't need IPv6 addresses, but do need IPv6 support).
13:02:10 <elliott> ais523: It's important to manage my ticks properly.
13:02:11 <Deewiant> elliott: My toNextIns doesn't move if it's on an instruction.
13:02:20 <elliott> Deewiant: Oh, so you do "advance; toNextIns"?
13:02:25 <elliott> That... makes sense, yeah :P
13:02:28 <ais523> elliott: start the tick counter at -1, then
13:02:40 <Deewiant> Sometimes you want advance, sometimes toNextIns, sometimes both.
13:03:07 <elliott> Deewiant: BTW, ghc doesn't have -finline-functions. :D
13:03:21 <Deewiant> I was poking fun at gcc -funroll-loops.
13:03:57 <elliott> The j "Jump Forward" instruction pops a value off the stack, and jumps over that many spaces. If there is a 1 on the stack, j will work like # does. e.g. 2j789. would print 9 and leave an empty stack. Negative values are legal arguments for j, such that 04-j@ is an infinite loop.
13:04:01 <elliott> Deewiant: j can only jump over spaces, discuss.
13:04:23 -!- poiuy_qwert has quit (Read error: Connection reset by peer).
13:04:34 <Deewiant> You'd've done better pasting only the first sentence. :-P
13:04:59 -!- aloril has quit (*.net *.split).
13:05:26 <elliott> Deewiant: Mr. Fancy "Pants" FancyMcPants
13:05:52 <elliott> OK, so first instruction is 0.
13:06:02 -!- poiuy_qwert has joined.
13:06:13 <elliott> elliott@elliott-MacBookAir:~/Code/shiro$ ./shiro75489
13:06:48 <elliott> Deewiant: That's the first line of output, my terminal went all weird.
13:08:28 <elliott> At least now I have no idea what's wrong.
13:09:10 <Deewiant> The readme walks you through the start, if it's dying really early.
13:09:45 <elliott> Deewiant: I don't think that will help, I think my actual advance code is broken :P
13:09:59 -!- Behold has joined.
13:10:03 <elliott> Which is weird because sanity.bf worked.
13:10:21 <elliott> Deewiant: I should probably get stringmode soon.
13:10:33 <Deewiant> If it printed only 0, vertical movement is broken.
13:10:54 <elliott> Deewiant: Define broken :P
13:11:08 <elliott> Interesting, I... don't have ^.
13:12:06 <Deewiant> The code is, off the top of my head, something like 0#@>.1#@v followed by . in the vertical direction
13:12:20 <elliott> Deewiant: Yeah, but that isn't even the problem, I print for every instruction: this thing isn't executing more than one instruction.
13:12:31 <elliott> This thing is hanging trying to find the next instruction after it advances which for some reason leaves it on a space.
13:13:20 -!- BeholdMyGlory has quit (Ping timeout: 250 seconds).
13:13:52 <Deewiant> If you hang on 0# that's pretty impressive :-D
13:16:21 <elliott> Deewiant: Mycology is 136130 wide, right?
13:16:27 <elliott> And starts with 0 and then a bunch of spaces?
13:16:51 <elliott> I conclude that nextPos is amusingly fucked... or my loading code which I haven't even tested once, do you think it could be that?
13:17:25 <elliott> *Main> fungeStateFromByteString "ab"
13:17:25 <elliott> FungeState {stackStack = [], fungeSpace = FungeSpace (fromList [((0,0),97),((1,0),98)]), ip = IP (0,0) (-1,0)}
13:17:50 <elliott> initialIP = IP origin west
13:18:10 <Deewiant> Maybe I should've put an @ at the end of sanity.bf :-D
13:18:26 <elliott> Deewiant: That might be a good idea :P
13:18:29 <Deewiant> I guess I didn't expect you'd have working movement and wrapping but an IP that moves in the wrong direction
13:18:38 <ais523> nah, sanity.bf should really print out 7654321 if you start the IP going backwards
13:18:58 <elliott> Deewiant: It reflected because of t, it looks like.
13:19:12 <elliott> That's so amazingly perfect.
13:19:52 <elliott> Deewiant: Hey, it's back to printing nothing again.
13:20:16 <elliott> It hangs on the elusive instruction known only as "v".
13:20:19 <Deewiant> I could also have done what I'd do these days and terminate the comment with a ., that way it'd print an extraneous 0
13:20:50 <elliott> That's not right is it Deewiant.
13:21:15 <elliott> Deewiant: ALL MY BUGS ARE IN MY HELPER VALUES
13:21:16 <Deewiant> Unless your origin is internally represented as the bottom left corner
13:22:00 <elliott> Deewiant: Heh, it's just printing 0 now. But only when I press ^C. I need to flush stdout after each print >_<
13:22:24 <Deewiant> It'll print newlines eventually
13:22:37 <elliott> Deewiant: Isn't that hideously inefficient, flushing after each print? Does CCBI do that? :P
13:22:53 <Deewiant> CCBI's output buffer is like 10x the size of cfunge's, too
13:24:23 -!- poiuy_qwert has quit (Read error: Connection reset by peer).
13:25:40 <elliott> Deewiant: I'm going to leave it for a minute and see if it outputs something that isn't 0. :p
13:25:52 <elliott> I have a feeling wrapping might be quite slow because Mycology is IIRC very wide.
13:26:00 -!- poiuy_qwert has joined.
13:26:03 <Deewiant> It shouldn't be wrapping for a long time.
13:27:16 <elliott> ("beforeToNextIns",(9,0),'v')
13:27:16 <elliott> ("afterToNextIns",(9,0),'v')
13:27:16 <elliott> ("beforeToNextIns",(9,1),' ')
13:27:32 <elliott> ("beforeToNextIns",(5,0),' ')
13:27:33 <elliott> ("afterToNextIns",(6,0),'1')
13:29:26 <elliott> *Shiro.Interpreter> nextInsPos fs (IP (9,1) (0,1))
13:30:06 <Deewiant> Why does your map have a ' ' at (9,1)
13:30:13 <elliott> *Shiro.Interpreter> fs !@@ nextInsPos fs (IP (9,0) (0,1))
13:30:13 <elliott> *Shiro.Interpreter> chr 118
13:30:13 <elliott> *Shiro.Interpreter> fs !@@ nextPos fs (IP (9,1) (0,1))
13:30:15 <elliott> *Shiro.Interpreter> chr 32
13:30:19 <elliott> *Shiro.Interpreter> fs !@@ nextPos fs (IP (9,2) (0,1))
13:30:23 <elliott> *Shiro.Interpreter> fs !@@ nextPos fs (IP (9,3) (0,1))
13:30:28 <elliott> *Shiro.Interpreter> fs !@@ nextPos fs (IP (9,4) (0,1))
13:30:32 <elliott> Deewiant: THAT'S A VERY GOOD QUESTION, TEN POINTS TO THE GENTLEMAN
13:30:34 <Deewiant> Should've stuck with the B8.lines
13:30:49 <elliott> *Shiro.Interpreter> fungeStateFromByteString "abc\ndef"
13:30:49 <elliott> FungeState {stackStack = [], fungeSpace = FungeSpace (fromList [((0,0),97),((1,0),98),((2,0),99),((3,1),100),((4,1),101),((5,1),102)]), ip = IP (0,0) (1,0)}
13:30:54 <elliott> Deewiant: This is what we call "hurf durf".
13:31:04 <elliott> | w == ff || (w == lf && lastWasCR) = (p, fs, False)
13:31:04 <elliott> | w == cr || w == lf = ((x,y+1), fs, w == cr)
13:31:27 <ais523> elliott: heh, it's interpreting \n DOS-style
13:31:40 -!- BeholdMyGlory has joined.
13:31:45 <elliott> Hey, hey, whoa, it executed @ after 4.
13:31:48 <Deewiant> elliott: Right, I didn't see that bit
13:31:59 <elliott> I just prefer the personal touch.
13:32:25 <ais523> Deewiant: but the readme's more than 80 characters wide!
13:32:33 <elliott> Deewiant: Man, printing "0 1 2 3 4 " takes a whole second.
13:32:41 <elliott> Deewiant: Is that slower than Language::Befunge?
13:32:51 <elliott> Deewiant: Prepare for ais523 to tell you that all tabs ever are 8 characters.
13:32:52 <Deewiant> Yes, I'd say it's quite a bit slower
13:32:55 <fizzie> Deewiant: Tabs are 8 characters.
13:33:01 <ais523> Deewiant: tabs are always 8 characters
13:33:08 <elliott> fizzie: For one, even if they were, they'd not be.
13:33:16 <elliott> MOVES to a column divisible by 8.
13:33:20 <ais523> how else would you expect cat to interpret them?
13:33:21 <elliott> That's not the same as 8 spaces.
13:33:27 <elliott> Also, tabs aren't "multiple characters".
13:33:31 <ais523> and yes, I mean divisible by 8, = 8 characters at the start of a line
13:33:40 <elliott> I thought you said "always 8 characters".
13:33:44 <elliott> (What characters, I wonder?)
13:33:49 <ais523> elliott: I was mimicking you
13:33:53 <ais523> and they're rendered to spaces by the terminal
13:34:09 <elliott> Ah. So if I made cat output "abcdefgh" on a tab that'd be valid? :)
13:34:11 <Deewiant> elliott: You can always get Language::Befunge and compare, maybe your machine is slow enough that they're comparable
13:34:39 <elliott> Deewiant: ~2.1 GHz Core 2 Duo, 4 gigs of RAM and an SSD, I think its slowness can't be put down to my machine :P
13:34:43 -!- Behold has quit (Ping timeout: 255 seconds).
13:34:55 <ais523> elliott: anyway, failing after 4 means stringmode isn't working
13:34:58 <elliott> I doubt the extra Hz does too much to Befunge-98 interpreters.
13:35:09 <elliott> so that's understandable :D
13:35:32 <elliott> Ugh, ... I think I have to include stringmodeness in the IP structure.
13:35:56 <elliott> Deewiant: But an IP is such a pure thing right now!
13:36:04 <Deewiant> Also, I'm amused that ais is doing the readme-reading for you
13:36:19 <elliott> I do have the readme up, I'm just not taking any of it in :P
13:36:40 <ais523> elliott: and being cat(1), I effectively expand tabs at the start of a line to eight spaces then complain about the width
13:36:45 <elliott> 5 34 " Toggle Stringmode If no reflection on the instruction
13:36:45 <elliott> occurs, but the string's contents are
13:36:46 <elliott> interpreted as instructions, a second
13:36:46 <elliott> "4 " is output before exiting.
13:36:52 <elliott> Deewiant: My " should reflect.
13:36:55 <elliott> I don't have an implementation, so.
13:37:06 -!- aloril has joined.
13:37:15 <elliott> Deewiant: And unimplemented instructions reflect.
13:37:16 <Deewiant> Your " reflects and that's why you get 0-4
13:37:23 <elliott> 5 34 " Toggle Stringmode If no reflection on the instruction
13:37:24 <elliott> occurs, but the string's contents are
13:37:24 <elliott> interpreted as instructions, a second
13:37:24 <elliott> "4 " is output before exiting.
13:37:44 <elliott> YOUR README IS WRONG, HOW CAN I TRUST IT.
13:37:45 <fizzie> Well, did you get a second 4?
13:37:56 <ais523> elliott: if " reflects, you get one 4; if " doesn't reflect, you get two 4s
13:38:05 <elliott> Stop prejudicing me just because I'm stupid.
13:38:36 <elliott> Deewiant: What would you call a (position,delta) pair, as part of an IP?
13:38:44 <elliott> I think I want to separate it out so that functions like advance can still take it.
13:39:32 <elliott> ais523: Nasty piece of work, that Deewiant!
13:39:33 <fizzie> I'd call it "momentum", it's hilariously unaccurate and misleading.
13:39:45 <elliott> fizzie: You're a funny one. :p
13:39:48 <ais523> fizzie: that almost made me laugh, but I'm at work
13:40:06 <ais523> you could make a Heisenburg reference
13:44:00 <elliott> maybe i'll call it a posta
13:44:22 -!- poiuy_qwert has quit (Read error: Connection reset by peer).
13:45:53 <elliott> ais523: oerjan is right dammit
13:45:56 <elliott> I just started reading a random log
13:46:00 -!- poiuy_qwert has joined.
13:46:01 <elliott> 06:21:47 <Deewiant> ehird: coding a Befunge-98 interp in Haskell?
13:46:01 <elliott> 06:21:54 <ehird> that is my intention, yep
13:46:34 <elliott> (in the #esoteric Date Format)
13:46:42 <ais523> hmm, good intentions come to those who wait
13:46:51 <elliott> "Oh right, a year passed."
13:46:57 <elliott> shit, that was 2 years ago?
13:46:58 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
13:47:12 <elliott> 2010 is kind of like a big chunk of nothingness from my perspective since I was at the unit for like 11 months
13:47:18 <elliott> more like 9 months in 2010, but yeah
13:47:27 <elliott> So 2009 is as good as "last year" to me :P
13:48:17 <elliott> ais523: do you have a copy of the MKRY spec?
13:48:22 <elliott> I want to be the first to implement it
13:49:22 <fizzie> Here's another suggestion, in case you didn't like the "deposition" ("deltion"?): "plane". Since, you see, it's two vectors, and that defines a plane. Logic, it's what's for dinner.
13:50:13 <elliott> `addquote <elliott> Deewiant: What would you call a (position,delta) pair, as part of an IP? <fizzie> I'd call it "momentum", it's hilariously unaccurate and misleading. [...] <fizzie> Deposition. :p [...] <fizzie> Here's another suggestion, in case you didn't like the "deposition" ("deltion"?): "plane". Since, you see, it's two vectors, and that defines a plane. Logic, it's what's for dinner.
13:50:14 <HackEgo> 295) <elliott> Deewiant: What would you call a (position,delta) pair, as part of an IP? <fizzie> I'd call it "momentum", it's hilariously unaccurate and misleading. [...] <fizzie> Deposition. :p [...] <fizzie> Here's another suggestion, in case you didn't like the "deposition" ("deltion"?): "plane". Since, you see, it's two
13:50:24 <HackEgo> 295) <elliott> Deewiant: What would you call a (position,delta) pair, as part of an IP? <fizzie> I'd call it "momentum", it's hilariously unaccurate and misleading. [...] <fizzie> Deposition. :p [...] <fizzie> Here's another suggestion, in case you didn't like the "deposition" ("deltion"?): "plane". Since, you see, it's two
13:50:34 <ais523> elliott: that doesn't use two spaces everywhere
13:50:57 <elliott> the [...] goes in-between the two spaces
13:51:22 <elliott> `echo "<elliott> Deewiant: What would you call a (position,delta) pair, as part of an IP? <fizzie> I'd call it \"momentum\", it's hilariously unaccurate and misleading. [...] <fizzie> Deposition. :p [...] <fizzie> Here's another suggestion, in case you didn't like the \"deposition\" (\"deltion\"?): \"plane\". Since, you see, it's two vectors, and that defines a plane. Logic, it's what's for dinner." >>quotes
13:51:24 <HackEgo> "<elliott> Deewiant: What would you call a (position,delta) pair, as part of an IP? <fizzie> I'd call it \"momentum\", it's hilariously unaccurate and misleading. [...] <fizzie> Deposition. :p [...] <fizzie> Here's another suggestion, in case you didn't like the \"deposition\" (\"deltion\"?): \"plane\". Since, you see, it's
13:51:25 <ais523> that's some insane logic you have there
13:51:28 <elliott> `run echo "<elliott> Deewiant: What would you call a (position,delta) pair, as part of an IP? <fizzie> I'd call it \"momentum\", it's hilariously unaccurate and misleading. [...] <fizzie> Deposition. :p [...] <fizzie> Here's another suggestion, in case you didn't like the \"deposition\" (\"deltion\"?): \"plane\". Since, you see, it's two vectors, and that defines a plane. Logic, it's what's for dinner." >>quotes
13:51:37 <HackEgo> 295) <elliott> Deewiant: What would you call a (position,delta) pair, as part of an IP? <fizzie> I'd call it "momentum", it's hilariously unaccurate and misleading. [...] <fizzie> Deposition. :p [...] <fizzie> Here's another suggestion, in case you didn't like the "deposition" ("deltion"?): "plane". Since, you see, it's two
13:53:41 <fizzie> In other news (of the "abusing environments" series), \theoremstyle{definition} \newtheorem{problem}{Problem} ... \begin{problem} ... \end{problem} seems to make a reasonably nice environment for denoting questions in an exercise paper.
13:54:19 <elliott> ais523: my quote system is too robust to break like that!
13:54:20 <fizzie> Problem 1, problem 2, etc.
13:54:40 <elliott> 06:32:12 <ehird> <dt>C ( -- c... )
13:54:40 <elliott> 06:32:14 <ehird> <dd>Push ','s
13:54:40 <elliott> 06:32:16 <ehird> <dt>D ( -- c... )
13:54:40 <elliott> 06:32:18 <ehird> <dd>Push '.'s
13:54:40 <elliott> 06:32:20 <ehird> <dt>E ( -- c... )
13:54:42 <fizzie> It doesn't do much, but it does do auto-numbering and a bit of \paragraph{}-style emphasis for the numbers.
13:54:44 <elliott> 06:32:22 <ehird> <dd>Push 'e' and 'h' (random)
13:54:48 <elliott> 06:32:26 <ehird> <p>All pushes from 3 to 15.</p>
13:54:52 <elliott> the relevant parts, anyway
13:55:14 <elliott> fizzie: I was RIFFING on the trollface-"problem?".
13:55:29 <ais523> <elliott> ais523: my quote system is too robust to break like that! <--- you appended /two/ lines, I'm wondering if you added a 296 and it got renumbered 295 after the delquote
13:55:37 <elliott> ais523: I appended one line.
13:55:41 <elliott> ais523: It's just that HackEgo cut it off.
13:55:45 <ais523> ah, in that case I misread
13:55:51 <elliott> ais523: I said "`echo ... >>x"
13:55:54 <elliott> but ` isn't interpreted by shell
13:55:58 <ais523> I thought you were trying to append the second part of the line to the bit that got cut off
14:00:12 <elliott> ais523: meanwhile, a new high in the abuse of Wikipedia's User namespace: http://en.wikipedia.org/wiki/User:Purpy_Pupple/Maze
14:00:55 <elliott> ais523: apparently, justified against [[Wikipedia:User pages#Excessive unrelated content]] because its output is used in [[Maze generation]] and because of [[Wikipedia:Featured picture candidates/Maze Generation 2]]
14:01:02 <elliott> which doesn't really make any sense to me
14:01:13 <ais523> elliott: you saw that on reddit
14:01:26 <ais523> in fact, the reddit thread turned into an impromptu MfD
14:01:42 <ais523> I'm surprised it hasn't been nominated, in fact
14:01:45 <ais523> elliott: no, on reddit
14:01:50 <elliott> hmm, only one small thread
14:02:03 <ais523> it resembled an MfD in quite a lot of ways, except for the lack of bolded comments and being a reddit thread rather than a wiki page
14:02:44 <elliott> "I like keeping my programs as efficient as possible and it would seem to me that this would cause the program to evaluate something it really shouldn't have to. Does the compiler recognize this and not include it in the final compiled code or is there something I don't understand about do-while's?"
14:02:49 <elliott> after someone suggested using do ... while (0) for a macro
14:03:20 <ais523> well, the do just sets a label, which doesn't appear in the final machine code; there's a valid point about the while, except that constant branches are really easy to optimise
14:03:36 <elliott> even stupidcc would optimise that out
14:04:21 -!- poiuy_qwert has quit (Read error: Connection reset by peer).
14:04:30 <elliott> ais523: hey, i just thought of another argument why [[Fork bomb]] shouldn't have 70 (hyperbole) almost-identical examples, apart from that merely being a stupid waste of space
14:04:35 <elliott> (ok, thought of = saw on reddit)
14:04:40 <elliott> most of those are original research! :)
14:05:59 -!- poiuy_qwert has joined.
14:12:50 -!- augur has quit (Remote host closed the connection).
14:15:59 <elliott> ais523: what would _you_ call it?
14:16:04 <elliott> development is blocked on this name :D
14:16:15 <ais523> I don't have much of an idea, really
14:16:38 <elliott> ais523: no, an IP inclues stringmode
14:16:42 <elliott> I just mean a pair of (position, delta)
14:16:46 -!- cheater- has quit (Ping timeout: 240 seconds).
14:16:57 <fizzie> Come to think of it; back in the y2k there were "year 19100"s, and possibly some "19910"s, and maybe even some "1900"s and "1990"s, but at least I didn't see any "199:"s.
14:17:17 -!- Lymia__ has quit (Read error: Connection reset by peer).
14:17:32 <elliott> I think 199: has happened.
14:17:49 -!- cheater- has joined.
14:17:52 <ais523> elliott: the Windows 3.1 file manager did 19:0
14:18:27 <fizzie> No carry for the second digit, I see.
14:18:28 -!- Lymia__ has joined.
14:19:23 <elliott> "Crashed my entire computer! Great job." --reddit
14:19:39 <ais523> elliott: it's '1' '9' '0'+((year-1900)/10) '0'+((year-1900)%10)
14:20:09 <elliott> http://esolangs.org/w/index.php?title=Brainfuck&curid=961&diff=20990&oldid=20786 *sigh*
14:20:22 <fizzie> Well, in a few places where the position/delta values have had a name like "Vector", I've seen the pos/delta pair called boringly "Vector2" or some other such. (But it does sound a bit too much like a 2-component vector.)
14:20:23 <elliott> the links section on the brainfuck article is insane
14:20:38 <elliott> fizzie: They are in fact called Vector; Vector2 seems a bit odd.
14:20:46 <elliott> fizzie: But I mean the field name.
14:20:59 <fizzie> What, I think it sounds more even than odd! (Eh eh ee ehehe eh.)
14:21:01 <elliott> data IP = IP { posdelt :: (Vector, Vector); ... } or whatever
14:21:08 <elliott> fizzie: ehehehhehehhhehehee,,,,
14:21:18 <elliott> Sponsored by MKRY, the fingerprint you can trust
14:21:42 <ais523> hmm, what about a taylor?
14:22:00 <ais523> on the basis that you've basically got a position and its derivative, which are the basis of the first two terms of a taylor series
14:22:16 <fizzie> That's almost as far-fetched as the "plane", really.
14:22:19 <elliott> fizzie: did you see when i linked you do that site with a glfunge binary for HP-UX?
14:22:44 <elliott> Clearly we need to figure out what the singular of the plural "taylor" is.
14:23:45 <ais523> fizzie: except that "plane" is incorrect there, as a plane through the origin is defined by two unit vectors, and I think other planes need one unit vector and one ordinary vector
14:23:56 <fizzie> Yes, I noticed; I had google-my-name-found it earlier, too. I didn't have anything to do with the HP-UX packaging; I'm in fact a bit ashamed that my mistakes are so prominent. Maybe some day I'll actually finally do the 3d-glitzy befunge I was envisioning back then. (At least now we've got programmable shaders and all that fluff.)
14:24:21 -!- poiuy_qwert has quit (Read error: Connection reset by peer).
14:24:59 <fizzie> ais523: Well, maybe a "disc" then? One vector for the position, other for the normal, and the length of the normal to specify area/radius?
14:25:06 <ais523> elliott: I like "tayle"
14:25:18 <elliott> ais523: Yes, but unfortunately nobody will know what the fuck it means. :p
14:25:29 <ais523> especially as it's a cool-sounding word as it is, and you don't need to tell people the etymology
14:25:49 <elliott> ais523: I'll go with "tayle" if I can't think of a more reasonable name.
14:25:53 <ais523> I think that fails in dimensions other than 3
14:25:59 -!- poiuy_qwert has joined.
14:26:00 <elliott> ais523: Do you think we could get someone to kickban fizzie?
14:26:05 * Ilari remembers he has some messy esolang interpretters for self-designed esolangs.
14:26:09 <ais523> e.g. it'd be a (3-dimensional) sphere in hyperspace
14:26:24 <ais523> I should upload my improved 1cnis interp some time, when I finish it
14:26:34 <elliott> fizzie: Heh, SCKE is yours?
14:26:37 <ais523> (I had to remove a couple of features in order to improve efficiency)
14:26:46 <fizzie> elliott: Yes, and I'm not proud of that either. :p
14:26:52 <elliott> fizzie: Holy shit, the GLfunge site has a VA Linux advert (it's a broken image).
14:26:54 <fizzie> elliott: I just needed a hostname lookup and something else.
14:27:02 <elliott> Isn't SCKE better than SOCK?
14:27:11 <elliott> But more importantly: VA Linux! Shit!
14:27:22 <fizzie> And you got some sort of points from that banner. :p
14:27:26 <elliott> * Funge98 works, with the following exceptions: {, }, u, l, h, m, (, ).
14:27:33 <elliott> Seriously? You wrote the website when it was that incomplete? :-D
14:28:03 <elliott> Sorry, it's just so COMICAL.
14:28:03 <fizzie> The email address is worng too.
14:28:08 <elliott> fizzie: So SOCK is an extension of SCKE?
14:28:27 <fizzie> No, SCKE just adds a few more commands; you plonk it on after loading SOCK, usually.
14:28:38 <ais523> elliott: picking on fizzie is rather unlike you...
14:28:54 <Ilari> Do either of those support IPv6? :-)
14:28:55 <elliott> ais523: It's not serious picking!
14:29:07 <elliott> It's just gosh-fizzie-truly-is-a-pathetic-excuse-for-a-hu maybe I won't finish this sentence!!
14:29:10 <ais523> Ilari: CLC-INTERCAL supports IPv6 nowadays
14:29:10 <fizzie> Ilari: No; Vorpal's NSCK should, though.
14:29:26 <ais523> and the way it does it is beautifully insane too, as it's transparent for IPv4 applications
14:29:37 <elliott> ais523: heh, how does it do it? maybe i'll implement it in SOCK and SCKE :D
14:29:43 <fizzie> SCKE just adds a v4-only gethostbyname() instruction ('H') and a poll command ('P').
14:29:44 <ais523> the way it works is, if you DNS lookup an IPv6 address, it returns an IPv4 address in the multicast region
14:29:58 <ais523> and then translates between them NAT-style
14:30:07 <ais523> umm, until the application exits, I think
14:30:25 -!- poiuy_qwert has quit (Client Quit).
14:30:30 <ais523> so IPv4 programs can use IPv6 without any modification at all
14:31:02 <elliott> fizzie: hmm, what does H's return look like?
14:31:36 <fizzie> elliott: Whatever I returns; usually an integer-mapped IPv4 address.
14:31:39 <ais523> I suggest the CLC-INTERCAL method be adopted in all other esolangs too, also real-life operating systems
14:31:48 <fizzie> ais523: There's a Internet-Draft for that mechanism.
14:31:55 <fizzie> ais523: http://tools.ietf.org/html/draft-liu-behave-nat46-02
14:31:59 <elliott> fizzie: what if the hostname ends with %ipv6, it returns instead an IPv6 address?
14:32:08 <elliott> CLC-INTERCAL: Implementing innovative Internet-Drafts.
14:32:45 <ais523> hmm, that one isn't numbered
14:32:50 <ais523> hasn't even been requested for comment yet
14:32:56 <ais523> I wonder if clc came up with the idea independently?
14:33:24 <fizzie> elliott: If you have bignum cells, maybe. The problem with retrofitting IPv6 into SOCK is that the addresses won't fit in single cells; so you either use some sort of a handle system (with the garbage-collection problems) or have a problem.
14:33:31 <ais523> also, those page breaks are irritating
14:33:39 <elliott> fizzie: I'd just push two cells.
14:33:41 <ais523> and the draft is expired (on sep 8 2010)
14:33:42 <elliott> Because, you know, radical.
14:33:50 <ais523> fizzie: how did you find that so quickly? or even know it existed?
14:34:06 <fizzie> ais523: Purely based on the far more popular (and sane) NAT64/DNS64 approach.
14:34:14 <ais523> also, it seems it was written entirely by China Mobile employees
14:34:17 <fizzie> ais523: Just thought if someone made it, surely they'd call it the obvious "nat46".
14:34:31 <elliott> ais523: This is the man who found an Ozy and Millie comic something like 10 seconds after vaguely quoting it.
14:34:42 <elliott> By using Google Book Search and then binary searching a specific year of archives.
14:34:46 <elliott> His searching power is INFINITE.
14:34:56 <ais523> and doesn't even mention the range of IPv4 addresses that should be used (maybe that's what the "reserved" addresses up the top can be used for? the IPs wouldn't need to be routable)
14:35:07 <elliott> (fizzie: Is your searching power infinite? That would be cool.)
14:35:10 <ais523> elliott: this is why IRC > Google
14:35:18 <elliott> ais523: but he did it with Google!
14:35:46 <ais523> yes, but a whole IRC channel full of people who are good with Google and also vaguely remember what they're looking for > one person trying to find it on their own
14:36:48 <elliott> ais523: yes, but bugging a random IRC channel with something that only you want == no results
14:37:26 <fizzie> There seems to also be a draft with the same name (but from different folks, Alain Durand from SUN Microsystems,inc) from 2002.
14:37:26 <ais523> elliott: luckily, #esoteric isn't a random IRC channel
14:37:50 <elliott> ais523: but it would not be amused if i just told it all my google searches
14:38:03 <ais523> elliott: it probably wouldn't mind with mine, they're so rare
14:38:20 <ais523> the search box in my browser is rarely set to Google at all
14:38:34 <ais523> generally, it's set to NetHackWiki or Wikipedia, although it's set to Esolang atm
14:39:03 <fizzie> (Not the Perl operator.)
14:39:03 <elliott> there was a modified Bing logo with "powered by Google" in it on reddit :)
14:39:13 <elliott> so Bing powers Yahoo, and Google powers Bing
14:39:28 <fizzie> And where's Altavista?
14:39:32 <ais523> fizzie: oh, I interpreted "Not the Perl operator" without the "not" for a moment
14:39:39 <ais523> altavista is merged with yahoo nowadays, isn't it?
14:39:43 <fizzie> "the most comprehensive search experience on the Web".
14:40:04 <ais523> altavista still looks like it always used to, which is pretty nice
14:40:21 <ais523> I'll search it for INTERCAL as normal, that's my typical nonscientific test to test search engines
14:40:31 <fizzie> Yes, it's nice to have some semblance of stability in this modern, confusing world.
14:40:32 <elliott> I thought altavista died recently
14:40:35 <elliott> wait, no, that was some other old engine
14:40:45 <elliott> ais523: the results page itself is web 2.0'd up
14:40:50 <ais523> hmm, the search results are copyright Yahoo
14:40:52 <elliott> it looks like Yahoo's with the logo swapped
14:40:57 <elliott> ais523: er, yes, Yahoo own AltaVista
14:41:01 <elliott> ais523: and thus Babelfish
14:41:09 <fizzie> Yes, it does redirect itself into a yahoo.com address after searching.
14:41:12 <ais523> indeed, I think it's just a reskin of Yahoo! nowadays
14:41:20 <elliott> at least the home page loads quickly :D
14:41:31 <elliott> http://uk.altavista.com/news/default
14:41:54 <ais523> elliott: either that, or around 1990
14:42:06 <elliott> "What are Matt’s thoughts on the security of the Vista kernel?
14:42:06 <elliott> Clearly he wasn’t impressed with NT, but since its technically obsolete I would be very interested to hear an ex-adware coder’s views on the “infectability” of Vista’s kernel." :what:
14:42:22 <ais523> I think they went back to the early-90s style in 2000 or so in order to escape from the horror that was mid-90s
14:42:27 <fizzie> My unscientific "my own surname" search finds my name in Microsoft Academic Search -- http://academic.research.microsoft.com/Author/8260699 -- and my Master's thesis in there.
14:42:45 -!- cheater- has quit (Ping timeout: 240 seconds).
14:43:02 <ais523> it's not that 1990 anyway, less than half the text is linked
14:43:17 <ais523> back in 1990, typically search engines, as well as the search box, would have a sort of index structure
14:43:24 <elliott> ais523: nah, 2000 style is very distinctive
14:43:42 <elliott> ais523: it's WinAmp, it's small pixel fonts, it's custom image buttons that just draw their own pixelly button
14:43:55 <elliott> it's white on medium-darkish blue, or black on white with bad shades of blue around
14:44:22 <ais523> I remember writing computer games in GDI16, aimed at 256-color screens
14:44:29 <ais523> which was more than the 16-color I'd previously used
14:44:35 <elliott> wow fizzie, I'm on page ii of your Master's and I'm already bored
14:44:42 <ais523> that computer might actually have /been/ 256-color, although I think it was up to 16-bit by then
14:44:46 <fizzie> elliott: It's not exactly terribly exciting stuff.
14:44:48 <elliott> how is that even possible? :D
14:44:51 -!- cheater- has joined.
14:44:59 <ais523> I'm not sure if my masters' is online anywhere
14:45:31 <elliott> fizzie: you neglected to get yourself nicknamed "DIRTY OLD MAN", how are you ever going to win the 2011 PhD challenge two years before it's announced now?
14:45:41 <elliott> also, you neglected to make it a PhD thesis instead of a Master's
14:45:58 <fizzie> But do note that the FFT spectrum in the flowchart of page 13 (page 23 of PDF) in fact does match the resulting MFCC coefficients at the end.
14:46:02 <ais523> Google finds no results on a search for the title, anyway
14:46:07 <fizzie> That's the sort of attention to detail you need.
14:46:22 <ais523> oh, I forgot it existed
14:46:23 <elliott> fizzie: When does the text turn into "blah blah blah blah blah ..."?
14:46:43 <elliott> "Speech is for the most a natural means of communication"
14:46:44 <fizzie> Also the speech waveform input is bona-fide real data, though the MFCCs and the spectrum are obviously just from one frame.
14:46:46 <elliott> fizzie: what does that even mean?
14:46:51 <elliott> I think you accidentally a word
14:47:17 <ais523> no results on Bing either, although the results it found by trying without the quotes were more relevant
14:47:18 <fizzie> Just substitute in whatever word you like.
14:47:20 <elliott> it would be advantageous if we could use spoken language as the medium
14:47:20 <elliott> also when interfacing with computer systems."
14:47:23 <elliott> can i just state the obvious before I go on
14:47:28 <ais523> and Cuil no longer exists; a pity, in a way (it used to be my default search engine)
14:47:49 <elliott> fizzie: no, it wouldn't :D
14:47:52 -!- FireFly has joined.
14:47:52 <ais523> elliott: because the results were reasonable, and I trusted them more than most of the competition
14:47:53 <elliott> fizzie: no, it wouldn't :D
14:47:56 <elliott> ais523: tell him he's wrong
14:48:22 <fizzie> It's not saying that you'd need to replace everything with speech; just that there's real use cases for it.
14:48:30 <ais523> elliott: well, surely it'd be advantageous if you could, just out of academic interest; and surely also advantageous if you never actually used it
14:48:38 <elliott> jump build jump build jump build
14:49:01 <ais523> elliott: haha, you saying that over IRC reminds me of commercial voice-control programs
14:49:12 <ais523> I tried out the one that came with Windows XP for a while, mostly for amusement value
14:49:19 <elliott> OS X's is ... interesting.
14:49:24 <elliott> It tends to do whatever you didn't tell it to.
14:49:26 <fizzie> Transcribing large audio/video corpuses so that you can do textual search on them is quite popular now.
14:49:37 <fizzie> elliott: Yes, I kept saying "switch to FireFox" and it instead every time opened iPhoto.
14:49:46 <elliott> fizzie: textual search? AUDIO SEARCH
14:49:46 <fizzie> But at least it was consistent.
14:50:06 <elliott> spectate swamp video search!
14:50:12 <elliott> ah, that's the one flaw of spectate swamp search
14:50:16 <elliott> its input is text, rather than another video
14:50:18 <fizzie> So you act out the scene you're looking for in front of a camera?
14:51:45 <elliott> ais523: seriously! (position,delta)! name it! i have naming disease!
14:51:48 <elliott> i can't code until i get names!
14:52:02 <ais523> I did already, did you not like my name?
14:52:05 <fizzie> What does cfunge call a structure like that?-)
14:52:22 <elliott> fizzie: probably it doesn't, it's too lame to have like, functions
14:52:26 <elliott> it's just a bunch of macros basically
14:52:37 -!- poiuy_qwert has joined.
14:53:33 <fizzie> Yes, it seems it's just funge_vector position; funge_vector delta;.
14:53:49 <Deewiant> elliott: So you're stuck on the name and no progress has been made?
14:54:27 <ais523> elliott: what about ip_pos_delta?
14:54:32 <ais523> it's the name used by cfunge
14:54:33 <elliott> Deewiant: ...that...actually makes an upsetting amount of sense
14:54:47 -!- poiuy_qwert has quit (Client Quit).
14:54:52 <ais523> void ick_save_ip_pos_delta(struct ick_ipposdeltatype* ippd)
14:54:55 <elliott> Deewiant: Half of an infinite line. Classic.
14:55:01 <ais523> actually, maybe just IFFI
14:55:15 <ais523> I just picked a random Funge interp I had handy...
14:55:21 <ais523> I like Ray too, though
14:55:34 <ais523> even though it should have an indication of speed
14:55:36 <elliott> ais523: wanna help me implement IFFI at some point :P
14:55:39 <fizzie> Whelps, off to do some shopping. ->
14:55:51 <ais523> elliott: as long as it doesn't actually involve writing code, sure
14:56:00 <elliott> ais523: of course it does, C-INTERCAL glue
14:56:06 <elliott> i'm not touching that code :-D
14:56:06 <ais523> note that the semantics of IFFI don't require the actual existence of an INTERCAL interp
14:56:10 <Deewiant> ais523: It does have an indication of speed, that's the delta('s magnitude)
14:56:18 <elliott> Deewiant: Yes, but the name Ray doesn't.
14:56:20 <ais523> Deewiant: I know, it's the name I was talking about
14:56:25 <elliott> It's the same ray no matter how fast you're travelling.
14:56:52 <ais523> elliott: it's just a fingerprint for INTERCAL control flow semantics
14:57:09 <elliott> ais523: why on earth was it implemented by ... right, of course.
14:57:21 <ais523> plus, an allowance for line numbers to be shared between the Funge program and a different program
14:57:23 <ais523> which gives you an FFI
14:57:24 <elliott> ais523: but you had an intercal->funge ffi, didn't you?
14:57:42 <ais523> it's a useful fingerprint even if not used as an FFI, anyway
14:57:46 <ais523> for certain values of "useful"
14:58:00 <ais523> but the real merit is in hooking up other programs to the same control system
14:58:03 <Deewiant> Maybe I should write an INTERCAL interp so I could do IFFI
14:58:06 <ais523> so you can jump around between them via COME FROM
14:58:49 <elliott> Deewiant: does D not have an FFI? ;)
14:59:08 <ais523> elliott: it probably doesn't have one that works like /that/
14:59:23 <elliott> so that he could bind it to C-INTERCAL
14:59:24 <Deewiant> C-INTERCAL has some cfunge-only bits, I'd rather be NIH-y and write my own than add CCBI-only stuff to something else entirely
14:59:33 <elliott> Deewiant: C-INTERCAL doesn't include IFFI, IIRC
14:59:49 <Deewiant> Unless I've misunderstood the extent of the connection between cfunge and its companion
14:59:50 <elliott> Deewiant: OK, better idea: do it to CLC-INTERCAL using Perl's XS.
15:00:03 <elliott> Deewiant: IFFI is I think just a big patch to C-INTERCAL but I might be wrong.
15:00:11 <elliott> as well as the fingerprint implementation in cfunge
15:00:43 <Deewiant> Right, but I thought that the C-INTERCAL bits were at least partly cfunge-specific and not very pluggable to arbitrary interps
15:00:57 <ais523> elliott: wrong way round, it's actually a patch to cfunge to make it fit into ick's FFI
15:01:03 -!- asiekierka has joined.
15:01:06 <ais523> plus an expansion library to ick to implement the other side
15:01:14 <elliott> Deewiant: That's true, yes.
15:01:20 <elliott> Deewiant: Thus CLC-INTERCAL.
15:01:26 <elliott> Or for COMPLIANCE, J-INTERCAL.
15:01:34 -!- Sgeo has joined.
15:01:46 <Sgeo> I'm alive! I'm alive!
15:01:56 <ais523> in theory, you could just generate a library and a compiler to .cio and ick wouldn't need to know about the existence of the Befunge side at all
15:01:57 <Sgeo> [Note: I am not an it]
15:02:14 <Deewiant> Compiling Befunge to INTERCAL?
15:02:50 <quintopia> you made me sing "sick day" by weird al sgeo (in my head)
15:02:53 <ais523> Deewiant: not exactly; it compiles Befunge to C (via the expedient of generating a program from a template that's pretty much just uses cfunge as a library and calls it)
15:03:46 <ais523> also, not quite C either; it's a .cio file (which is best explained like this: executable : linker : object file :: C : ick(1) : .cio file)
15:03:54 * elliott reads AnMaster argue against More Readable Use of Cat with 08:44:37 <AnMaster> ehird, "can not create process: limit exceeded"
15:04:09 <Deewiant> elliott: Mess with your Rays instead
15:04:11 <ais523> the INTERCAL program is also compiled to .cio, and the two are linked together, then the resulting C file compiled and linked
15:04:33 <elliott> Deewiant: Needs a better name, Ray would just be the point
15:04:44 <Deewiant> A ray is specifically the two put together
15:04:46 <elliott> Deewiant: Ray wouldn't distinguish (1,0) and (2,0)
15:04:55 <ais523> Deewiant: err, does that explain it? the whole thing's a little tricky to explain
15:05:07 <ais523> also, I had some sort of idea that some day the .cio files would be reusable, so you didn't have to compile the whole thing in one go
15:05:12 <Deewiant> elliott: If it's a ray in a discrete space, like it is, it arguably does
15:05:13 <ais523> but atm they aren't, and I forget why
15:05:48 <elliott> Deewiant: Fair enough then.
15:06:09 -!- augur has joined.
15:07:08 <ais523> so anyway, if you compile INTERCAL and Befunge-98 together, the command line looks like this: "ick -e program.i program2.b98", and it generates program.cio and program2.cio, linking them together with libick.a and libick_ecto_b98.a to form program (.exe, on DOS)
15:07:31 <ais523> I'm not entirely sure what happens if both the INTERCAL and Befunge programs have the same basename, I think it's a "so don't do that then"
15:08:13 <ais523> you could also link in one or C programs and an expansion libraries if you liked, along the lines of "ick -e program.i program2.b98 program3.c syslibc"
15:08:23 <ais523> assuming I've got that arg list in the right order, I'm not sure if it's sensitive to that
15:08:54 <ais523> but you're only allowed one INTERCAL input file (if you had multiples, you could just concatenate them); and one Befunge file (as it serves as the entry point if it's present)
15:09:00 <ais523> and other-dimensional Funges aren't supported
15:09:13 <ais523> (nor is Befunge-93 due to the lack of fingerprints)
15:11:39 <elliott> @hoogle (a -> b) -> (b -> a) -> (b -> b) -> a -> a
15:11:39 <lambdabot> Control.Parallel.Strategies (.|) :: (b -> c) -> Strategy b -> (a -> b) -> a -> c
15:11:40 <lambdabot> Control.Parallel.Strategies (.||) :: (b -> c) -> Strategy b -> (a -> b) -> a -> c
15:11:40 <lambdabot> Control.Parallel.Strategies (-|) :: (a -> b) -> Strategy b -> (b -> c) -> a -> c
15:11:52 <elliott> the above is the "within" function, if anyone's curious
15:11:52 <Deewiant> @djinn (a -> b) -> (b -> a) -> (b -> b) -> a -> a
15:12:05 <elliott> Deewiant: that's not right
15:12:19 <elliott> f fro to f x = to (f (fro x))
15:12:28 <elliott> if we take the first two arguments as a tuple
15:12:32 <Deewiant> ?ty \fro to f x -> to . f . fro $ x
15:12:33 <lambdabot> forall a b a1 a2. (a2 -> a1) -> (a -> b) -> (a1 -> a) -> a2 -> b
15:12:45 <Deewiant> @djinn (a2 -> a1) -> (a -> b) -> (a1 -> a) -> a2 -> b
15:12:50 <Deewiant> @pl \fro to f x -> to . f . fro $ x
15:13:04 <elliott> type Accessor a b = ((a -> b), (b -> a))
15:13:23 <elliott> type Accessor a b = ((a -> b), (a -> b -> a))
15:13:30 <elliott> ray = (\(IP r _) -> r, \(IP _ s) r -> IP r s)
15:13:39 <elliott> within ray transformRaySomehow someIP
15:13:48 <elliott> someIP{ ray = transformRaySomehow (ray someIP) }
15:13:58 <elliott> you can also define all the setters and stuff based on this
15:14:01 <elliott> TODO: hack that into Shiro
15:15:52 <elliott> I SHOULD RENAME THAT FIELD
15:16:23 <Deewiant> elliott: s/ip <$> get/gets ip/
15:16:45 <elliott> Deewiant: Fuck. I forgot that one space != two spaces in string mode.
15:16:50 <elliott> I also forgot that spaces take a tick in non-string-mode.
15:16:55 * Sgeo suddenly has VB flashbacks
15:17:09 <Deewiant> They don't take a tick in non-string-mode.
15:17:32 -!- MigoMipo has joined.
15:17:54 <ais523> elliott: one space == two spaces even in string mode, in Befunge-98
15:17:54 <elliott> Deewiant: Not even a single tick?
15:18:02 <ais523> and they don't take time outside stringmode
15:19:51 <elliott> Couldn't match expected type `StateT FungeState IO Value'
15:19:51 <elliott> against inferred type `a -> Value'
15:19:52 <elliott> In the expression: (!@ k) . gets fungeSpace
15:19:52 <elliott> In the definition of `peek': peek k = (!@ k) . gets fungeSpace
15:23:01 <elliott> Now let's see how Mycology does when spaces are stripped from strings.
15:23:27 <Sgeo> What is with Reddit and Chrome?
15:23:32 <Sgeo> Maybe it's the plugins I use?
15:23:41 <elliott> 6 95 _ East-West If If the comparison is done incorrectly
15:23:41 <elliott> (i.e. the wrong direction is taken)
15:23:41 <elliott> an additional "5 " is output.
15:23:41 <ais523> elliott: _ went the wrong way, perhaps due to reversing the comparison
15:23:49 <elliott> doCharIns '_' = do x <- pop; if x == 0 then go west else go east
15:23:55 <elliott> so X-Y if is X if true, Y if false?
15:24:11 <elliott> doCharIns '|' = do x <- pop; if x == 0 then go north else go south
15:24:39 <Deewiant> 95 _ East-West If b delta <- if (b) (-1,0) else (1,0)
15:24:47 <Deewiant> 124 | North-South If/2D b delta <- if (b) (0,-1) else (0,1)
15:24:50 <elliott> Deewiant: Oh my god, you need this binary. It is hilarious watching it type out each letter painstakingly.
15:24:56 <elliott> elliott@elliott-MacBookAir:~/Code/shiro$ ./shiro
15:25:20 <elliott> This is the slowest interpreter ever.
15:25:25 <elliott> Deewiant: Yeees, I'm not sure what that is.
15:25:41 <elliott> How does it test empty stack popping non-zero?
15:25:42 <Deewiant> Given the space it looks like it came from a .
15:26:19 <Deewiant> Except that it hasn't tested | yet, so probably _
15:26:20 <elliott> Then likely my | is flipped too.
15:26:51 <elliott> tos = headOr space <$> toss
15:27:16 <elliott> Deewiant: That 4 just came again without the space.
15:27:19 <Deewiant> I like how you just use the wrong constants everywhere
15:27:27 <elliott> Yes, it's the source of all my bugs.
15:27:47 <elliott> Deewiant: It gets slower every single character. I'm not sure why.
15:28:25 <elliott> Seriously, this thing is impressively slow.
15:28:28 <Deewiant> Sounds like some big expression getting built up and not forced
15:28:36 <elliott> Deewiant: Yeah, I have absolutely no strictness annotations.
15:28:42 <elliott> Dear god it's at 101% CPU.
15:28:52 <elliott> Ooh, something else works!
15:29:03 <elliott> It takes a while to figure out what it is though :P
15:29:24 <elliott> Deewiant: Is it possible to pass Mycology with a stringmode as broken as mine?
15:29:35 <ais523> elliott: in what way is it broken?
15:29:41 <elliott> ais523: GOOD:emptystackpopszero
15:29:45 <Deewiant> It'll look at spaces eventually.
15:30:06 <ais523> elliott: are p/g meant to work?
15:30:11 <elliott> doCharIns 'g' = popVec >>= peek >>= push
15:30:11 <elliott> doCharIns 'p' = do val <- pop; pos <- popVec; poke pos val
15:30:19 <elliott> and as far as I can tell, they _should_
15:30:29 <Deewiant> elliott: Wrong order of pop/popVec
15:30:57 <Deewiant> ?. undo pl do pos <- popVec; val <- pop; poke pos val
15:30:57 <lambdabot> Parse error at "lette..." (column 47)
15:31:08 <Deewiant> ?. pl undo do pos <- popVec; val <- pop; poke pos val
15:31:19 <elliott> Deewiant: But hey, this isn't bad for my second day of coding, if you ask me. Admittedly I asked you a lot of things.
15:31:33 <elliott> But I figured out most of the instructions myself! And I haven't copy-pasted a single line from CCBI, which is innovative for this channel.
15:32:13 <elliott> Deewiant: This thing is gonna go bezerk testing my negative k behaviour, isn't it.
15:32:27 <elliott> then replicateM_ (fromIntegral (abs n)) advance
15:32:28 <elliott> else do Ray pos _ <- gets (ray . ip)
15:32:30 <elliott> replicateM_ (fromIntegral n) (doIns =<< peek pos)
15:32:42 -!- copumpkin has joined.
15:32:42 <elliott> Arguably it should be advance >> toNextIns that it replicates.
15:32:55 <elliott> Arguably enough that I'm fixing it now.
15:33:44 <elliott> Deewiant: It already does that
15:33:51 <Deewiant> If you make it toNextIns it won't
15:33:55 <elliott> Deewiant: (advance >> toNextIns).
15:34:09 <elliott> Deewiant: Note that 0 is a nop for the replicateM_.
15:34:13 <elliott> It just starts off with "advance; toNextIns".
15:34:19 <elliott> It's logical that it would continue to do so for smaller values.
15:34:36 <Deewiant> If your code is a nop for zero than any behaviour at all is arguable
15:34:46 <Deewiant> Or rather, they're all equally un-arguable
15:34:49 <elliott> Deewiant: I think the main slowness here is that it's calculating the bounds for the entire fungespace every single move.
15:34:54 <elliott> Including multiple times for a stream of spaces.
15:35:11 <elliott> <Deewiant> Or rather, they're all equally un-arguable
15:35:15 <elliott> Hey, mine is, like, continuous.
15:35:18 <Deewiant> Looping through 80000 Map nodes every instruction won't be fast, no :-D
15:35:25 <Deewiant> And doing it twice, too, I guess
15:35:49 <elliott> f(n) | n > 0 = normal k behaviour; | otherwise = advance to next instruction |n|+1 times
15:35:49 <Deewiant> elliott: replicateM_ (fromIntegral (abs n)) launchTheMissiles matches the spec too
15:35:52 <elliott> f(n) | n > 0 = normal k behaviour; | otherwise = advance to next instruction |n|+1 times
15:35:56 <elliott> Deewiant: But mine captures the 0 behaviour ELEGANTLY.
15:36:02 <elliott> UNDEF:#acrossleftedgeskipseasternmostcellinfile
15:36:07 <Deewiant> elliott: No it doesn't, because your thing is just a nop for 0
15:36:10 <elliott> Deewiant: That's the behaviour you think should be BAD if not for Vorpal, right?
15:36:20 <elliott> I do "advance; toNextIns" beforehand in k.
15:36:28 <Deewiant> Your code for n <= 0 is a nop for 0
15:36:35 <Deewiant> So you can put whatever you like in there
15:36:43 <elliott> Deewiant: Yes, but I mean the algorithm behind it.
15:36:50 <elliott> I just moved it above since the else branch would use it too.
15:37:02 <elliott> UNDEF:#acrossleftedgeskipseasternmostcellinfile
15:37:02 <elliott> UNDEF:#acrossleftedgehitseasternmostcellonline
15:37:06 <elliott> <elliott> Deewiant: That's the behaviour you think should be BAD if not for Vorpal, right?
15:37:12 <ais523> elliott: those look like IRC channels
15:37:24 <Deewiant> I think the fact that you need to do it in both cases just proves that it's not sensible to somehow extend it to negatives :-P
15:37:35 <ais523> elliott: that's the naive behavoiur, isn't it?
15:37:43 <ais523> although it's dubious semantically
15:37:47 <Deewiant> Not just "for Vorpal" but more that I'm lazy
15:37:50 <elliott> Deewiant: My # is just "advance"
15:37:56 <elliott> Should it be advance >> toNextIns?
15:38:03 <Deewiant> Your data structure should be better :-P
15:38:09 <ais523> I can see a case for skips, hits; but skips, skips is more reasonable
15:38:31 <ais523> Deewiant: err, I meant hits, hits
15:38:45 <ais523> elliott: it's not GOOD or BAD, it's just D
15:38:58 <ais523> obviously k did something so insane that it hit a random part of fungespace
15:39:25 <elliott> Deewiant I have no idea what is going on
15:39:31 <elliott> But I think this means k is broken.
15:39:51 <Deewiant> The reason it doesn't say BAD is because your stringmode is broken
15:40:12 <elliott> Deewiant: I thought the CCBI behaviour _was_ to advance before executing it.
15:40:18 <ais523> Deewiant: apparently you don't check for broken stringmode early enough
15:40:29 <elliott> ais523: it takes skill to break stringmode as badly as I have
15:40:33 -!- ais523 has left (?).
15:40:36 <Deewiant> I know, I forgot to do it for the Befunge-98 half so I inserted it after k
15:40:41 -!- ais523 has joined.
15:40:42 <Deewiant> I know, I forgot to do it for the Befunge-98 half so I inserted it after k
15:40:49 <ais523> EgoBot: I thought you just ignored spaces?
15:41:22 <elliott> Yay, I think I've fixed it.
15:42:09 <Deewiant> Hmm, I wonder if I can get away with ; instead of " there
15:42:31 <elliott> Couldn't match expected type `s -> a' against inferred type `IP'
15:42:32 <ais523> have you tested ; by that point?
15:42:32 <elliott> In the first argument of `gets', namely `ip'
15:42:45 <ais523> elliott: never use gets, it's deprecated and inherently a security hole
15:42:49 -!- Phantom_Hoover has joined.
15:43:05 <elliott> Deewiant: I just hope he's actually joking :P
15:43:10 <ais523> elliott: I am, obviously
15:43:23 <elliott> ais523: hey, 2007-you would have said that seriously. maybe.
15:43:28 <ais523> the "deprecated" was intended to make sure
15:43:48 <ais523> but even a C-style gets would be safe in Haskell
15:44:07 <elliott> the second gets uses the first ip as the function
15:44:10 <elliott> because of the name clash :D
15:46:23 <elliott> "For all fingerprints involving vectors, RC/Funge-98 doesn't, for some
15:46:23 <elliott> reason, use the IP's storage offset."
15:46:34 <Deewiant> In practice, though, I'd expect people to fix their "" as soon as they see the messed up messages. :-P
15:47:06 <elliott> Deewiant: ooh just realised something
15:47:12 <elliott> Deewiant: my removing spaces from fungespace on load is a fail
15:47:23 <elliott> Deewiant: because it means it has to go through the is-it-in-the-map procedure before returning 32
15:47:29 <elliott> almost identical behaviour i think
15:47:53 <Deewiant> The tests don't assume that behaviour, but neither do they depend on it
15:48:23 <elliott> Deewiant: Hmm, I disagree with your interpretation of #
15:48:31 <elliott> Consider an IP starting at (0,0) with a delta of (2,0)
15:48:40 <elliott> It STANDS TO REASON that the IP's position is always (2n,0) for integer n.
15:48:43 -!- Phantom_Hoover has quit (Ping timeout: 240 seconds).
15:48:53 <ais523> elliott: doesn't Deewiant's # interpretation do that?
15:48:54 <elliott> Therefore, after traversing the infinite Lahey space line magic, it arrives at the other side at (0,0).
15:49:05 <elliott> I don't see how wrapping and # are any different, though.
15:49:09 <elliott> I don't see how wrapping and # are any different, though.
15:49:22 <elliott> Why does wrapping end up past the start of the line because of the delta, and # not?
15:49:35 <elliott> loop (x,y) (dx,dy) (mx,my)
15:49:35 <elliott> | x `ltx` mx && y `lty` my = (mx+dx, my+dy)
15:49:41 <elliott> i.e., for positive dx and dy:
15:49:45 <elliott> if x < maximumx and y < maximumy
15:49:59 <elliott> then resulting position is (minimum x + dx, minimum y + dy)
15:50:00 <Deewiant> You don't necessarily hit the start of the line
15:50:11 <Deewiant> But with a delta of (1,0) you of course do
15:50:54 <elliott> Deewiant: Then I don't see why my interpretation of # as advance is wrong. Sure, it wraps but OHHH
15:51:07 <elliott> It can advance, making it wrap, and will then go to the next instruction.
15:51:09 <elliott> OK, I think I can fix that.
15:51:53 <elliott> doCharIns '#' = modifyRay (\Ray (x,y) (dx,dy) -> (x+dx,y+dy))
15:52:04 <Deewiant> # as advance is completely correct, it's just that the way you do wrapping with the bounds rectangle it works a bit weirdly
15:52:21 <elliott> Deewiant: I thought your trace showed that k did advance to the instruction before executing it.
15:52:39 <Deewiant> 2011-02-07 14:25:42 ( Deewiant) elliott: For the record, this behaviour follows from the impl "move IP; if (arg==0) return; get next instruction; move IP back; while (arg--) execute instruction;"
15:52:54 -!- Phantom_Hoover has joined.
15:54:31 <elliott> I've removed the flush and it seems to be going slower because I don't see the incremental character-typing. :P
15:56:45 <Deewiant> So add it back, it's more fun that way :-P
15:58:14 <elliott> Strangely, the "GOOD: , works" line appears faster than the "GOOD: : duplicates" one. :D
15:58:32 <Deewiant> GOOD: , works can't rely on : working yet, so it can't use a loop.
15:58:51 <ais523> flushes hardly slow down a program that isn't I/O bound anyway
15:58:53 <elliott> Deewiant: ...That is amazing.
15:59:01 <elliott> Deewiant: That is possibly my favourite slowdown ever.
15:59:04 <Deewiant> So it outputs at 1 char/tick instead of 1 char/7 ticks or so, I forget the loop's speed
15:59:10 <ais523> I use them in pretty much all my esolang interps, on the basis that esolangs are basically never I/O-bound
15:59:17 <Deewiant> If it's the right-to-left loop it's like 1 char/11 ticks
15:59:25 <elliott> ais523: Befunge-98 IO is character-based, though.
15:59:35 <elliott> So flushing is quite more dramatic than e.g. flushing after Underload's S :P
15:59:44 <Deewiant> Flushes aren't exactly zero-cost for CPU anyway.
15:59:53 <elliott> Deewiant: I think my talk about no premature optimisation was a bit much.
16:00:00 <elliott> How long is the typical Mycology output? :P
16:00:04 <ais523> Deewiant: no, but the length of time they take is proportional to the amount of I/O you do
16:00:16 <ais523> so they hurt I/O-bound programs much more than CPU-bound programs
16:00:45 <ais523> (this morning, I was learning about GPU-bound programs, and how they can either be memory-bound or thread-bound)
16:00:51 <elliott> There are plenty CPU-bound programs that do a lot of IO while computing. :P
16:00:55 <Deewiant> $ ccbi -f-all mycology.b98| wc -c
16:01:10 <elliott> Shouldn't take long to check, since your interpreter is INSTANT and all.
16:01:13 <Deewiant> $ ccbi -f-all mycology.b98| wc
16:01:35 <elliott> G O O D : i n s t r u c t i o n s b e t w e e n ; a r e s k i p p e d
16:01:39 <elliott> ^ Representation of how slow this is going.
16:01:40 <Deewiant> If you remove all the tmp files
16:01:56 <elliott> Deewiant: It changes depending on the run? :P
16:02:10 <Deewiant> Without FILE it can't remove the tmp files that it uses to test i and o
16:02:15 <elliott> I'm assuming that's the line count. Wait, no.
16:02:21 <elliott> What are wc's counts again?
16:02:39 <elliott> I forgot that wc can count actual words. :P
16:02:43 <elliott> UNDEF: # across left edge hits easternmost cell in file
16:02:43 <elliott> UNDEF: # across left edge hits easternmost cell on line
16:02:50 <elliott> Deewiant: That's the way, uh-huh uh-huh, you like it, uh-huh uh-huh?
16:04:03 <elliott> Deewiant: Ha, it now does the 0 as part of the ORTHOGONAL case.
16:04:11 <elliott> then replicateM_ (fromIntegral (abs n + 1)) (advance >> toNextIns)
16:04:11 <elliott> let insIP = nextInsPos fs (nextIPPos fs (ip st))
16:04:15 <elliott> replicateM_ (fromIntegral n) (doIns =<< peek pos)
16:05:08 <Deewiant> s/fromIntegral (abs n + 1)/fromEnum (n == 0)/ and you're good to go
16:05:20 <elliott> Deewiant: My behaviour is perfectly legal!
16:05:30 <elliott> Deewiant: Also, that would make -1kx execute x.
16:05:33 <ais523> elliott: see if you can get your interp powerful enough to handle fungot reliably
16:05:34 <fungot> ais523: before learning your second language, have a huge pile of ideas in my head
16:05:37 <elliott> Which I guess is appealing, in a way :P
16:05:49 <ais523> fungot: it's a little late for that...
16:05:49 <fungot> ais523: you can still scroll the waves forward until the cone positions match
16:05:56 <elliott> Deewiant: Wanna run this on your machine so I can find out what's the next thing that's wrong before the sun goes cold? :-D
16:06:11 <elliott> ais523: fungot is mainly an exercise in implementing fingerprints.
16:06:12 <Deewiant> Mine probably won't be that much faster, but sure, if you want.
16:06:23 <ais523> elliott: indeed, although you need to get the basics working too
16:06:44 <ais523> which was possibly meant to be a joke
16:07:13 <elliott> Deewiant: Uploading shiro to sprunge now.
16:07:23 <elliott> I would feel guilty about the abuse of web space, but it's Google's.
16:07:35 <elliott> elliott@elliott-MacBookAir:~/Code/shiro$ uuencode shiro 755 <shiro|curl -F 'sprunge=<-' sprunge.us
16:07:35 <elliott> elliott@elliott-MacBookAir:~/Code/shiro$
16:08:00 <elliott> Deewiant: Got the ability to set up an nc -l -e 'cat >file' on a port? :P
16:08:09 -!- zzo38 has joined.
16:08:17 <elliott> http://catseye.tc/projects/funge98/library/TOYS.html aaaargh
16:08:18 <ais523> elliott: why is pastebinning an interp an abuse of web space?
16:08:45 <elliott> elliott@elliott-MacBookAir:~/Code/shiro$ cat shiro | nc tar.us.to 1234
16:08:46 <elliott> elliott@elliott-MacBookAir:~/Code/shiro$
16:08:53 <elliott> ais523: because it was a uuencoded binary
16:08:59 <Deewiant> I just ran that command, I don't know how nc works
16:09:07 <ais523> elliott: of a Haskell program?
16:09:18 <elliott> ais523: a 1.5 megabyte-before-uuencoding binary
16:09:21 <elliott> Deewiant: I'll just upload it :P
16:09:23 <Deewiant> Oh, it took that as a hostname
16:09:26 <elliott> ais523: Requires more than a few lirbaries.
16:09:51 <elliott> Deewiant: 1541637 bytes according to wc -c is the magic number you need to kill it at.
16:10:02 -!- asiekierka has quit (Ping timeout: 250 seconds).
16:10:29 <elliott> Deewiant: Now cd to mycology.b98 and run it.
16:10:35 <elliott> (The directory with mycology.b98 in it, that is.)
16:10:38 <Deewiant> ../shiro: error while loading shared libraries: libgmp.so.3: cannot open shared object file: No such file or directory
16:10:52 <elliott> Deewiant: You want a static binary? :P
16:11:06 <elliott> Deewiant: Oh, I'm sorry, I'm just OLD-FASHIONED.
16:11:22 <Deewiant> So yeah, I suggest the static binary :-P
16:11:53 <elliott> Deewiant: Well, it's 2.6 megs.
16:12:17 <elliott> Deewiant: IIRC Haskell binaries do not like being stripped.
16:12:30 <elliott> Sending the non-stripped one now.
16:13:25 <Deewiant> I see you use the basename of the path
16:13:30 <Deewiant> $ time ../shiro ~/programming/projects/mycology/mycology.b98
16:13:30 <Deewiant> shiro: mycology.b98: openBinaryFile: does not exist (No such file or directory)
16:13:39 <elliott> <elliott> Deewiant: Now cd to mycology.b98 and run it.
16:13:40 <elliott> <elliott> (The directory with mycology.b98 in it, that is.)
16:13:44 <elliott> There's no command-line interface.
16:13:56 <Deewiant> Oh, it doesn't take a parameter at all, heh.
16:14:37 -!- oerjan has joined.
16:14:42 <Deewiant> I can quite conclusively say that Language::Befunge is not this slow.
16:14:46 <ais523> I nearly facepalmed to death today due to misinterpreting what someone said
16:15:05 <elliott> Deewiant: Yes. For maximum slowness, you need Shiro!
16:15:15 <ais523> they'd done a crazy hack that involved mapping someone else's hostname to 127.0.0.1, thus using their own computer as a proxy to it by setting up a tunnel there on port 443
16:15:16 <oerjan> ais523: did you get a concussion?
16:15:25 -!- asiekierka has joined.
16:15:36 <ais523> but I heard it backwards, and thought that what they'd said was that they'd remapped 127.0.0.1 to instead go to the other person's website
16:15:37 <elliott> how did you misinterpret it?
16:15:49 <elliott> Deewiant: HAS IT CRASHED YET
16:15:52 <ais523> which would have been truly insane
16:17:28 <elliott> Shiro has in fact slowed down time as experienced by Deewiant.
16:17:29 <ais523> and my thoughts were along the lines of "is that even possible" and "what effect would that have on a computer"
16:17:58 <ais523> I'm half-tempted to actually figure out how to do it and do it to see what happens, but I don't really want to and anyway wouldn't put in enough effort to accomplish anything
16:18:05 <oerjan> 14:04:44 <elliott> ais523: oerjan is right dammit
16:18:05 <oerjan> 14:04:47 <elliott> I just started reading a random log
16:18:29 <ais523> oerjan: elliott read you talking to him about how he started and never finished Befunge-98 interps in Haskell
16:18:30 <Deewiant> elliott: It's gone a bit quiet after 4k #
16:18:41 <elliott> oerjan: pick a random log the day after I start writing a befunge-98 interpreter in Haskell while talking to ais523, it's me talking to ais523 about implementing a befunge-98 interpreter in haskell
16:18:50 <elliott> Deewiant: Paste the last few lines?
16:18:58 <Deewiant> GOOD: 4k # jumps 4 times from k
16:19:07 <elliott> Deewiant: Do you know what the next test is? :P
16:19:28 <Deewiant> $ ccbi mycology.b98| head -n30 | tail -n5
16:19:33 <Deewiant> GOOD: 4k # jumps 4 times from k
16:19:34 <Deewiant> GOOD: 2k ;;;5 executes 5 thrice
16:19:34 <Deewiant> GOOD: ak47k$ leaves 3 fours on stack
16:20:06 <elliott> Deewiant: Likely I have a bug in my ;-skipper, then.
16:20:15 <elliott> That ;;;; is like /**//**/, right?
16:21:04 <Deewiant> The "comment" started by the third ; is closed by the first ; after wraparound
16:21:16 <elliott> Deewiant: That's... disgusting :-D
16:21:43 <elliott> Deewiant: Is it still running?
16:21:48 <elliott> I think it's running to the right edge of the playfield.
16:21:52 <Deewiant> I ^C'd it to get you that output.
16:21:58 <elliott> Deewiant: OK, let me explain.
16:22:02 <elliott> Deewiant: You know how slow one tick goes?
16:22:06 <elliott> i.e. the first GOOD output.
16:22:21 <elliott> Deewiant: It's doing that, times the width of the playfield at the point.
16:22:25 <elliott> Deewiant: Which is O(slow).
16:22:32 <elliott> Deewiant: Think you've got the patience to wait it out? :-P
16:22:40 <Deewiant> It should be far less instructions than have been run at that point.
16:22:49 <Deewiant> And ; should be faster than running something anyway
16:22:52 <elliott> Deewiant: Yes, but it's going to be silent all the way.
16:22:55 <Sgeo> I am bored. I am a goban.
16:22:56 <elliott> Deewiant: It's not about the running.
16:22:58 <elliott> Deewiant: The actual execution is fast.
16:23:05 <elliott> Deewiant: It's the fact that every time you go forwards, it re-calculates the bounds.
16:23:09 <elliott> Including as part of the loop.
16:23:17 <elliott> SOME MIGHT SAY that this is retarded.
16:23:25 <elliott> SOME MIGHT SAY that I might fix it right now.
16:23:33 <elliott> Deewiant: But do you wanna wait it out while I fix it? :P
16:23:39 <Deewiant> It'll be faster for you to fix it than for me to run it until it gets further
16:23:44 <elliott> It'll just be a temporary fix, since the real thing to do is:
16:23:49 <Deewiant> It was at 6 minutes when I killed it
16:23:54 -!- cheater- has quit (Ping timeout: 240 seconds).
16:23:55 <elliott> TODO: Add cached bounds arrays indexed by row and column.
16:24:40 <pikhq> And my procrastination is successful again.
16:24:50 -!- cheater- has joined.
16:25:12 <pikhq> I keep getting rewarded for putting stuff off until the last minute by being able to actually get it done without trouble.
16:25:37 <ais523> wow: http://www.schneier.com/blog/archives/2011/02/uk_immigration.html
16:26:15 <ais523> summary: someone working for UK immigration put his wife on the no-fly list while she was abroad, in order to get rid of her
16:26:26 <Sgeo> pikhq, welcome to my world
16:26:46 <elliott> Deewiant: Open the port again :P
16:26:49 <pikhq> Sgeo: Oh, shaddup, you aren't even getting a real degree.
16:27:02 <ais523> although people have accused Schneier's sources of being unreliable
16:27:08 <elliott> He's getting a cheap plastic imitation of a degree!
16:27:27 <Sgeo> elliott, everyone here gets the reference
16:31:44 <elliott> Deewiant: It should wrap pretty quickly.
16:31:49 <elliott> It's just busy-looping, basically.
16:31:53 <elliott> Rather than bound-counting.
16:32:03 <elliott> Deewiant: Most of it should just be a straight addition loop until it wraps.
16:33:27 <elliott> Deewiant: OMGGGGGGGGGGG HOW IS IT DOIIIIIINGGGG
16:33:28 <zzo38> ais523: Do you think his wife will go on the boat if she is not allowed in airplane flying?
16:33:51 <elliott> Clearly she will go on the boat.
16:34:15 <ais523> how does it take three minutes to do "4k #"?
16:34:20 <elliott> ais523: it already did that
16:34:28 <elliott> ais523: it's 2k ;;;5 which takes a long time
16:34:50 <ais523> also, 2k ;;;5 on a line by itself? ouch
16:34:57 <elliott> ais523: on a line with other things
16:35:05 <ais523> any of them semicolons?
16:35:27 <elliott> Deewiant: Are you having fun
16:35:50 <Deewiant> I'm not exactly staring at it waiting for something to happen
16:38:20 <Deewiant> I'm unconvinced that anything's going to happen today; how're your optimizations doing
16:38:35 <elliott> Deewiant: Seriously, this should be not too slow...
16:38:38 <elliott> It's basically a busyloop.
16:38:55 <Deewiant> Sure it's not an infinite busyloop with the semicolons like that? :-P
16:38:59 <oerjan> ais523: what do you think of my recent changes to the Underload page?
16:39:15 <ais523> oerjan: I like them, it's an improvement
16:39:18 <elliott> Deewiant: I very much doubt it.
16:39:24 <elliott> oerjan: eek, you changed things?
16:39:31 <ais523> although you don't mention explicitly that stacks go bottom at the left to top at the right, which is the Underload convention
16:39:39 <ais523> elliott: he improved the documentation on the basic commands
16:39:41 <Deewiant> You're right, it's not infinite, but it is slow
16:39:44 <elliott> well specifically the Commands section
16:39:56 <elliott> Deewiant: You STOPPED IT? HOW COULD YOU
16:40:11 <Deewiant> But it's at 12 minutes of CPU time
16:40:18 * elliott resists urge to revert oerjan's change
16:40:40 <oerjan> elliott: i copied the layout from the Glass page, although the stack effect notation is slightly changed (similarly to in my "lambda" notation, they are of course related)
16:40:48 <elliott> ALWAYS WITH THE EXCUSES FOR UGLINESS
16:41:14 <Deewiant> elliott: Seriously, profile it :-P
16:41:26 <oerjan> elliott: of course i was the one who made that layout for the Glass page in the first place
16:41:26 <elliott> Deewiant: I have absolutely no idea how to do profiling with ghc.
16:41:38 <Deewiant> http://www.google.com/search?q=ghc%20profiling oh look it's the first result
16:41:49 <elliott> Deewiant: Sorry, let me rephrase: Fuck you :P
16:42:34 <elliott> Deewiant: Will that work if I ^C it?
16:42:36 <Deewiant> And grab like only the befunge-93 area of Mycology because that'll take a while
16:43:05 <elliott> CAF Main 274 61 0.0 0.0 98.5 98.4
16:43:05 <elliott> <*>_a4Zn Shiro.Monad 414 1 0.0 0.0 0.0 0.0
16:43:05 <elliott> stackStack Shiro.Monad 425 2 0.0 0.0 0.0 0.0
16:43:21 <elliott> Deewiant: Err, is this thing ordered by any useful metric at all?
16:43:39 <elliott> I *think* it's higher is more used.
16:43:45 <elliott> Bounds time is 86% which is no surprise.
16:43:50 <elliott> I'll try strictness-peppering.
16:44:23 <Deewiant> Get rid of the bounds crap :-P
16:44:31 <elliott> Deewiant: That would be Really Hard.
16:44:36 <elliott> Deewiant: As in, not right now :P
16:44:42 <Deewiant> At least don't do it on every iteration of loop
16:45:18 <elliott> Deewiant: If you just remove *.o files and not *.hi files, does it not recompie?
16:45:24 <elliott> Oh, no, .hi is just the interface.
16:45:48 <Deewiant> If it says [ 1 of 1] compiling foo.hs then it recompiles
16:45:55 <elliott> What do you need to enable to be able to use !Foo in types again?
16:46:00 <Deewiant> If it just says "linking exec" then it didn't
16:46:02 <oerjan> ais523: i put parentheses around the variables because i think it's more intuitively useful in practice, it gives the whole stack change/lambda notation a meaning of "running this command/program after the program to the left changes the result into the program on the right." Although the S case slightly breaks that.
16:46:13 <Deewiant> I don't know, I don't use types that much :-P
16:46:39 <ais523> oerjan: indeed, my first Underload interp actually worked more or less directly on the principle there
16:46:48 <ais523> it's just, it probably needs to be explained to people who don't know Underload
16:47:17 <ais523> on the basis that they're the people who need to be told how the lang works, people who do know Underload already know
16:47:58 <elliott> Deewiant: OK, I give in, I'll add bounds information.
16:48:00 <ais523> !bf joust test >>(+)*100000
16:48:24 <ais523> elliott: how did you get as far as you could without it?
16:48:28 <ais523> !bfjoust test >>(+)*100000
16:48:35 <oerjan> ais523: hm do you mean you used those as rewriting rules on the program? because that should be possible.
16:48:39 <elliott> ais523: By calculating bounds all-the-fucking-tmie.
16:48:41 <ais523> oerjan: yep, pretty much
16:48:43 <Deewiant> ais523: He recalculated it every time anything moved
16:48:51 <ais523> by looping over every cell in fungespace?
16:48:51 <Deewiant> I.e. the IP or any intermediate vector
16:49:02 <ais523> also, when the /IP/ moves?
16:49:15 <elliott> It was impressively slow. :)
16:49:16 <Deewiant> And in k, presumably, when fetching the next instruction etc
16:49:32 <elliott> Now to go from rowBounds and colBounds to bounds.
16:50:15 <elliott> , rowBounds :: Map Value (Value,Value) -- min, max
16:50:16 <elliott> , colBounds :: Map Value (Value,Value) }
16:50:19 <elliott> That's not the ideal structure, is it?
16:50:23 -!- impomatic has joined.
16:50:25 <elliott> I don't see how to go from that to minimum and maximum coordinates.
16:50:32 <EgoBot> Score for ais523_test: 0.0
16:51:17 <ais523> I think it draws some runs and loses others
16:51:21 <ais523> I was just curious to see what would happen
16:51:30 <ais523> actually, wait, why doesn't that draw with defend7?
16:51:51 <ais523> just doesn't score any points from that
16:52:17 <ais523> heh, there are a couple of new programs by impomatic on the hill since I last looked
16:52:22 <ais523> any particular ingenious strategies in them?
16:52:46 <ais523> oh, and some of Lymia__'s evo programs finally got onto the leaderboard
16:53:22 <ais523> the side-effects seem to be the death of defend9 and vibration (finally), and defend7 winning
16:53:49 <lambdabot> forall b a. b -> (a -> b) -> Maybe a -> b
16:54:26 <impomatic> Although I got a confusing score from one of the new ones -> http://twitpic.com/3xcqje
16:54:27 <ais523> elliott: cpressey replied to your questions on the wiki, btw
16:54:52 -!- Sgeo has quit (Ping timeout: 255 seconds).
16:54:55 <ais523> impomatic: looks like you have the same client bug as Mibbit
16:55:37 <ais523> I should try to come up with another jouster along the lines of defend7/defend9, but it's hard to improve on the relative simplicity of the defend7 formula
16:55:44 <impomatic> 9.9 " 9 . 9 " displays as a smilie
16:56:11 <elliott> Couldn't match expected type `Map Value (Value, Value)'
16:56:12 <elliott> against inferred type `Map
16:56:12 <elliott> (Map Value (Value, Value)) (Value, Value)
16:56:12 <elliott> -> Map (Map Value (Value, Value)) (Value, Value)'
16:56:18 <ais523> in fact, I only recently realised why defend7 works as well as it does (it's mostly because 256 is a power of 2)
16:57:53 <ais523> even so, it's beaten by various slow rushes; it's just that slow-rushing seems to be quite a bad strategy on the current hill for whatever reason
16:57:53 -!- Behold has joined.
16:58:08 <ais523> (even though myndzi_slowrush is second; it must be a very good slow rush)
16:58:34 <lambdabot> forall a k. (Ord k) => (Maybe a -> Maybe a) -> k -> M.Map k a -> M.Map k a
16:59:25 <ais523> wow, defend7 has been on the hill for over a year
16:59:52 <ais523> along with a few other programs that aren't mine
17:00:04 <elliott> hmm, I have a feeling my row code is broken
17:01:09 -!- BeholdMyGlory has quit (Ping timeout: 250 seconds).
17:01:21 <Ilari> Xe180He8O0PW118eeeQQQ118Q1O 08DO
17:01:29 <oerjan> ais523: ok now it got _really_ ugly, is there a better way to format that...
17:01:39 <elliott> yes, by killing it with fire :D
17:01:54 <oerjan> ais523: underload page
17:02:23 <Ilari> Wonder what TECO would do with code like that.
17:02:38 <oerjan> i considered a table, except i vaguely recall i considered it for glass and decided against it...
17:02:39 <ais523> I only poll that every 15 minutes or so
17:02:54 <impomatic> Oh, I appear to have the oldest on the hill, survived 21 months :-)
17:03:21 <oerjan> ais523: well i didn't think the conversation had ended properly, so i didn't bother adding context...
17:03:56 <ais523> it hadn't, just I'd dumped the conversation state from mental cache in order to make room for other things
17:04:09 <ais523> so I needed to reload the information that would have been cached from other users of the channel
17:04:18 <oerjan> INSUFFICIENT SHORT-TERM MEMORY FOR IRCING
17:06:13 <elliott> Deewiant: Jumps straight to
17:06:14 <elliott> GOOD: 4k # jumps 4 times from k
17:06:51 <Deewiant> I'll assume this is an infloop then
17:07:33 <elliott> Deewiant: Time to add debugge magick.
17:09:03 <elliott> Deewiant: Queer, it finds the end of the semicolon.
17:10:48 <ais523> hmm, are Lymia__'s evobots based on the current hill? or an old hill? or something else?
17:11:17 <Deewiant> The top 10 from a short while ago IIRC
17:11:44 <ais523> on the assumption that they can push off the bottom 10?
17:11:53 <elliott> Ugh, it's even buggy, For some reason it's doin' it rong.
17:12:03 <ais523> if they're based on mine, it's a little hilarious that they pushed defend7 up to the top
17:12:06 <elliott> afterSemicolon IP {ray = Ray (606,40) (1,0), isStringMode = False} (32)
17:12:06 <elliott> afterSemicolon IP {ray = Ray (607,40) (1,0), isStringMode = False} (32)
17:12:06 <elliott> afterSemicolon IP {ray = Ray (608,40) (1,0), isStringMode = False} (32)
17:12:06 <elliott> afterSemicolon IP {ray = Ray (609,40) (1,0), isStringMode = False} (32)
17:12:06 <elliott> afterSemicolon IP {ray = Ray (610,40) (1,0), isStringMode = False} (32)
17:12:06 <elliott> afterSemicolon IP {ray = Ray (611,40) (1,0), isStringMode = False} (32)
17:12:08 <ais523> as that program was in the set
17:12:08 <elliott> afterSemicolon IP {ray = Ray (612,40) (1,0), isStringMode = False} (32)
17:12:13 <elliott> Oh, I think I'm not taking advantage of my special bounds functions.
17:12:39 <Deewiant> In the x-direction it's at 180 :-P
17:13:06 <elliott> I'm going to assume that nextIPPosWithBounds is broken.
17:15:18 <elliott> loop (-1528,40) (1,0) (0,0)
17:15:31 <elliott> loop (-3436,40) (1,0) (0,0)
17:16:02 <elliott> loop :: Vector -> Vector -> Vector -> Vector
17:16:02 <elliott> loop (x,y) (dx,dy) (mx,my)
17:16:02 <elliott> | trace ("loop " ++ show (x,y) ++ " " ++ show (dx,dy) ++ " " ++ show (mx,my)) False = undefined
17:16:02 <elliott> | x `ltx` mx && y `lty` my = (mx+dx, my+dy)
17:16:02 <elliott> | x `gtx` mx || y `gtx` my = loop (x-dx, y-dy) (dx,dy) (mx,my)
17:16:07 <elliott> where ltx, gtx, lty, gty :: Value -> Value -> Bool
17:16:26 <elliott> let mx = posneg dx mnx mxx
17:17:03 <elliott> although i recall that broke something
17:17:47 <elliott> About to test division by zero...
17:17:50 <elliott> Deewiant: It's totally bitchin' fast now.
17:17:58 <ais523> !bfjoust tripwire3 >(-)*5>(+)*5(>)*7[(>)*3(>[-]+)*5(.)*100000](>[>[-]+])*18>>[[+]]
17:18:03 <EgoBot> Score for ais523_tripwire3: 3.9
17:18:16 <Deewiant> (.)*100000 seems a bit... excessive
17:18:20 <elliott> Deewiant: Although I don't currently shrink bounds.
17:18:34 <ais523> that one seems good vs. Lymia__ and impomatic, and bad vs. everyone else
17:18:43 <elliott> Deewiant: What should rem-0 be in funge? Taking /0 = 0 and thus 0?
17:19:08 <Deewiant> "Remainder by zero is subject to the same rules as division by zero"
17:19:30 <elliott> It doesn't _push_ ], z, [ to the stack.
17:20:47 <EgoBot> Score for impomatic_wait: 0.0
17:20:48 <elliott> BAD: wraparound with non-cardinal delta doesn't work
17:20:49 <elliott> BAD: { reflected, maybe ran out of memory
17:20:49 <Deewiant> elliott: w makes more sense now? :-D
17:20:56 <elliott> Deewiant: I haven't implemented {, but that first one... ffffuuu
17:21:00 <elliott> Also, yes, a lot more sense :P
17:21:12 <elliott> I thought you were meant to like, p it somewhere in your path.
17:21:33 <ais523> !bfjoust stridewire (>)*9[(-----[+]>)*20[[+]]]>>[(-----[+]>)*18[[+]]]>>[(-----[+]>)*16[[+]]]>>[(-----[+]>)*14[[+]]]>>[(-----[+]>)*12[[+]]]>>[(-----[+]>)*10[[+]]]>>[(-----[+]>)*8[[+]]]>>[(-----[+]>)*6[[+]]]>>[(-----[+]>)*4[[+]]]>>[(-----[+]>)*2[[+]]]>[[+]]>[[+]]>[[+]]
17:21:36 <EgoBot> Score for ais523_stridewire: 21.6
17:22:54 <ais523> I wonder if I change the stride to 3?
17:23:08 <elliott> Deewiant: I like that "maybe ran out of memory" part.
17:23:37 <ais523> !bfjoust stridewire (>)*9[(-----[+]>)*20[[+]]]>>>[(-----[+]>)*17[[+]]]>>>[(-----[+]>)*14[[+]]]>>>[(-----[+]>)*11[[+]]]>>>[(-----[+]>)*8[[+]]]<>>[(-----[+]>)*5[[+]]]>>>[(-----[+]>)*2[[+]]]>[[+]]>[[+]]>[[+]]
17:23:39 <EgoBot> Score for ais523_stridewire: 19.2
17:23:48 <ais523> yep, 2's probably better there
17:23:53 <ais523> !bfjoust stridewire (>)*9[(-----[+]>)*20[[+]]]>>[(-----[+]>)*18[[+]]]>>[(-----[+]>)*16[[+]]]>>[(-----[+]>)*14[[+]]]>>[(-----[+]>)*12[[+]]]>>[(-----[+]>)*10[[+]]]>>[(-----[+]>)*8[[+]]]>>[(-----[+]>)*6[[+]]]>>[(-----[+]>)*4[[+]]]>>[(-----[+]>)*2[[+]]]>[[+]]>[[+]]>[[+]]
17:23:57 <EgoBot> Score for ais523_stridewire: 21.4
17:24:29 <EgoBot> Score for impomatic_wait: 5.4
17:25:00 <ais523> because sacrificing 1/3 of the games for a small improvement on the other 2/3 makes it worse against bots it was close to beforehand
17:25:05 <ais523> what about if I add decoys?
17:25:24 <ais523> !bfjoust stridewire >>++>--(>)*6[(-----[+]>)*20[[+]]]>>[(-----[+]>)*18[[+]]]>>[(-----[+]>)*16[[+]]]>>[(-----[+]>)*14[[+]]]>>[(-----[+]>)*12[[+]]]>>[(-----[+]>)*10[[+]]]>>[(-----[+]>)*8[[+]]]>>[(-----[+]>)*6[[+]]]>>[(-----[+]>)*4[[+]]]>>[(-----[+]>)*2[[+]]]>[[+]]>[[+]]>[[+]]
17:25:28 <EgoBot> Score for ais523_stridewire: 14.9
17:25:52 <ais523> heh, it's surprising how much worse the small decoys make it, although that doesn't surprise me at all given the principle behind stridewire
17:25:57 <ais523> !bfjoust stridewire >>>--(>)*6[(-----[+]>)*20[[+]]]>>[(-----[+]>)*18[[+]]]>>[(-----[+]>)*16[[+]]]>>[(-----[+]>)*14[[+]]]>>[(-----[+]>)*12[[+]]]>>[(-----[+]>)*10[[+]]]>>[(-----[+]>)*8[[+]]]>>[(-----[+]>)*6[[+]]]>>[(-----[+]>)*4[[+]]]>>[(-----[+]>)*2[[+]]]>[[+]]>[[+]]>[[+]]
17:26:01 <EgoBot> Score for ais523_stridewire: 15.4
17:26:13 <ais523> !bfjoust stridewire (>)*9[(-----[+]>)*20[[+]]]>>[(-----[+]>)*18[[+]]]>>[(-----[+]>)*16[[+]]]>>[(-----[+]>)*14[[+]]]>>[(-----[+]>)*12[[+]]]>>[(-----[+]>)*10[[+]]]>>[(-----[+]>)*8[[+]]]>>[(-----[+]>)*6[[+]]]>>[(-----[+]>)*4[[+]]]>>[(-----[+]>)*2[[+]]]>[[+]]>[[+]]>[[+]]
17:26:16 <EgoBot> Score for ais523_stridewire: 21.4
17:26:27 <ais523> first time I've ever seen a BF Joust program drop significantly in the ranking upon adding decoys
17:27:23 <elliott> Deewiant: What the fuck is { for?
17:27:31 <ais523> !bfjoust stridewire_faster (>)*9[([+]>)*20[[+]]]>>[([+]>)*18[[+]]]>>[([+]>)*16[[+]]]>>[([+]>)*14[[+]]]>>[([+]>)*12[[+]]]>>[([+]>)*10[[+]]]>>[([+]>)*8[[+]]]>>[([+]>)*6[[+]]]>>[([+]>)*4[[+]]]>>[([+]>)*2[[+]]]>>[[+]]>[[+]]>[[+]]
17:27:35 <EgoBot> Score for ais523_stridewire_faster: 13.7
17:27:49 <Deewiant> It's actually a lot more useful than I first thought it would be
17:28:10 <ais523> !bfjoust stridewire_faster (>)*11[([+]>)*18[[+]]]>>[([+]>)*16[[+]]]>>[([+]>)*14[[+]]]>>[([+]>)*12[[+]]]>>[([+]>)*10[[+]]]>>[([+]>)*8[[+]]]>>[([+]>)*6[[+]]]>>[([+]>)*4[[+]]]>>[([+]>)*2[[+]]]>>[[+]]>[[+]]>[[+]]
17:28:11 <Deewiant> I use it throughout the fingerprint testing code now so that I can add a fingerprint in between (so that it's in alphabetical order) without breaking all the g/p positioning
17:28:13 <EgoBot> Score for ais523_stridewire_faster: 7.5
17:28:27 <ais523> OK, it really does need to work on /all/ tape lengths, I think
17:28:30 <ais523> !bfjoust stridewire_faster (>)*9[([+]>)*20[[+]]]>>[([+]>)*18[[+]]]>>[([+]>)*16[[+]]]>>[([+]>)*14[[+]]]>>[([+]>)*12[[+]]]>>[([+]>)*10[[+]]]>>[([+]>)*8[[+]]]>>[([+]>)*6[[+]]]>>[([+]>)*4[[+]]]>>[([+]>)*2[[+]]]>>[[+]]>[[+]]>[[+]]
17:28:34 <EgoBot> Score for ais523_stridewire_faster: 13.7
17:28:50 <impomatic> !bfjoust wait []+.+.+.+.(+)*128(>[-])*30
17:28:55 <elliott> Deewiant: Wait, nobody told me I'd have to keep track of a storage vector.
17:28:57 <EgoBot> Score for impomatic_wait: 5.4
17:28:58 <elliott> Deewiant: Why didn't you tell me this.
17:29:13 <EgoBot> Score for impomatic_wait: 5.4
17:29:15 <ais523> also, I don't get how defend7 beats stridewire
17:29:38 <ais523> !bfjoust stridewire (>)*9[(-----[+]>)*20[[+]]]>>[(-----[+]>)*18[[+]]]>>[(-----[+]>)*16[[+]]]>>[(-----[+]>)*14[[+]]]>>[(-----[+]>)*12[[+]]]>>[(-----[+]>)*10[[+]]]>>[(-----[+]>)*8[[+]]]>>[(-----[+]>)*6[[+]]]>>[(-----[+]>)*4[[+]]]>>[(-----[+]>)*2[[+]]]>>[[+]]>[[+]]
17:29:45 <EgoBot> Score for ais523_stridewire: 21.4
17:29:53 <Deewiant> elliott: I was going to tell you about it when you said you need stringmode but then you distracted me with the position+delta naming thing
17:30:03 <ais523> I may run that one offline to see what happens
17:30:05 <elliott> Deewiant: Is this offset stuff per-IP?
17:30:25 <Deewiant> Your IP structure is only going to grow, live with it :-P
17:30:29 <elliott> Deewiant: Have I ever told you how much I hate you? :D
17:30:41 <elliott> Deewiant: I might want to make IP extensible in the same way as the generic state structure, for fingerprints, the way this is going...
17:30:57 <EgoBot> Score for impomatic_wait: 5.4
17:30:57 <Deewiant> You'll need in addition to what you have currently at least a thread ID and a set of fingerprint semantics stacks
17:32:18 <Deewiant> And actually I'm pretty sure that's all you'll need, assuming no fingerprints and concurrent funge-98
17:32:43 <quintopia> impomatic: i thought about doing that, but i realized it will frequently take two instructions to get to the + so you end up losing...
17:32:49 <impomatic> !bfjoust wait (+)*50000(>)*9([-]>)*21
17:33:05 <EgoBot> Score for impomatic_wait: 11.0
17:33:22 <impomatic> quintopia: Hmmm... will have to think of something different :-)
17:35:15 <Deewiant> Why is growing your IP such a problem
17:35:53 <elliott> Deewiant: Nothing, just all the damn offsets I need EVERYWHERE because of this
17:36:12 <Deewiant> I recommend a "pop offset vector" function
17:36:14 <Ilari> APNIC last day: 0.04 blocks allocated.
17:36:49 <elliott> Deewiant: There's a STACK of them?!?!?!?!
17:37:01 <elliott> Deewiant: Can't I just keep them on the actual stack like it says, and store only the top in the IP?
17:37:14 <Deewiant> I meant, pop a vector and apply the offset to it
17:37:26 <elliott> Deewiant: I'm implementing it in my peek and poke functions instead.
17:37:35 <ais523> aha, defend7 beats stridewire because of its anti-tripwire decoy
17:38:11 <Deewiant> Just about everything that uses vectors :-P
17:39:00 <ais523> !bfjoust stridewire_faster (>)*9[(-----[+]>>)*10[[+]]]>>[(-----[+]>>)*9[[+]]]>>[(-----[+]>>)*8[[+]]]>>[(-----[+]>>)*7[[+]]]>>[(-----[+]>>)*6[[+]]]>>[(-----[+]>>)*5[[+]]]>>[(-----[+]>>)*4[[+]]]>>[(-----[+]>>)*3[[+]]]>>[(-----[+]>>)*2[[+]]]>>[(-----[+]>>)*1[[+]]]>[[+]]>[[+]]>[[+]]
17:39:02 <EgoBot> Score for ais523_stridewire_faster: 7.6
17:39:05 <ais523> I predict a low score for that
17:39:11 <ais523> not as low as I'd thought, actually
17:39:14 <elliott> Deewiant: But that's the thing
17:39:19 <elliott> Deewiant: Every single peek and poke is now offset
17:39:24 <elliott> Deewiant: So I don't have to think about it at all
17:39:27 <ais523> at least it beats defend7
17:39:33 <Deewiant> peek and poke are not the only things that are offset
17:39:46 <elliott> Deewiant: Everything apart from file loading goes through peek and poke.
17:39:55 <ais523> but that's the only improvement over regular stridewire
17:39:58 <Deewiant> Only things that touch funge-space go through peek and poke
17:40:02 <EgoBot> Score for ais523_stridewire: 0.0
17:40:08 <Deewiant> And that "apart" is already one place you need to apply an offset :-P
17:40:09 <myndzi> haha, bfjoust is active again eh ;)
17:40:12 <elliott> Deewiant: Isn't that what the storage offset is.
17:40:34 <Deewiant> There are things that push vectors that have been offset onto the stack
17:41:15 <ais523> !bfjoust tripstridewire (>)*9[>(-----[+]>)*19[[+]]]>>[>(-----[+]>)*17[[+]]]>>[>(-----[+]>)*15[[+]]]>>[>(-----[+]>)*13[[+]]]>>[>(-----[+]>)*11[[+]]]>>[>(-----[+]>)*9[[+]]]>>[>(-----[+]>)*7[[+]]]>>[>(-----[+]>)*5[[+]]]>>[>(-----[+]>)*3[[+]]]>>[>(-----[+]>)*1[[+]]]>[[+]]>[[+]]>[[+]]
17:41:17 <elliott> Deewiant: In fingerprints, you mean?
17:41:18 <EgoBot> Score for ais523_tripstridewire: 26.7
17:41:35 -!- BeholdMyGlory has joined.
17:41:44 <ais523> whoops, I deleted the original stridewire by mistake
17:41:52 <ais523> !bfjoust stridewire (>)*9[(-----[+]>)*20[[+]]]>>[(-----[+]>)*18[[+]]]>>[(-----[+]>)*16[[+]]]>>[(-----[+]>)*14[[+]]]>>[(-----[+]>)*12[[+]]]>>[(-----[+]>)*10[[+]]]>>[(-----[+]>)*8[[+]]]>>[(-----[+]>)*6[[+]]]>>[(-----[+]>)*4[[+]]]>>[(-----[+]>)*2[[+]]]>[[+]]>[[+]]>[[+]]
17:41:56 <EgoBot> Score for ais523_stridewire: 22.0
17:41:58 <ais523> !bfjoust stridewire_faster <
17:42:03 <EgoBot> Score for ais523_stridewire_faster: 0.0
17:42:12 <Ilari> A /13 to South Korea, a /14 to China, a /18, two /19s, a /20 and a /21 to Japan, a /18 to Pakistan, a /22 and a /24 to Australia, a /24 to Indonesia.
17:42:37 -!- Behold has quit (Read error: Operation timed out).
17:43:07 <elliott> "then sets the new storage offset to the location to be executed next by the IP (storage offset <- position + delta)"
17:43:07 <Ilari> On IPv6 front: a /32 to Japan and a /32 to Indonesia,
17:43:10 <elliott> Deewiant: How behave with wrap
17:44:30 <elliott> BAD: wraparound with non-cardinal delta doesn't work
17:44:39 <elliott> Deewiant: You don't handle { working but } reflecting.
17:45:01 <elliott> "} acts like r if a stack-stack underflow would otherwise occur (i.e. when there is only one stack on the stack-stack.)"
17:45:09 <elliott> Deewiant: I thought you said that the stack-stack was filled with infinite stacks.
17:45:15 <ais523> Gregor: this is confusing: stridewire and tripstridewire each beat the same set of programs, except that stridewire beats tripstridewire. So why is tripstridewire beating stridewire on points?
17:45:20 <Deewiant> elliott: I didn't say that, you said that.
17:45:46 <elliott> Deewiant: So what happens on "u" with only one stack on the stack stack?
17:46:17 <ais523> myndzi: I just came up with a new tactic
17:46:30 <ais523> which does really well against pretty much everyone but impomatic, who it fails horribly against
17:46:41 <ais523> I wonder if it's because impomatic uses a different sort of decoy, generally speaking?
17:48:57 <ais523> haha, I see what I did wrong
17:49:50 <ais523> !bfjoust tripstridewire (>)*9[(-----[+]>)*20[[+]]]>>[>(-----[+]>)*17[[+]]]>>[>(-----[+]>)*15[[+]]]>>[>(-----[+]>)*13[[+]]]>>[>(-----[+]>)*11[[+]]]>>[>(-----[+]>)*9[[+]]]>>[>(-----[+]>)*7[[+]]]>>[>(-----[+]>)*5[[+]]]>>[>(-----[+]>)*3[[+]]]>>[>(-----[+]>)*1[[+]]]>[[+]]>[[+]]>[[+]]
17:50:15 <elliott> Deewiant: If wraparound with non-cardinal delta doesn't work, does the { test fail or something? :P
17:50:40 <EgoBot> Score for ais523_tripstridewire: 28.5
17:51:14 <elliott> Deewiant: Oh, I think I see the problem.
17:51:31 <elliott> Deewiant: I need to set the IP's position to (0,0) after changing the storage offset, right?
17:52:04 <Deewiant> Well, if all your funge-space access such as movement and stuff now uses the offset...
17:52:08 <Deewiant> Starting to see why that's a bad idea? :-D
17:52:36 <elliott> I am sure I can do it some more
17:53:48 -!- asiekierka has quit (Read error: Operation timed out).
17:54:04 <elliott> Deewiant: Is x's vector offset? :P
17:54:53 <elliott> BAD: { transfers cells incorrectly
17:54:53 <elliott> 10 0 0 Stopping due to fear of corrupt stack stack
17:55:17 <Deewiant> That bit is fairly robust and careful :-D
17:55:31 <elliott> Deewiant: Does that mean I fucked it up incredibly badly? :D
17:55:34 <Gregor> elliott: Is "stack stack" a joke, or a semi-intentional result of stack corruption?
17:55:49 <elliott> Gregor: Funge-98 has an actual, honest to god, stack of stacks.
17:55:55 <Deewiant> You fucked it up badly enough that I haven't predicted that result
17:56:06 <elliott> then transfer (fromIntegral n)
17:56:06 <elliott> else replicateM_ (fromIntegral (abs n)) $ modifySOSS (0:)
17:56:09 <elliott> let Ray (x,y) (dx,dy) = ray ip
17:56:11 <elliott> let (ox,oy) = storageOffset ip
17:56:13 <elliott> modifySOSS $ (oy:) . (ox:)
17:56:15 <elliott> modifyIP $ \ip -> ip{ storageOffset = (x+dx, y+dy) }
17:56:16 <Deewiant> Honestly, I don't think I have any specific checks there
17:56:24 <Deewiant> Just correctly/incorrectly, and if incorrectly -> bail
17:57:44 <impomatic> !bfjoust wait >+++>++[]<((+)*128(>)*8(+.)*56(<)*8)*3((+)*128(>)*9(+.)*55(<)*9)*3((+)*128(>)*10(+.)*54(<)*10)*3((+)*128(>)*11(+.)*53(<)*11)*3((+)*128(>)*12(+.)*52(<)*12)*3((+)*128(>)*13(+.)*51(<)*13)*3((+)*128(>)*14(+.)*50(<)*14)*3((+)*128(>)*15(+.)*49(<)*15)*3((+)*128(>)*16(+.)*48(<)*16)*3((+)*128(>)*17(+.)*47(<)*17)*3((+)*128(>)*18(+.)*46(<)*18)*3((+)*128(>)*19(+.)*45(<)*19)*3((+)*128(>)*20(+.)*4
17:57:47 <EgoBot> Score for impomatic_wait: 0.0
17:58:03 <Gregor> impomatic: I am truly impressed.
17:58:03 <elliott> impomatic: TOOOOOOOO BIIIIIIIIIIIIIIIG
17:58:25 <EgoBot> Score for coppro_awful: 8.7
17:58:32 <elliott> Deewiant: It's oy:ox:rest of stack, right?
17:58:39 <elliott> Deewiant: i.e. TOS oy ox ... BOS
17:58:58 <Gregor> coppro: You can cause other competitors to wander off the tepe while you do nothing.
17:59:12 <Gregor> pooppy: You can cause other competitors to wander off the tepe while you do nothing.
17:59:20 <ais523> !bfjoust tripstridewire <
17:59:23 <EgoBot> Score for ais523_tripstridewire: 0.0
18:00:05 <elliott> Gregor: Why would they wonder of the tepee?
18:00:07 <ais523> !bfjoust tripwire_antidecoy (>)*9[((-)*10[+]>)*20[[+]]]>>[((-)*10[+]>)*18[[+]]]>>[((-)*10[+]>)*16[[+]]]>>[((-)*10[+]>)*14[[+]]]>>[((-)*10[+]>)*12[[+]]]>>[((-)*10[+]>)*10[[+]]]>>[((-)*10[+]>)*8[[+]]]>>[((-)*10[+]>)*6[[+]]]>>[((-)*10[+]>)*4[[+]]]>>[((-)*10[+]>)*2[[+]]]>>[[+]]>[[+]]
18:00:11 <EgoBot> Score for ais523_tripwire_antidecoy: 24.2
18:00:21 <Gregor> elliott: They didn't find any tripwires, but were expecting them.
18:00:41 <ais523> !bfjoust tripwire_antidecoy <
18:00:44 <EgoBot> Score for ais523_tripwire_antidecoy: 0.0
18:00:47 <ais523> umm, that was meant to be stridewire_antidecoy
18:00:52 <elliott> Deewiant: Ohwait, they're transferred as a block >_<
18:01:10 <ais523> but nonetheless, making it better against impomatic hurts it against Lymia and jix
18:01:13 <Gregor> !bfjoust wtf >+[(+)*126>+]
18:01:18 <EgoBot> Score for Gregor_wtf: 0.2
18:01:19 <elliott> Deewiant: I LIKE THE PART WHERE { AND U BEHAVE TOTALLY DIFFERENTLY
18:01:45 <Deewiant> Going to quit before you're done?-)
18:01:54 <Phantom_Hoover> http://www.amazon.com/FarmVille-Dummies-Angela-Morales/dp/1118016963
18:02:09 <elliott> Deewiant: Current plan: Get it totally passing Mycology. Clean things up. Optimise a little bit. Get fingerprint infrastructure. Implement a bunch. Clean up & optimise.
18:02:17 -!- MigoMipo has quit (Ping timeout: 245 seconds).
18:02:25 <Gregor> Phantom_Hoover: I ... I do not want to live in this world.
18:02:28 <Deewiant> If you start with TRDS you can cut down "a bunch" to "none"
18:02:29 <ais523> interesting fact: stridewire wins 1/21 against defend7; tripstridewire wins 10/21
18:02:37 <ais523> which is why it was scoring better
18:03:00 <elliott> FarmVille is like Minecraft except with social interaction.</troll>
18:04:05 <Vorpal> wait. Isn't minecraft just Dwarf Fortress for dummies?
18:04:27 <Phantom_Hoover> Anyway, Gnomeo and Juliet must be stopped at the source.
18:04:34 <Gregor> Phantom_Hoover: 288 pages
18:04:40 <Vorpal> Phantom_Hoover, "Gnomeo"?
18:05:06 <Phantom_Hoover> Gregor, ah, but killing Shakespeare will alter the course of history sufficiently that Mark Zuckerberg won't even be born.
18:05:12 <Gregor> I recall having a book once titled "The Complete Idiots Guide for Dummies"
18:05:28 <elliott> Deewiant: What IS the point of that pushing zeroes on the SOSS for negatives thing?
18:06:02 <elliott> Deewiant: It hangs now!!!!!
18:06:09 <Deewiant> elliott: At least it's specced instead of undefined
18:06:10 <ais523> !bfjoust tripstridewire (>)*9[(-----[+]>)*20[[+]]]>>[>(-----[+]>)*17[[+]]]>>[>(-----[+]>)*15[[+]]]>>[>(-----[+]>)*13[[+]]]>>[>(-----[+]>)*11[[+]]]>>[>(-----[+]>)*9[[+]]]>>[>(-----[+]>)*7[[+]]]>>[>(-----[+]>)*5[[+]]]>>[>(-----[+]>)*3[[+]]]>>[>(-----[+]>)*1[[+]]]>[[+]]>[[+]]
18:06:13 <EgoBot> Score for ais523_tripstridewire: 28.3
18:06:36 <elliott> Vorpal: why the fuck is { so crazy
18:06:41 <Vorpal> luckily the actual site is flash so I can't see anything!
18:07:05 <Vorpal> elliott, which part of it in specific?
18:07:27 <elliott> pushing 3 zeroes on the SOSS
18:07:35 <Vorpal> elliott, "because the spec says so"
18:07:49 <ais523> aha, the reason that tripstridewire does better than stridewire on the leaderboard is that it wins just below 50%, rather than 0%, against certain enemys
18:07:55 <ais523> like defend7, and some of impomatic's
18:08:26 <impomatic> ais523: doesn't tripstridewire fall off the end after (>)*9[(-----[+]>)*20
18:08:45 <ais523> impomatic: that's 29 spaces
18:08:50 <elliott> Deewiant: Does it tell you that { is good before failing at }?
18:09:05 <ais523> although that's a good point; if it encounters something after 9 spaces, clearly the actual flag must be within another 9
18:09:18 <Vorpal> ais523, where is the score board now again?
18:09:31 <elliott> Deewiant: I have a contraversial opinion to tell.
18:09:44 <elliott> Deewiant: I think Funge-98 is fucking nuts and was invented by crackheaded monkeys on crack.
18:09:48 <ais523> !bfjoust tripstridewire (>)*9[(-----[+]>)*9[[+]]]>>[>(-----[+]>)*11[[+]]]>>[>(-----[+]>)*13[[+]]]>>[>(-----[+]>)*13[[+]]]>>[>(-----[+]>)*11[[+]]]>>[>(-----[+]>)*9[[+]]]>>[>(-----[+]>)*7[[+]]]>>[>(-----[+]>)*5[[+]]]>>[>(-----[+]>)*3[[+]]]>>[>(-----[+]>)*1[[+]]]>[[+]]>[[+]]
18:09:51 <EgoBot> Score for ais523_tripstridewire: 28.5
18:09:59 <ais523> Vorpal: http://codu.org/eso/bfjoust/report.txt
18:10:03 <Deewiant> But then, most esolangs are like that
18:10:08 <Vorpal> !bfjoust test (-)*1000
18:10:15 <EgoBot> Score for Vorpal_test: 12.9
18:10:19 <Vorpal> !bfjoust test (-)*10000
18:10:24 <ais523> impomatic: it turned out to make basically no difference, but it helped very slightly, there must be a corner case where that's useful
18:10:26 <EgoBot> Score for Vorpal_test: 12.9
18:10:27 <elliott> Deewiant: At least with most of them, implementation is a brief experience of pain.
18:10:43 <elliott> Deewiant: As opposed to a week-long experience of pain with direct access to the guy who's already read the mushy tea leaves.
18:10:47 <ais523> Vorpal: oh come on, what does that beat? apart from tripstridewire?
18:11:01 <elliott> `addquote <Vorpal> !bfjoust test (-)*10000 <EgoBot> Score for Vorpal_test: 12.9 <Vorpal> yay
18:11:03 <quintopia> ais523: anything that [-] on the flag before >
18:11:07 <Vorpal> ais523, I was wondering
18:11:15 <Deewiant> elliott: That's because they're all boringly simple
18:11:16 <ais523> oh, also regular stridewire
18:11:25 <elliott> Deewiant: Underload is boring and simple? :p
18:11:38 <ais523> and large_decoy_attack, and shade
18:11:51 <Vorpal> ais523, I was actually interested in if that would help with the "0 at the end of two turns" thing
18:11:56 <Deewiant> elliott: If it can be implemented in befunge-98 without too much trouble, it's simple :-D
18:11:57 <ais523> the moment I put tripwire programs in, everyone suddenly busts out the anti-tripwire programs
18:12:09 <ais523> I think one of my early defense programs work a bit like that
18:12:18 <ais523> and defend7 does it too, but only in contexts where it knows it's likely to help
18:12:24 <ais523> *works a bit like that
18:12:28 <impomatic> !bfjoust simple (>)*9(-----[+]>)*21
18:12:31 <myndzi> ais523: i think most of the programs on the hill are over a year old
18:12:31 <HackEgo> 295) <Vorpal> !bfjoust test (-)*10000 <EgoBot> Score for Vorpal_test: 12.9 <Vorpal> yay
18:12:36 <EgoBot> Score for impomatic_simple: 6.0
18:12:40 <myndzi> i don't think anyone has been busting out "anti-tripwire" programs on you ;p
18:12:40 <ais523> Vorpal: set the repeat coutn up to a million
18:12:49 <myndzi> but because defend did well, that got incorporated into most of the active programs
18:13:02 <myndzi> and to be honest it doesn't usually hurt anything
18:13:07 <ais523> myndzi: "anti-tripwire" is any stupid simple program that doesn't set up decoys in order to make tripwires suicide
18:13:10 <Vorpal> !bfjoust test (-)*1000000
18:13:17 <Gregor> !bfjoust durptarded [[(+)*10000(-)*10000]+]
18:13:28 <myndzi> i thought tripwire was prettty much the opposite?
18:13:30 <ais523> Vorpal: so the interp times out as a draw, rather than your program losing when it runs out of repeats
18:13:32 <myndzi> waiting on a cell to change and then acting
18:13:38 <ais523> myndzi: no, that's defend7, etc
18:13:45 <Vorpal> ais523, it seems to take a while
18:13:47 <EgoBot> Score for Vorpal_test: 12.3
18:13:47 <ais523> tripwire looks for the first nonzero value, assumes it's a decoy, and skips it
18:13:48 <EgoBot> Score for Gregor_durptarded: 11.7
18:13:48 <myndzi> which is what i remember us calling a 'tripwire'
18:13:56 <Vorpal> ais523, wait, why did that preform worse?
18:14:04 <ais523> some programs really were going ot the end
18:14:07 <myndzi> then itt's reverse-named ;p
18:14:21 <ais523> and I think because it changed the relative standings of some of the others
18:14:26 <ais523> myndzi: indeed, it's a tripwire avoider
18:14:29 <ais523> shortened to "tripwire"
18:14:40 <ais523> and it's a little late to change the name now
18:14:41 <myndzi> i thought you meant anti-tripwire the technique
18:14:46 <myndzi> not anti-tripwire the program
18:14:52 <myndzi> you could nuke it and rename it
18:15:07 <Vorpal> !bfjoust test (++-)*1000000
18:15:26 <EgoBot> Score for Vorpal_test: 30.4
18:15:27 <myndzi> it's fun to see the programs i wrote so long ago still there, but not as fun when i realize it's because nobody played in all that time ;D
18:15:39 <ais523> wow, tripstridewire vs. mirage is really bizarre
18:15:48 <elliott> `addquote <Vorpal> !bfjoust test (++-)*1000000 <Vorpal> probably will suck <EgoBot> Score for Vorpal_test: 30.4 <Vorpal> what
18:15:49 <HackEgo> 296) <Vorpal> !bfjoust test (++-)*1000000 <Vorpal> probably will suck <EgoBot> Score for Vorpal_test: 30.4 <Vorpal> what
18:15:50 <Vorpal> ais523, see the last score
18:15:52 <myndzi> Vorpal: because it changes the timing
18:15:59 <quintopia> elliott: i was about to quote that too
18:16:03 <Vorpal> myndzi, true, but I didn't expect it to do that much
18:16:05 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
18:16:08 <myndzi> see if you are going - every time
18:16:13 <elliott> !bfjoust probably_will_suck (++++--)*1000000
18:16:16 <myndzi> and some program is looping on - every other
18:16:24 <myndzi> maybe the loop never ends, depending on timings
18:16:26 <EgoBot> Score for elliott_probably_will_suck: 13.1
18:16:28 <ais523> try it yourself, see what will happen
18:16:33 <myndzi> but since you add some wobble.. :)
18:16:42 <elliott> !bfjoust probably_will_suck ((+)*19(-)*18)*1000000
18:16:55 <EgoBot> Score for elliott_probably_will_suck: 13.5
18:16:57 <myndzi> i dunno, i forget exactly how ] is determined when two programs write to the same cell
18:17:20 <ais523> Vorpal_test is an ais523-beater, it loses to more or less everyone else
18:17:20 <myndzi> ++- is better because lots of [-] or [+]
18:17:24 <myndzi> it decrements every other
18:17:28 <ais523> thanks for pushing me right down the leaderboard, Vorpal!
18:17:36 <Vorpal> elliott, guess I hit a sweet spot with the numbers there
18:17:47 <elliott> Vorpal: rather, i think it's because your test program beat ais523 only
18:17:51 <elliott> and now ais523 is low down the leaderboard
18:17:52 <Vorpal> ais523, not intended. Also: For science!
18:17:57 <quintopia> !bfjoust definitely_will_suck [--]+[[+-]+]+
18:17:58 <elliott> !bfjoust probably_will_suck (++-)*1000000
18:18:06 <Vorpal> elliott, actually a bit more than just ais it seems
18:18:10 <ais523> Vorpal: obviously, but it's still amusing
18:18:24 <myndzi> i didn't think that your score depended on the score of the opponents, just how many wins you get?
18:18:25 <ais523> anyway, it beat /all/ my programs, apart from defend7 which was a rather obvious draw
18:18:29 <myndzi> ais didn't get knocked off so..?
18:18:29 <Gregor> I notice there are no evolved programs on the chart :P
18:18:38 <EgoBot> Score for quintopia_definitely_will_suck: 9.4
18:18:39 <EgoBot> Score for elliott_probably_will_suck: 26.5
18:18:54 <elliott> !bfjoust probably_will_suck (-++)*1000000
18:19:02 <ais523> elliott: isn't that just what Vorpal did?
18:19:04 <Gregor> Holy fekk there are O_O
18:19:07 <Gregor> I didn't notice those X-P
18:19:13 <quintopia> i wonder what definitely_will_suck beat
18:19:14 <Gregor> One's got 24 points O_O
18:19:16 <Vorpal> elliott, you pushed mine down too
18:19:18 <EgoBot> Score for elliott_probably_will_suck: 23.4
18:19:25 <elliott> Gregor: Is this invalidating your life-long creationist beliefs?
18:19:35 <ais523> and just like that, stridewire fell back off the leaderboard
18:19:47 <Vorpal> !bfjoust test >+>+<<(++-)*1000000
18:19:49 <ais523> tripstridewire is definitely an interesting concept, though; I'll have to look into it more
18:19:53 <variable> we have a creationist here? Hersey!
18:19:57 <Gregor> elliott: Actually it's invalidating my punctuated design beliefs since I haven't seen a punctuation yet :P
18:20:04 <Gregor> variable: I'm kidding, I'm not a retard.
18:20:07 <variable> and yes - I know that's a chocolate
18:20:10 <EgoBot> Score for Vorpal_test: 20.3
18:20:11 <myndzi> hmm, i think i had more than one on by nescience, what fell off?
18:20:23 <ais523> !bfjoust tripstridewire_faster (>)*9[(-[+]>)*9[[+]]]>>[>(-[+]>)*11[[+]]]>>[>(-[+]>)*13[[+]]]>>[>(-[+]>)*13[[+]]]>>[>(-[+]>)*11[[+]]]>>[>(-[+]>)*9[[+]]]>>[>(-[+]>)*7[[+]]]>>[>(-[+]>)*5[[+]]]>>[>(-[+]>)*3[[+]]]>>[>(-[+]>)*1[[+]]]>[[+]]>[[+]]
18:20:25 <myndzi> isn't theere an archive somewhere
18:20:27 <EgoBot> Score for ais523_tripstridewire_faster: 24.5
18:20:35 <elliott> mapM_ push (padTake 0 n s)
18:20:36 <elliott> io$print "alas, the eve of donkeys is not at hand"
18:20:36 <elliott> I looooove my debug statements.
18:20:41 <myndzi> oh right it was like, a git repository or something
18:20:45 <myndzi> i don't have any of that shit set up here
18:20:47 <Gregor> variable: Also, that's not a chocolate, that's an adjective meaning "similar to a hearse"
18:20:51 <Vorpal> !bfjoust test (--+)*1000000
18:20:56 <ais523> very similar score, but the wins and losses are in different places
18:20:59 <myndzi> or because i never use it :P
18:21:05 <myndzi> it's on my old laptop at work
18:21:16 <ais523> !bfjoust tripstridewire_faster (>)*9[(--[+]>)*9[[+]]]>>[>(--[+]>)*11[[+]]]>>[>(--[+]>)*13[[+]]]>>[>(--[+]>)*13[[+]]]>>[>(--[+]>)*11[[+]]]>>[>(--[+]>)*9[[+]]]>>[>(--[+]>)*7[[+]]]>>[>(--[+]>)*5[[+]]]>>[>(--[+]>)*3[[+]]]>>[>(--[+]>)*1[[+]]]>[[+]]>[[+]]
18:21:17 <elliott> Deewiant: Woo, now it's back to being incorrect
18:21:33 <EgoBot> Score for Vorpal_test: 22.5
18:21:33 <EgoBot> Score for ais523_tripstridewire_faster: 19.5
18:21:35 <myndzi> (see what i was talking about yesterday about fiddling constants until you win, then someone else does it? ;)
18:21:48 <ais523> !bfjoust tripstridewire_faster (>)*9[(-[+]>)*9[[+]]]>>[>(-[+]>)*11[[+]]]>>[>(-[+]>)*13[[+]]]>>[>(-[+]>)*13[[+]]]>>[>(-[+]>)*11[[+]]]>>[>(-[+]>)*9[[+]]]>>[>(-[+]>)*7[[+]]]>>[>(-[+]>)*5[[+]]]>>[>(-[+]>)*3[[+]]]>>[>(-[+]>)*1[[+]]]>[[+]]>[[+]]
18:21:48 <myndzi> too bad there's no 'age' statistic
18:21:50 <elliott> myndzi: clearly it should try your program with every constant
18:21:53 <EgoBot> Score for ais523_tripstridewire_faster: 22.6
18:21:58 <myndzi> elliott: well, it's not that simple
18:22:03 <ais523> myndzi: there is, just look at the last-modified in egobot
18:22:10 <elliott> GOOD: { transfers cells correctly
18:22:10 <elliott> GOOD: { sets storage offset correctly, and p uses it
18:22:11 <ais523> several of the programs are over a year old
18:22:14 <myndzi> i mean, that there's not exactly "constants" to fiddle
18:22:19 <myndzi> of course it was a joke :P
18:22:23 <elliott> myndzi: it would end up just trying all programs :D
18:22:24 <myndzi> but there are some, too
18:22:35 <myndzi> obviously mine would win then!
18:22:42 <elliott> it would be every program vs. every program :D
18:22:46 <myndzi> because in the end it would have beat every program! ;)
18:22:50 <quintopia> !bfjoust definitely_will_suck >+>+<<(-)*128+[[+-]+]+
18:22:51 <ais523> you know, any successful program ends up pushing what it beats off the hill, and then getting worse
18:22:54 <myndzi> shh, your logic has no place here
18:23:01 <ais523> that's what happened to stridewire; really quickly, programs it beat got pushed off
18:23:04 <myndzi> ais523: clearly need a bigger hill
18:23:11 <EgoBot> Score for quintopia_definitely_will_suck: 4.3
18:23:15 <myndzi> or less similar programs
18:23:27 <myndzi> !bfjoust most_definitely_will_suck <
18:23:30 <EgoBot> Score for myndzi_most_definitely_will_suck: 0.0
18:23:34 <quintopia> !bfjoust definitely_will_suck (-)*128+[[+-]+]+
18:23:37 <ais523> when I first came up with stridewire, it beat everyone but impomatic; now, it's not really beating anyone but myndzi
18:23:48 <Vorpal> !bfjoust suckitude_personified <+
18:23:53 <myndzi> i didn't quite even read what it did
18:23:57 <ais523> !bfjoust tripstridewire_faster <
18:23:59 <EgoBot> Score for Vorpal_suckitude_personified: 0.0
18:23:59 <EgoBot> Score for quintopia_definitely_will_suck: 12.3
18:24:00 <EgoBot> Score for ais523_tripstridewire_faster: 0.0
18:24:03 <myndzi> i haven't modified any of my programs
18:24:06 <ais523> I'm going to remove duplicates of my programs in order to help the others survive longer
18:24:07 <Vorpal> argh myndzi beat me to it
18:24:10 <myndzi> so i'm not surprised that a program written to beat them all...?
18:24:20 <ais523> it wasn't written to beat them all, I was just trying out a new strategy
18:24:31 <ais523> and it was hilarious seeing how it did much better against some people's programs than others
18:24:33 <myndzi> ah, well that's good, i hope it can stay
18:24:37 <ais523> different people have different styles, it seems
18:24:38 <Vorpal> 8 0.00 -20.00 ais523_tripstridewire_faster.bfjoust
18:24:39 <myndzi> i should read about it later
18:24:48 <ais523> (also of note: tripstridewire would do well in BF Joust 1, the original)
18:24:51 -!- kar8nga has joined.
18:24:53 <myndzi> well, it seems like lots of the programs wound up being very similar from different people
18:25:07 <myndzi> like, i realized that if i messed around with slowrush it would wind up being more like wiggle lol
18:25:19 <myndzi> or something, i forget precisely which programs were involved at the time
18:25:28 <ais523> tripstridewire is basically a really /really/ aggressive rush program
18:25:36 <ais523> it's faster than a typical fast-rush program by a factor of 2
18:25:42 <ais523> because it only checks every second tape cell
18:25:47 <quintopia> !bfjoust test (-)*128+[+-](+)*128>>>>>>>>+[>[-]+]
18:25:52 <Vorpal> ais523, why every second?
18:25:55 <ais523> then, when it finds one, it starts zeroing from the cell after that
18:26:01 <EgoBot> Score for quintopia_test: 7.5
18:26:06 <ais523> Vorpal: to give extra speed at the expense of reliability
18:26:26 <ais523> it can often start attacking the flag while the opponent is still setting up its decoys
18:26:28 <ais523> thus it works better on short tapes, worse on longer ones
18:26:35 <Gregor> ais523: "would do well in BF Joust 1" weren't the changes YOUR idea? :P
18:26:44 <myndzi> i wonder if i ever wrote something that set up the decoys backwards
18:26:50 <myndzi> maybe never had a reason tto
18:27:10 <ais523> in because it needed decoys just to have time to set up its other decoys
18:27:23 <myndzi> well that would apply to any program
18:27:27 <ais523> the decoys were the entire point, rather than just slowing the opponent down
18:27:27 -!- Behold has joined.
18:27:27 <Vorpal> !bfjoust test >>>-<+<-(--+)*1000000
18:27:29 <myndzi> of course it nets you a loss in speed eventually
18:27:33 <Vorpal> !bfjoust test >>>-<+<<(--+)*1000000
18:27:36 <myndzi> but not by all that much
18:27:37 <ais523> as they needed to be at specific values in order for its strategy to work
18:27:42 <ais523> rather than just slowing the opponent
18:27:43 <elliott> Deewiant: What's the test after "{ with negative argument works"?
18:27:54 <ais523> (to be precise, it set up a range of decoys, then timed them in order to deduce the opponent's strategy)
18:28:01 <EgoBot> Score for Vorpal_test: 15.4
18:28:01 <EgoBot> Score for Vorpal_test: 15.4
18:28:08 <Deewiant> elliott: Or get a binary that works :-P
18:28:11 <myndzi> that's the one i was thinking about the other day
18:28:13 -!- kar8nga has quit (Excess Flood).
18:28:19 <myndzi> wiggle gets around it in an interesting way
18:28:24 <elliott> Deewiant: Link me to your site :P
18:28:26 <Vorpal> !bfjoust test >>>-<-<<(--+)*1000000
18:28:26 <quintopia> Vorpal: it fails to kill tripwire now that you added decoys
18:28:27 <myndzi> by basically using different timings for every attack
18:28:28 <ais523> that was defend9; it was on the hill for ages, but collapsed eventually
18:28:42 <Vorpal> quintopia, I'm just checking what different decoys do
18:28:43 <ais523> due to programs like wiggle that do that, and programs like slowrush which just use really bizarre timings
18:28:52 <EgoBot> Score for Vorpal_test: 15.4
18:28:59 -!- kar8nga has joined.
18:29:05 <EgoBot> Score for Vorpal_test: 0.0
18:29:09 <ais523> and rush programs often got there before the decoys were set up correctly
18:29:11 <Vorpal> !bfjoust shudder (--+)*1000000
18:29:18 <Vorpal> (I'd like to rename it)
18:29:26 <ais523> not to mention tripwire-avoiders completely screwing up the whole concept
18:29:38 <myndzi> damn those enemy programs for not playing by your rules
18:29:39 <EgoBot> Score for Vorpal_shudder: 18.2
18:30:03 <ais523> defend7's a lot more robust, as it doesn't need to detect the enemy loops but rather uses mathematics to ensure that most common timings won't make the flag fall
18:30:08 <EgoBot> Score for quintopia_test: 15.8
18:30:27 <Vorpal> !bfjoust shudder (++-)*1000000
18:30:28 <elliott> !bfjoust wiggles_woggle_but_they_dont_fall_down (>--+<+--)*1000000
18:30:36 <EgoBot> Score for Vorpal_shudder: 17.5
18:30:40 <EgoBot> Score for elliott_wiggles_woggle_but_they_dont_fall_down: 0.0
18:30:48 -!- BeholdMyGlory has quit (Ping timeout: 250 seconds).
18:30:57 <EgoBot> Score for quintopia_test: 0.0
18:31:05 <Vorpal> !bfjoust shudder (--+)*1000000
18:31:09 <Vorpal> so that one was better
18:31:15 <elliott> !bfjoust wiggles_woggle_but_they_dont_fall_down (>--+<+--)*100000
18:31:17 <ais523> !bfjoust stupid_defender_clearer (>)*8(>[[+]])*21
18:31:33 <elliott> GOOD: } reflects when stack stack has only one stack
18:31:37 <EgoBot> Score for elliott_wiggles_woggle_but_they_dont_fall_down: 0.2
18:31:38 <EgoBot> Score for ais523_stupid_defender_clearer: 13.2
18:31:38 <EgoBot> Score for Vorpal_shudder: 19.3
18:31:58 <Vorpal> ... I can't compare if everyone keep submitting :P
18:32:02 <Vorpal> !bfjoust shudder (++-)*1000000
18:32:23 <ais523> unfortunately, stupid_defender_clearer doesn't do well enough against the non-shudder-style programs to clear the shudder-style programs as well as it should
18:32:41 <EgoBot> Score for Vorpal_shudder: 18.2
18:32:46 <myndzi> !bfjoust lole (>+)*8([>][-][>][--][>][---])*4
18:32:48 <Vorpal> okay so other one is better
18:32:52 <Vorpal> !bfjoust shudder (--+)*1000000
18:32:58 <Vorpal> (and I'm done for today)
18:33:04 <myndzi> --+ is the same as ++-
18:33:10 <myndzi> it tests both of them in the fight
18:33:15 <ais523> ugh, report.txt seems blank
18:33:23 <EgoBot> Score for myndzi_lole: 0.0
18:33:23 <Deewiant> It's blank because it's running
18:33:23 <EgoBot> Score for Vorpal_shudder: 18.3
18:33:26 <ais523> Vorpal: swapping + and - is done automatically, and the scores for both averaged
18:33:26 <Vorpal> myndzi, it inverts everything and tests?
18:33:28 <quintopia> !bfjoust sex_bobomb [-](+-)*1000000
18:33:39 <Vorpal> ais523, so why did I get different results for them
18:33:44 <myndzi> because peeople were just taking existing programs and swapping them
18:33:54 <myndzi> so now it tests it both ways
18:33:56 <EgoBot> Score for quintopia_sex_bobomb: 8.9
18:34:07 <ais523> Vorpal: because the scoreboard was different due to you pushing stupid test programs off the leaderboard in between
18:34:08 <myndzi> what di i break with that program, i didn't expect it to do anything useful but 0 lol
18:34:34 <myndzi> i think i forgot everything i knew about this ;D
18:34:38 <elliott> GOOD: u with a positive count transfers cells correctly
18:34:38 <elliott> BAD: u with a positive count transfers cells incorrectly
18:34:51 <elliott> With a blank line in-between, no less.
18:35:07 <elliott> BAD: fedcba0{05-} doesn't leave 15 on stack
18:35:19 <Vorpal> elliott, next time try making it swap BAD and GOOD compared to the rest of the line
18:35:22 <ais523> myndzi: the [>] is a bad idea, if you hit an opposing decoy-chain it's almost guaranteed to run off the tape
18:35:29 <Vorpal> elliott, what is the problem
18:35:30 <EgoBot> Score for quintopia_sex_bobomb: 7.4
18:35:30 <ais523> and you don't run [-] except immediately after [>]
18:35:38 <elliott> Vorpal: I have no idea why my code would not be doing that
18:35:46 <ais523> so basically, you're searching for a position where [>] will cause you to die, then running [>]
18:35:47 <myndzi> oh right, i think i got loops backwards
18:35:52 <ais523> which is a little counterintuitive...
18:36:00 <Deewiant> elliott: Jumping to the BAD is likely a result of your x not quite working, or movement with a noncardinal in general
18:36:08 <fizzie> ais523: "-- asked around in #nethack to see if anyone knew why it had been pulled. aid523 said that it was because the version of Spork on NAO was --" ... could it be your long-lost almost-identical (edit distance 1!) twin brother!?
18:36:11 -!- MigoMipo has joined.
18:36:13 <myndzi> what was the code that moved to the first nonzero and skipped it
18:36:22 <elliott> Deewiant: BAD: wraparound with non-cardinal delta doesn't work
18:36:26 <myndzi> oh, need nested brackets for that huh
18:36:26 <ais523> fizzie: I'm a regular in #nethack, and have also posted on rgrn
18:36:30 <ais523> and that was meant to be ais523, but a typo
18:36:32 <elliott> Deewiant: But "BAD: fedcba0{05-} doesn't leave 15 on stack" is an actual problem, right?
18:36:49 <Vorpal> elliott, hard to tell. It could be jumping incorrectly
18:36:52 <Deewiant> elliott: I don't think I ever use wraparound with a non-cardinal intentionally, it's too much of a headache to figure it out compared to just jumping directly to the right place :-P
18:36:53 <Vorpal> elliott, better fix x first?
18:36:59 <Deewiant> And yes, it's an actual problem
18:37:04 <quintopia> !bfjoust infinite_shudder [[(++-)*1000000]+]
18:37:04 <fizzie> ais523: That's so boringly prosaic explanation. I think I'll rather believe mine.
18:37:06 <Vorpal> Deewiant, I thought you tested it?
18:37:06 <elliott> Vorpal: My wraparound is broken ever since I fixed it.
18:37:18 <Deewiant> Vorpal: Yes, I meant other than that
18:37:31 <myndzi> yeah uhh, just keep adding more * numbers to make the hill slower >:(
18:37:31 <EgoBot> Score for quintopia_infinite_shudder: 17.9
18:37:32 <elliott> Vorpal: I hire you to fix my wrap-around algorithm
18:37:53 <quintopia> wat. why is that not as good as shudder?
18:37:54 <elliott> Vorpal: Ah, I don't think we quite understand each other: I hire you to fix my wrap-around algorithm
18:37:59 <elliott> quintopia: takes cycles at start
18:38:05 <Vorpal> elliott, and I don't think you understand me.
18:38:23 <ais523> fizzie: were you aware I was active in the NetHack community, btw? I wasn't aware you read rgrn
18:38:58 <quintopia> elliott: why does shifting the actual shuddering by 2 cycles a make-or-break issue?
18:39:15 -!- Sgeo has joined.
18:39:30 <ais523> quintopia: because it depends on when opposing programs reach you
18:39:57 <myndzi> you could put it back by also shifting the ++- pattern probably
18:39:59 <Vorpal> quintopia, actually you pushed mine down
18:40:16 <myndzi> that'd start - at the same time as it would have otherwise
18:40:45 <fizzie> ais523: Yes, your nethackitude has been revealed on-channel often enough that I had caught it.
18:41:00 <ais523> hmm, it's not that often in this channel
18:41:07 <ais523> (much more often in #nethack, occasionally in ##nomic)
18:41:28 <ais523> also, ais523_stupid_defender_clearer is still hanging on somehow
18:41:40 <ais523> presumably because people keep trying stupid defenders
18:41:42 <quintopia> Vorpal: yeah i just looked at the chart and noticed that
18:41:42 <ais523> it's doing its job, anyway
18:42:00 <ais523> ah no, it was just pushed off
18:42:02 <elliott> loop (x,y) (dx,dy) (mx,my)
18:42:02 <elliott> | x `ltx` mx || y `lty` my =
18:42:03 <elliott> (if x `ltx` mx then mx+dx else x,
18:42:03 <elliott> if y `lty` my then my+dy else y)
18:42:03 <elliott> | x `gtx` mx || y `gtx` my = loop (x-dx, y-dy) (dx,dy) (mx,my)
18:42:03 <myndzi> oughtta go all forum style on this and "pin" warriors ;)
18:42:06 <elliott> Deewiant, where's my obvious bug
18:42:14 <myndzi> when unique ones show up, stick em there!
18:42:37 <myndzi> i confess to being curious how this would stack up
18:42:42 <ais523> also, how did stupid_defender_clearer beat shade?
18:42:48 <myndzi> i think some work on the interpreter could be done though
18:42:51 <ais523> it wasn't meant to beat anything but stupid defenders (and tripstridewire)...
18:42:56 <myndzi> ais523: i don't even remember how anything i wrote works anymore
18:43:05 <myndzi> i think shade skips a tripwire
18:43:10 <ais523> shade was written by nescience
18:43:15 <ais523> but if it's tripwire-skipping, that explains it
18:43:15 <myndzi> that was my altnick at work
18:43:27 <ais523> quintopia: I like the finite one as it is
18:43:37 <ais523> the hill is inherently resistant to masses of clone programs
18:43:42 <ais523> unless they're /really good/ clone programs, I suppose
18:43:44 <quintopia> ais523: so? who was suggesting replacing it?
18:43:52 <ais523> you were suggesting an infinite hill
18:44:02 <Vorpal> myndzi, that is nes science right? as in NES.
18:44:05 <quintopia> yes, in addition to the finite one
18:44:19 <myndzi> http://www.m-w.com/cgi-bin/dictionary?book=Dictionary&va=nescience
18:44:29 <fizzie> ais523: "2010-02-26 22:08:26 < scarf!~scarf@unaffiliated/ais523: fizzie: you read rgrn?" -- it seems we did in fact sort of already have this discussion.
18:44:32 <myndzi> although the page isn't loading for me haha
18:44:47 <fizzie> (I'm not entirely sure I ever answered, though.)
18:44:52 <Vorpal> myndzi, oh I preferred my explanation!
18:44:56 <ais523> fizzie: wow, that was quite a memory from ages ago
18:45:48 <myndzi> i like interesting words
18:46:14 -!- Lymia_ has joined.
18:46:46 <myndzi> yeah, i think shade is just a fairly simple tripwire skip thing
18:47:06 -!- ais523 has quit (Read error: Connection reset by peer).
18:47:09 <myndzi> it's so long because it couldn't be shorthanded
18:48:27 -!- poiuy_qwert has joined.
18:48:40 -!- ais523 has joined.
18:48:42 <myndzi> i mean like, i add 10 before subtract looping; so if it's a -10 or less decoy, it gets cleared quickly
18:49:05 <ais523> myndzi: yep, I figured it out but my connection dropped, so you didn't see that I figured it out
18:49:21 <ais523> [19:06] <ais523> offset clears are a little arms race in themselves; you can set it high to beat impomatic, or low to beat everyone else
18:49:22 <ais523> [19:06] <ais523> because impomatic tends to use unusually large decoys, which leave him a bit vulnerable on short tapes but more powerful on long ones
18:49:24 <Vorpal> fizzie, any progress on jitfunge recently?
18:49:28 <myndzi> decoys: (>(-)*9)*2>(>-)*4 tripwire skip: >[ attack: >(+)*10[-] (times 20)
18:49:34 <myndzi> i guess i could have shorthanded the attack
18:49:39 <ais523> oh, you set decoys of 9 too?
18:49:41 <myndzi> oh, except you can't nest it right?
18:49:43 <Vorpal> ais523, just wondering. Is Feather completely dead or do you think you will resume it at some point?
18:49:49 <ais523> and shorthanding is just a convenience to make it easier over IRC
18:50:00 -!- Lymia__ has quit (Ping timeout: 276 seconds).
18:50:06 <ais523> in fact, I even managed to create a constant without it going into an infinite loop
18:50:12 <myndzi> i worked out a method to interpret the shorthand code without expanding itt
18:50:14 <ais523> which is a huge achievement in Feather terms
18:50:16 <myndzi> in a way which allowed nesting
18:50:33 <myndzi> but i don't think it ever got implemented
18:50:35 <elliott> myndzi: that's what egojoust does
18:50:49 <myndzi> maybe it did then? i asked someone last night and he said it expanded in memory
18:50:56 <ais523> Vorpal: I can't remember, but I think it involved a crazy bootstrapping using multiple other constants, and being simultaneously metacircular and not metacircular wrt Scheme by detecting which any particular constant used
18:50:57 <myndzi> which is the old behavior
18:51:13 <ais523> sure, the constants just sit there and don't do anything, but at least they exist
18:51:20 <ais523> myndzi: egojoust uses some pretty clever optimisation code there
18:51:23 <Vorpal> ais523, how would you get those bootstrapping constants?
18:51:35 <ais523> I think it works by detecting that the combined effect of two programs made no change, and just fastforwarding the loop
18:51:35 <myndzi> ais523: it may be the result of my work then!
18:51:43 <ais523> Vorpal: err, it's a mess
18:51:46 <myndzi> oh wait i see what you mean
18:52:20 <myndzi> what i was talking about is different from that, and maybe it is hard to combine them, unsure
18:52:39 <ais523> what's a good pastebin for Scheme?
18:52:43 <myndzi> i remember there being limitations like you couldn't nest shorthand
18:52:53 <ais523> you can nest shorthand
18:52:55 <myndzi> and it wasn't being interpreted in-place
18:53:05 <Vorpal> ais523, sprunge.us, add ?scheme to end of url iirc
18:53:07 <myndzi> it was being expanded into a string buffer or something
18:53:18 <myndzi> so i worked out how to process it in-place
18:53:26 <myndzi> but now i don't quite remember ;) it was pretty simple though
18:53:29 <Gregor> elliott: It expands it if it contains [ or ] or is a %-loop, so only simple *-loops remain.
18:53:32 <ais523> http://sprunge.us/NQXK?scheme
18:53:53 <myndzi> %-loops was the thing i solved
18:54:01 <myndzi> that's the (a{b}c)%n right?
18:54:02 <ais523> Gregor: %-loops were actually designed to be interpretable without expansion in the presence of [ and ], that's their purpose
18:54:12 <ais523> but they didn't really catch on
18:54:18 <elliott> ais523: I like that original program
18:54:29 <Gregor> ais523: Well, I'm lazy :P
18:54:29 <Vorpal> ais523, yeah I was reading
18:54:31 <ais523> elliott: it's the mockingbird combinator
18:54:37 <myndzi> i dunno, i just remember last it was discussed there was a problem with it somehow
18:54:43 <elliott> ais523: is that the initial Feather interpreter?
18:54:48 <ais523> Feather embeds untyped lambda calculus
18:54:55 <elliott> it should be the initial interprete
18:54:56 <ais523> although it's a metacircular test
18:55:03 <ais523> and indeed it would, but I doubt that helps
18:55:09 <ais523> perhaps you can retroactively make it do that later
18:55:09 <elliott> ais523: your scheme style is horrible
18:55:11 <Vorpal> ais523, okay that hurts my brain to read. Impressive.
18:55:26 <ais523> what in particular's unidiomatic about it?
18:55:30 <ais523> (I hardly know Scheme)
18:55:33 <elliott> ais523: well, right off the bat, you have
18:55:50 <Vorpal> ais523, no, it isn't that. It is the feather bit that hurts. And yeah what elliott said
18:55:55 <elliott> ais523: secondly, "addmethod" -> "add-method", "feather_blah" -> "feather-blah", etc.
18:56:12 <elliott> also, you have an awful lot of nesting, but in an interpreter that's probably unavoidable
18:56:19 <elliott> although, returning (remainder parsed) is wrong
18:56:22 <elliott> return (remainder . parsed)
18:56:36 <ais523> tuple rather than list?
18:56:49 <ais523> lists are easier to read once it generalises past two elements
18:57:09 <Vorpal> ais523, a list is made out of tuples though (cons cells are 2-tuples)
18:57:25 <myndzi> by its name, i assume it is just a straight attack but slower
18:57:27 <elliott> ais523: yes, but you only have two elements
18:57:28 <ais523> myndzi: IIRC, it's an attack program, but one that moves slowly setting up lots of decoys, and tries not to fall for standard tricks
18:57:30 <myndzi> which threw off defend versions at the time
18:57:31 <elliott> ais523: and car/cdr are nice accessors
18:57:46 <ais523> that feels like abuse of cons to me
18:57:52 <ais523> although I know schemers do that all the time
18:57:55 <myndzi> well it's short enough: >(+)*19>(-)*19(>++++++>------)*1>+>->->+(>[[-(+)*22[-]]+>[+(-)*22[+]]->]+)*21
18:58:03 <Vorpal> ais523, you are more used to comon lisp?
18:58:05 <ais523> I prefer my lang, mentally, to be based on lists rather than conses, for whatever reason
18:58:18 <ais523> Vorpal: not really, I'm not a big Lisp user at all
18:58:30 <ais523> it's just that Scheme had pretty much exactly the right feature set for Feather
18:58:32 <myndzi> it alternates its attack
18:58:41 <myndzi> to average the results from polarized decoys
18:58:48 <myndzi> i don't know why -(+)*22
18:58:52 <myndzi> maybe to trip tripwires?
18:58:54 <Vorpal> ais523, I find the indention somewhat confusing too. Especially around your let statements.
18:59:10 <Vorpal> but it was too long ago I did scheme, I don't remember how it should be done
18:59:19 <ais523> that indentation is correct, I think it's crazy because the line breaks are in the wrong place
18:59:20 <elliott> however Emacs does it is correct
18:59:29 <Vorpal> ais523, that could be it
19:00:01 <myndzi> i wish i remembered why i did that haha
19:00:06 <myndzi> it's probably something tricky! ;)
19:00:07 <impomatic> How do I submit a BFJoust program from a file?
19:00:10 <myndzi> it also leaves a decoy trail
19:00:22 <EgoBot> Score for quintopia_adlout: 2.1
19:00:37 <myndzi> ais523: any chance you know why i would have done that? :P
19:00:42 <myndzi> it's gonna bother me all day now haha
19:00:48 <ais523> impomatic: post the file online, submit a program starting http://
19:00:56 <ais523> and it'll detect that it looks like an URL and download it rather than using it raw
19:01:17 <ais523> myndzi: it may well have been specifically to defeat defend9
19:01:32 -!- impomatic has quit (Quit: ChatZilla 0.9.86 [Firefox 3.5.16/20101130074636]).
19:01:40 <ais523> I don't think that alone makes any difference to defend7
19:01:53 <myndzi> did defend9 leave off-by-1 decoys?
19:02:16 <ais523> no, but it worked based on timings
19:02:37 <myndzi> hum, it wouldn't matter with the decoys anyway, just tripwires that sit on 1 or -1
19:02:39 <ais523> I suspect that + to trip confused its timing when combined with the 22
19:02:58 <myndzi> oh yeah, it was to trip tripwires
19:03:04 <myndzi> because it trips them either way if they sit on 1
19:03:05 <ais523> which gives the appearance of having been programmed specifically to give a timing that caused defend9 to mis-ID the strategy
19:03:30 <ais523> defend9 could ID [-] pretty easily normally, but the 22 was probably just enough to make it think it was something else
19:03:41 -!- impomatic has joined.
19:03:52 <ais523> one thing I don't get is why it beats defend7
19:03:54 <myndzi> the 22 was just an offset clear of about 20
19:04:12 <impomatic> Grrrr... Chatzilla crashes every time I click a link. It's about time I installed something else
19:04:18 <myndzi> i'm pretty sure i only chose it to tackle decoys of up to 20 in size
19:04:25 <ais523> it beats it for every possible timing, too
19:04:40 <ais523> impomatic: indeed, especially if you have a tendency to click links
19:05:02 <ais523> anyway, likely the only reason slowrush wins is those massive decoys at the start
19:05:04 <impomatic> !bfjoust scimitar http://candlebags.co.uk/temp/1.txt
19:05:12 <elliott> Deewiant: getting wrapping right + headache = awesome?
19:05:13 <myndzi> anyway, that's the 'slow' part
19:05:33 <EgoBot> Score for impomatic_scimitar: 44.1
19:05:35 <myndzi> it was easier than editing it out ;) i think it used to be 2 or something
19:05:44 <myndzi> plus i could change it later
19:06:54 <ais523> it's instructive to look at the summary for tripstridewire vs slowrush (which I ran in a locally modified egojoust to print the loss reasons for each length); tripstridewire wins alternate lengths for short programs, but loses on the long ones
19:07:16 <ais523> because it's just a case of whether it can get over to your flag before your setup is complete
19:07:21 <quintopia> yeah i don't get why it beats defend7 either :P it looks ridiculously stupid. has something to do with the creating big decoys out of nowhere and then destroying them probably
19:07:53 <myndzi> there is that too, i guess
19:07:58 <myndzi> i mean, i leave behind simple decoys
19:08:06 <myndzi> but if you ran into it while i was in a loop, i dunno what happen
19:08:47 <elliott> Deewiant: Man, per-line-and-per-column bounds are really tricky to do wrapping with.
19:08:53 <quintopia> yeah i just meant in terms of defend7's strategy of going out into the world and cycling every cell through all its values
19:08:54 <myndzi> but it would only do that on a cell that had been altered so...
19:09:05 <Vorpal> elliott, why are you doing it that way
19:09:08 <Deewiant> elliott: I've never done that, so I wouldn't know.
19:09:10 <elliott> Vorpal: Because that's how I store bounds?
19:09:11 <Vorpal> elliott, it won't work for non-cardinal anyway
19:09:23 <myndzi> yeah, defend can't depend on the value of any cell
19:09:28 <Vorpal> elliott, you would have to check if it went outside then insid
19:09:29 <myndzi> it has to get home in time for lunch
19:09:34 <elliott> (minX,maxX) = Map.findWithDefault undefined y' (rowBounds fs)
19:09:35 <elliott> (minY,maxY) = Map.findWithDefault undefined x' (colBounds fs)
19:09:36 <myndzi> so it takes a long time to w in
19:09:37 <elliott> in if x' < minX || x' > maxX || y' < minY || y' > maxY then ...
19:09:38 <Vorpal> elliott, like one line being shorter than another
19:10:02 <elliott> I'm pretty sure that will definitely work.
19:10:04 <Vorpal> elliott, oh is this for non-cardinal?
19:10:20 <impomatic> !bfjoust scimitar http://candlebags.co.uk/temp/1.txt
19:10:27 <myndzi> i remember designing one to make defend suicide
19:10:28 <quintopia> impomatic: what the heck is that doing?
19:10:36 <EgoBot> Score for impomatic_scimitar: 46.6
19:10:39 <myndzi> slowrush may have been designed with that in mind but i don't think it's the one
19:10:42 <myndzi> it was an earlier defend version
19:10:49 <myndzi> trip the tripwire then just take your time gettting there
19:11:00 <myndzi> defend decs its flag until it loses
19:11:09 <impomatic> quintopia: unfortunately it turns out I've recreated defend from scratch. :-(
19:11:17 <ais523> myndzi: aha: what happens is that the extra pair of square brackets around the attack in slowrush serves as a defend7 detector
19:11:27 -!- pikhq_ has joined.
19:11:28 <Gregor> INTELLIGENT DESIGN IN ACTION
19:11:29 -!- pikhq has quit (Ping timeout: 260 seconds).
19:11:41 <Vorpal> !bfjoust test (+-)*1000000
19:11:46 <ais523> slowrush notices that [+] went past 0 but didn't stay there the cycle afterwards, and does the whole 22-offset thing again
19:11:55 <EgoBot> Score for Vorpal_test: 8.6
19:11:58 <myndzi> oh shit i was misreading the nesting
19:12:13 <myndzi> i thought thte two were separate and it was just alternating the attacks
19:12:18 <myndzi> didn't remember they were tied together
19:12:35 <elliott> Deewiant: Hmm, Mycology wraps right after printing the first 0?
19:12:40 <myndzi> i mean the -+ and the +-
19:12:42 <ais523> that has one more pair of square brackets than normal
19:12:54 <myndzi> >(+)*19>(-)*19(>++++++>------)*1>+>->->+(>[[-(+)*22[-]]+>[+(-)*22[+]]->]+)*21
19:12:59 <Deewiant> elliott: Mycology wraps after "Befunge-98 detected"
19:12:59 <Gregor> !bfjoust aaaaah_motherland (>)*10((+)*127<)*10
19:13:01 <ais523> so the [-]], if it doesn't leave the loop, means you hit a defense program that's trying to lock you in place
19:13:14 <EgoBot> Score for Gregor_aaaaah_motherland: 1.6
19:13:15 <myndzi> they are tied togethter
19:13:17 <elliott> Deewiant: To differ, I beg
19:13:20 <myndzi> the forward and backward one
19:13:25 <quintopia> they are indeed tied together ais523
19:13:35 <myndzi> i was reading it as something like
19:13:41 <ais523> and the ingenious part is, that bit only runs against defense programs
19:13:46 <myndzi> well, something without those bracketts
19:13:52 <myndzi> yeah, i'm pretty sure i did that intentionally ;p
19:13:55 <ais523> so you use your own decoy-clear code as a timing-randomiser against defend7
19:13:57 <EgoBot> Score for Vorpal_test: 8.1
19:13:59 <myndzi> i just couldn't remember what i was doing haha
19:14:10 <Vorpal> how can it get any points
19:14:23 <ais523> impomatic: is scimitar just a defend7 clone?
19:14:26 <myndzi> and programs that skip tripwires suicide
19:14:29 <Gregor> Oh, I forgot to write MetaBFJoust :P
19:14:29 <ais523> Vorpal: it draws with everything, IIRC
19:14:38 <Vorpal> ais523, I thought that was fixed
19:14:48 <Vorpal> 3 | - - - 0 - + 0 - - 0 - - - - - - - - + 0 | 8.1 | -11.7 | Vorpal_test.bfjoust
19:14:51 <impomatic> ais523: I haven't checked exactly, but I think it's pretty similar.
19:15:13 <EgoBot> Score for Vorpal_test: 8.1
19:15:46 <myndzi> you don't lose for running out of code
19:15:58 <myndzi> ] doesn't try to loop because the cell is nonzero
19:16:00 <ais523> impomatic: it's not quite; the differences: defend7 uses its flag to lock the opponent, scimitar uses the cell after; and defend7 has an extra decoy for tripping anti-tripwires
19:16:03 <quintopia> Gregor: aka, submit programs that generate bfjoust programs, give them the programs they fought to learn from, and iterate?
19:16:04 <myndzi> so even though it's a syntax error.. lol
19:16:05 <Vorpal> myndzi, I thought syntax error wouldn't do that
19:16:05 <EgoBot> Score for Vorpal_test: 8.1
19:16:34 <Vorpal> ais523, does tripwire set up decoys?
19:16:36 -!- copumpkin has quit (Ping timeout: 240 seconds).
19:16:56 <ais523> tripwire itself, I can't remember
19:16:57 <myndzi> ais523: i have an idea on a similar concept actually now
19:16:59 <ais523> tripstridewire doesn't
19:16:59 <myndzi> i'll have to try later
19:17:20 <quintopia> i think the metabfjoust tourney would be the best thing ever
19:17:28 <Vorpal> !bfjoust test (>[-].)*
19:17:34 <Vorpal> !bfjoust test (>[-].)*20
19:17:39 <ais523> way to specify a repeat count
19:17:41 <EgoBot> Score for Vorpal_test: 8.3
19:17:41 <EgoBot> Score for Vorpal_test: 8.3
19:18:29 <ais523> hmm, slowrush shows huge signs of being optimised specifically to beat its main competitors at the time
19:18:43 -!- poiuy_qwert has quit (Quit: This computer has gone to sleep).
19:18:51 <ais523> also interesting: defend7 beats a lot more than scimitar, but scimitar tends to beat better programs
19:18:51 <Gregor> ais523: And yet, it's still on the top of the hill :P
19:19:00 -!- copumpkin has joined.
19:19:02 <ais523> (and ofc, they draw with each other)
19:19:15 <Gregor> And no claiming that my score-calculation algorithm is unfair :P
19:19:30 <ais523> I think slowrush took a generically good program, and tweaked it to beat a bunch of specific strategies that beat it
19:19:35 <ais523> which is of course a legitimate thing to do
19:19:42 <quintopia> so the scoring system gives you a better ranking for beating better programs?
19:20:10 <Gregor> quintopia: http://codu.org/eso/bfjoust/SCORES
19:20:52 <ais523> Gregor: tripstridewire is a bit of an exploit of your scoring algo, btw, seeing as it normally loses overall but is optimised for short tapes and so doesn't lose very badly to most programs
19:20:56 <elliott> Deewiant: The essential trickiness seems to be that whenever I say "foo < minFoo", I actually mean "foo > maxFoo" if dfoo is negative, and my headache isn't showing any signs of going away.
19:21:01 <ais523> thus it doesn't lose so many points
19:21:20 <Deewiant> elliott: Just separate the two dfoo cases?
19:21:35 <Gregor> ais523: If you have suggestions for a better scoring algorithm ... TOO BAD, mine is perfect by definition.
19:21:46 <ais523> I don't, it's part of the game
19:21:48 <quintopia> ais523: what do you think of having a "gauntlet" of simple programs that never get deleted that contribute to the program's score in addition to the hill battles?
19:21:50 <elliott> Deewiant: Yeah, except that when I do that, it fails :-D
19:21:53 <Vorpal> elliott, in taste or what?
19:22:02 <quintopia> we could pick and choose which programs go in the "gauntlet"
19:22:04 <ais523> quintopia: people might just exploit specific failings of them
19:22:08 <Vorpal> elliott, I thought Alvedon was the really bad one when it came to side effects?
19:22:14 <Deewiant> elliott: You're doing it wrong :-P
19:22:18 <ais523> I think the "gauntlet" is made up atm by the programs that have been there over a year
19:22:23 <ais523> anyway, time to go home
19:22:24 -!- ais523 has quit (Remote host closed the connection).
19:22:26 <elliott> Vorpal: http://en.wikipedia.org/wiki/Aspirin#Adverse_effects
19:23:48 <quintopia> and yet every now and then ... stupid programs get added that do much better than they should... and there's no way to prevent a single strategy from taking over half of the hill
19:23:58 <Vorpal> elliott, hm they are all more or less bad it seems
19:24:07 <impomatic> !bfjoust scimitar http://candlebags.co.uk/temp/1.txt
19:24:21 -!- pumpkin has joined.
19:24:45 <EgoBot> Score for impomatic_scimitar: 0.0
19:24:49 <elliott> Vorpal: Adverse effects, bad? Never!
19:25:06 <Vorpal> quintopia, they aren't stupid if they work :P
19:25:30 <Vorpal> quintopia, besides there is beauty in simplicity
19:25:35 <elliott> Deewiant: What does it means if I get "0 4 ".
19:25:37 <quintopia> Vorpal: they only work against specific opponents though, but that's enough to take over half the hill
19:25:50 <impomatic> !bfjoust scimitar http://candlebags.co.uk/temp/1.txt
19:25:54 <Vorpal> quintopia, that's the scoring code that is problematic then
19:26:10 <elliott> Gregor: I suggest that you weight programs such that a program gets penalised more heavily for not beating more of the hill.
19:26:16 <elliott> Gregor: Perhaps make it exponential or something.
19:26:28 <elliott> Gregor: (But make sure to take into account not penalising for losing to really bad programs)
19:26:34 <Vorpal> but I find the specialised ones quite interesting
19:26:35 <EgoBot> Score for impomatic_scimitar: 37.7
19:26:37 -!- copumpkin has quit (Ping timeout: 240 seconds).
19:26:58 <Deewiant> elliott: Your v moves southwest instead of south?
19:27:08 <elliott> Deewiant: No, all I've changed is my wrapping code :-D
19:27:18 <impomatic> !bfjoust scimitar http://candlebags.co.uk/temp/1.txt
19:27:23 <Deewiant> Your wrapping code should have no effect until before "Befunge-98 detected"
19:27:48 <elliott> Deewiant: Well... it "wraps" after you output 0 for me.
19:27:57 <Vorpal> elliott, you are doing it wrong then
19:28:04 <Deewiant> elliott: Find the wrap: 0#@>. 1#@v
19:28:08 <EgoBot> Score for impomatic_scimitar: 46.6
19:28:19 <elliott> Then something is fucked HOORAY
19:28:41 -!- Sgeo has quit (Ping timeout: 255 seconds).
19:29:12 <elliott> Deewiant: Fixed by doing something that makes no sense!!!
19:29:22 <elliott> Map.alter (\x -> Just $ maybe (v,v) (\(minv,maxv) ->
19:29:22 <elliott> (if v < minv then v else minv,
19:29:22 <elliott> if v > maxv then v else maxv)) x) k
19:29:23 <Vorpal> impomatic, why do you do >->+[]< hm...
19:29:32 <elliott> Now, stop me if I'm wrong.
19:29:40 <elliott> But surely the row bounds should be indexed by y?
19:29:48 <Vorpal> impomatic, oh you defend the first decoy after?
19:30:13 <impomatic> Vorpal: defend on the first cell after the flag.
19:31:45 <Vorpal> elliott, v < minv? Not the other way around?
19:32:01 <impomatic> Apparently defend7 defends on the flag, but if I try that next I'll probably end up with the same code :-(
19:32:05 <elliott> Vorpal: If the new value is lower than the minimum bound, the new value is the new minimum bound.
19:32:36 <Vorpal> elliott, wait. If v is less that minumum, then v
19:32:58 <Vorpal> thought it was wrapping
19:33:26 <elliott> Vorpal: But the thing is, I'm indexing the _ROW_ bounds with x which is the _column_
19:33:37 <impomatic> !bfjoust scimitar2 http://candlebags.co.uk/temp/2.txt
19:33:58 <EgoBot> Score for impomatic_scimitar2: 42.4
19:35:41 <Vorpal> Gregor, why http://codu.org/eso/bfjoust/report-2009-05-29-20-17.mp4
19:35:56 <Gregor> Vorpal: Because I felt like it? :P
19:37:07 <impomatic> !bfjoust scimitar2 http://candlebags.co.uk/temp/3.txt
19:37:20 <EgoBot> Score for impomatic_scimitar2: 0.0
19:37:42 <Gregor> impomatic: Why in god's name do you have /temp/ access to candlebags.co.uk?
19:37:54 <EgoBot> Score for impomatic_scimitar2: 8.9
19:37:58 <Gregor> (Note the decapitalization of "god" that makes the above phrase totally meaningless)
19:38:11 <elliott> Candlebags is actually a street name for crack cocaine.
19:38:23 <Gregor> *stars fly over our heads8
19:38:38 <Vorpal> impomatic, you sell the stuff in http://candlebags.co.uk/ ?
19:38:52 <elliott> No. He sells crack cocaine POSING as that. (Note: Also lies)
19:39:02 <Gregor> It's actually just uncut pure cocaine.
19:40:22 <Vorpal> Gregor, I'd like mine in a rose cut
19:40:27 <impomatic> Elliott: no crack, that'd be my other website
19:40:31 <elliott> PEOPLE WHO BELIEVE IMPOMATIC'S COVER STORY: 0
19:40:40 <elliott> PEOPLE WHO DON'T BELIEVE IMPOMATIC'S COVER STORY: All of them
19:40:41 <Gregor> crackcocaineforyouhooray.co.uk
19:40:49 <elliott> Gregor: A+++ would buy from similarly-named sites again
19:43:37 <Vorpal> Gregor, what does codu stand for
19:45:09 <elliott> Crack Orgies? Dtotally Usoldhere
19:48:13 -!- Lymia__ has joined.
19:49:25 -!- elliott_ has joined.
19:49:28 <elliott_> Deewiant; So does CCBI really solve diophantines for wrapping?
19:49:34 -!- elliott has quit (Read error: Connection reset by peer).
19:49:46 <elliott_> Deewiant: What license is CCBI under again?
19:50:06 <Vorpal> elliott_, are you going to just copy what he wrote?
19:50:07 <elliott_> Deewiant: How imperative is the code :P
19:50:15 <quintopia> does [-] decrement every 3 cycles or every other cycle?
19:50:19 <elliott_> At least until I can figure out wtf is wrong.
19:50:28 <Deewiant> It's pretty complicated though :-P
19:51:24 -!- Lymia_ has quit (Ping timeout: 240 seconds).
19:51:38 -!- copumpkin has joined.
19:52:05 -!- pumpkin has quit (Ping timeout: 255 seconds).
19:56:36 <Vorpal> <elliott_> Deewiant; So does CCBI really solve diophantines for wrapping? <-- do you think I would lie?
19:56:44 <elliott_> No, but I think you might misunderstand :P
19:57:33 <elliott_> I think my wrapping is broken again X_X
19:57:37 <elliott_> Why is this so fucking hard to get right
19:57:49 <Vorpal> elliott_, why are you not doing it as a single bounding box?
19:57:50 <Deewiant> Why don't you implement the trivial algorithm straight from the spec
19:57:54 <elliott_> It's those stupid fucking non-cardinal directions.
19:57:59 <elliott_> Deewiant: I am and it isn't working :P
19:58:05 <elliott_> Deewiant: Because of the awy I store bounds.
19:58:08 <elliott_> Vorpal: Because that doesn't allow for shrinking.
19:58:15 <Deewiant> If you fall outside bounds, turn around and move until you fall outside bounds again, and then reverse
19:58:29 <elliott_> Deewiant: That's what I've been doing.
19:58:33 <Vorpal> elliott_, just keep member counts for each column and row
19:59:04 <Vorpal> elliott_, that won't work for jagged bounds. Think of one short line between two really long ones. Or a situation where funge space is:
19:59:31 <elliott_> Deewiant: Meh, I'll just store bounds as a rectangle, Vorpal is right for once.
20:00:02 -!- copumpkin has quit (Ping timeout: 250 seconds).
20:00:08 <Vorpal> it is patently obvious anyway
20:02:18 <Vorpal> elliott_, maybe you should go rest then
20:03:11 -!- copumpkin has joined.
20:04:00 <elliott_> Deewiant: OK, it now wraps after "p modifies space" which is indeed the correct place.
20:05:49 -!- myndzi_ has joined.
20:06:32 <elliott_> Deewiant: Do you stop moving when *one* coord goes out of bounds, or when *both* go out of bounds?
20:06:37 <Vorpal> what is the point of that
20:06:50 <Vorpal> it seems a bit pointless to me
20:07:01 <Vorpal> oh wait, you aren't using ssl to freenode myndzi_?
20:07:40 <Vorpal> elliott_, you mean for wrapping?
20:07:47 <Vorpal> elliott_, one coord I believe
20:08:33 <elliott_> What if both are out of bounds? Do you correct both to be in-bounds, or just one?
20:08:36 <Vorpal> elliott_, at least with the simple bounding box model that should work
20:08:41 <elliott_> What if both are out of bounds? Do you correct both to be in-bounds, or just one?
20:08:56 <Vorpal> `addquote <elliott_> I'm a bit 'tarded.
20:08:57 <HackEgo> 297) <elliott_> I'm a bit 'tarded.
20:09:26 <Deewiant> `addquote ( Vorpal) `addquote <elliott_> I'm a bit 'tarded. ( Vorpal) (NOTHING PERSONAL!)
20:09:26 <HackEgo> 298) ( Vorpal) `addquote <elliott_> I'm a bit 'tarded. ( Vorpal) (NOTHING PERSONAL!)
20:09:31 <quintopia> myndzi_: [-] <--how many cycles per dec?
20:09:58 <elliott_> Deewiant: That... worst nickname format ever.
20:10:11 <elliott_> `run sed -i 's/( Vorpal)/<Vorpal>/g' quotes
20:10:13 <Vorpal> and I agree with elliott_ on that one
20:10:15 -!- GreaseMonkey has joined.
20:10:17 <HackEgo> 298) <Vorpal> `addquote <elliott_> I'm a bit 'tarded. <Vorpal> (NOTHING PERSONAL!)
20:10:20 <olsner> multi-line quotes always end up so ugly :/
20:10:28 <elliott_> Only because MORONS DON'T PUT TWO SPACES BETWEEN MESSAGES
20:10:40 <elliott_> `run sed -i s'/tarded. <V/tarded. <V/g' quotes
20:10:44 <HackEgo> 298) <Vorpal> `addquote <elliott_> I'm a bit 'tarded. <Vorpal> (NOTHING PERSONAL!)
20:11:07 <olsner> you're a bit of a 'tard, obviously
20:11:36 <impomatic> !bfjoust scimitar2 http://candlebags.co.uk/temp/3.txt
20:11:38 <elliott_> Hey Deewiant, what has three ducks and quacks like hanging after "GOOD: p modifies space"
20:12:30 <EgoBot> Score for impomatic_scimitar2: 43.9
20:12:33 <olsner> damn annoying WM bug, the taskbar loses the ability to change focus
20:12:47 <olsner> clicking just starts the "wants attention" animation
20:13:45 <elliott_> Deewiant: Seriously though, what's wrong with this logic: If the coordinate oversteps either current boundary, jump it to the opposite one.
20:13:59 <elliott_> That's pathological if you e.g. go off the end of the right and there's 2 billion spaces before the single instruction before the end.
20:14:05 <elliott_> But it seems like it'd normally be faster.
20:14:07 <EgoBot> Score for impomatic_scimitar2: 8.9
20:14:21 <Vorpal> elliott_, that works for cardinal?
20:14:27 <elliott_> Vorpal: Oh, is that cardinal-only?
20:14:33 <elliott_> olsner: xfwm is really bad IME
20:14:33 <Vorpal> elliott_, not for flying of course
20:14:47 <Vorpal> elliott_, see the reversing algorithm for flying!
20:14:54 <elliott_> BAD: wraparound with non-cardinal delta doesn't work
20:15:04 <olsner> it seems time-related, but I dunno if it's about uptime or just about more opportunities for the right case to happen
20:15:25 <Vorpal> elliott_, Why don't you just do the flying algorithm from the spec
20:15:39 <olsner> elliott_: why so? except for this bug I think it's as good as any wm I've tried
20:15:41 <Vorpal> elliott_, on boxy bounds?
20:15:43 <elliott_> wrap minXY@(minX,minY) maxXY@(maxX,maxY) (Ray (x,y) d@(dx,dy))
20:15:43 <elliott_> | oobX || oobY = Ray (if oobX then x+dx else x, if oobY then y+dx else y) d
20:15:43 <elliott_> | otherwise = wrap minXY maxXY (Ray (x-dx,y-dy) d)
20:15:43 <elliott_> where oobX = x < minX || x > maxX
20:15:45 <Vorpal> elliott_, or on jagged ones?
20:15:45 <myndzi_> if it wasn't already answered
20:15:52 <elliott_> Big ol' frickin' box of boxshit.
20:16:02 <olsner> at least in the "normal" category of WM's, with floating windows and stuff
20:16:02 <elliott_> (if x < minX then x else minX, if y < minY then y else minY)
20:16:02 <elliott_> (if x > maxX then x else maxX, if y > maxY then y else maxY)
20:16:06 <elliott_> That update algorithm might be wrong.
20:16:07 <Vorpal> elliott_, well I'm not sure. But cfunge implements that one
20:16:10 <myndzi_> freenode wouldn't let me connect without it on my phone
20:16:11 <Vorpal> in case you want to check
20:16:18 <Vorpal> elliott_, rather than solving equations
20:16:28 <myndzi_> my pass is a hash so it was a pain in the ass ;)
20:16:48 <elliott_> Vorpal: Can't read cfunge, it's GPL'd. If you grant me a license to read that code and rewrite a derivative-in-algorithm without restrictions...
20:16:49 -!- myndzi_ has changed nick to nescience.
20:16:52 <Vorpal> myndzi_, err. Why not on your phone?
20:17:07 -!- nescience has changed nick to evitable.
20:17:14 <Vorpal> elliott_, alas I can't. Other copyrightholders
20:17:18 <Vorpal> elliott_, including you and ais
20:17:18 <elliott_> evitable: you can't evit the inevitable
20:17:25 <olsner> elliott_: which window manager would you recommend though?
20:17:26 <elliott_> Vorpal: They haven't touched the wrapping code.
20:17:31 <elliott_> Vorpal: I mean just this single algorithm.
20:17:33 <evitable> I don't know, I think bot protection
20:17:39 <Vorpal> elliott_, remember when you ported it to cygwin!
20:17:44 <evitable> maybe my ip falls in a restricted block
20:17:44 <elliott_> olsner: Although dwm is quite nice. :p
20:17:53 <evitable> or - oh - probably because no ident
20:17:55 <elliott_> Vorpal: I grant myself the appropriate license. And as ais523 hasn't touched the wrapping code...
20:17:58 <Vorpal> elliott_, wait, let me rewrite it in asm!
20:18:01 <olsner> elliott_: dwm is a tiling wm, right?
20:18:05 <Vorpal> elliott_, actually you didn't touch wrapping code
20:18:11 <Vorpal> elliott_, anyway it is rather imperative
20:18:11 <elliott_> olsner: Well, yes, but it's dynamic tiling.
20:18:30 <elliott_> Vorpal: That's okay, I just want to see the damn thing :P
20:18:35 <elliott_> Because I'm implementing this perfectly.
20:18:51 <Vorpal> elliott_, just remember to mention me in credits!
20:19:00 <elliott_> Vorpal: That's not a no-restrictions license.
20:19:10 <elliott_> But hey, that's all right, you can't copyright an algorithm anyway.
20:19:10 <Vorpal> elliott_, indeed it is BSDish
20:19:21 <fizzie> I thought the SASL-auth thing only applied to people connecting via Tor. I mean, quite a few people don't have a reachable identd.
20:19:33 <elliott_> // NOTE: This has been duplicated in funge-space.c for speed reasons.
20:20:00 <elliott_> It just MAKES THE FUNCTION FASTER.
20:20:08 <Vorpal> elliott_, actually the inlining helped
20:20:12 <Vorpal> elliott_, I did profile it
20:20:17 <Vorpal> and we are talking about a 20%
20:20:23 <elliott_> What is it with Befunge implementers and profiling.
20:20:28 <elliott_> Vorpal: You could have put it in a C file to be #included :P
20:20:28 <fizzie> Googling freenode + sasl only finds that recent "be safe out there" blog-post that they have in the MOTD, which says "One form of spam, popular recently, claims that freenode will require SASL to connect."
20:20:51 <Vorpal> elliott_, anyway it is fungespace_wrap you want to check
20:20:56 <elliott_> I like how you have a CFUN_OBEY_THE_SPECIFICATION define.
20:21:06 <elliott_> // FIXME, HACK: Why are the +1/-1 needed?
20:21:09 <elliott_> FEELING GOOD ABOUT THIS CODE GUYS
20:21:20 <Vorpal> elliott_, that is for cardinal :P
20:21:36 <Vorpal> elliott_, you only need the section after
20:21:39 <Vorpal> with the do-while loop
20:22:25 <elliott_> As far as I can tell, your code shouldn't be able to work.
20:22:29 <elliott_> BAD: wraparound skips easternmost cell
20:22:39 <elliott_> Because you increment the x and y by the delta unconditionally...
20:22:43 <Vorpal> elliott_, uh that is not BAD
20:22:47 <elliott_> whereas you should surely only do it for those coordinates that are out of bounds.
20:22:48 <evitable> I saw that too fizzie, but it disconnects me and says this server requires sasl
20:22:50 <Vorpal> at least was last I checked
20:22:55 <elliott_> Deewiant: Facepalm Vorpal for me.
20:22:58 <Vorpal> elliott_, not when I wrote the code. Why is it bad now
20:23:01 <elliott_> Or just give him the ability to read.
20:23:10 <Vorpal> elliott_, I thought you said something else
20:23:13 <elliott_> OTHER THINGS THAT HELP VORPAL UNDERSTAND: Mocking.
20:23:15 <evitable> it doesn't do it on my home computer
20:23:21 <Vorpal> <elliott_> Because you increment the x and y by the delta unconditionally... <-- what else should you do
20:23:27 <Vorpal> if you don't what the heck are you doing
20:23:31 <elliott_> Vorpal: Increment only the coordinates that are out of bounds.
20:23:45 <Vorpal> elliott_, that is a bug obviously
20:23:52 <elliott_> Vorpal: Because otherwise you skip the first cell?
20:24:00 <Deewiant> elliott_: You have to move by the delta :-P
20:24:07 <elliott_> wrap minXY@(minX,minY) maxXY@(maxX,maxY) (Ray (x,y) d@(dx,dy))
20:24:07 <elliott_> | oobX || oobY = Ray (x+dx, y+dx) d
20:24:07 <elliott_> | otherwise = wrap minXY maxXY (Ray (x-dx,y-dy) d)
20:24:07 <elliott_> where oobX = x < minX || x > maxX
20:24:12 <elliott_> Deewiant: SERIOUSLY, HOW CAN THIS CODE NOT BE PERFECT
20:24:18 <fizzie> :lindbohm.freenode.net NOTICE * :*** No Ident response ← but it didn't really matter, it let me in just fine.
20:24:20 <elliott_> IT'S NOT TARDULOUS IN THE SLIGHTEST
20:24:35 -!- fizzie3 has joined.
20:25:06 <fizzie3> :Yes, I always type "USER 1 2 3 4" when I can't be bothered to remember the parameters. :p
20:25:36 <fizzie3> Yet I am not a number! I am a free man!
20:25:40 <elliott_> "My real name is 4, but I go by fizzie3 on the Internet. I log in as 1."
20:25:48 -!- fizzie3 has quit (Client Quit).
20:26:09 <Vorpal> elliott_, WM as in window manager?
20:26:26 <Vorpal> elliott_, anyway do you move by delta now
20:26:42 <Vorpal> or do you still do the "only mess with one out of bounds" weirdness
20:26:42 <elliott_> No, because that, as I said, breaks it.
20:26:46 <elliott_> Now let me fix my fucking WM >_<
20:26:59 <Vorpal> elliott_, well the correct thing is to move by delta always
20:27:19 <elliott_> I fucking do. Argh, it has a typo. LET ME FIX MY WM stop talking okay how do i kil lthis thing
20:28:28 -!- elliott_ has quit (Remote host closed the connection).
20:28:32 -!- elliott has joined.
20:29:21 <Vorpal> elliott, that is trivial with cfunge's algorithm!
20:29:34 <elliott> That's the algorithm I'm using you asswipe. :P
20:29:45 <Vorpal> elliott, for shrinking? It has one?
20:29:57 -!- ais523 has joined.
20:29:59 <Vorpal> elliott, that was what I was talking about
20:30:14 <Deewiant> Use CCBI's algorithms, they're highly nontrivial but at least they're FAST
20:30:54 <elliott> Deewiant: I'd have to convince myself that solving diophantines for wrapping is actually something a sane person could think of before doing that.
20:31:01 <elliott> And that will take a very, very long time.
20:31:28 <elliott> Oh yes. Deewiant: What the fuck does "s" do. I can't find it in the spec. Only in the reference.
20:31:28 <ais523> hmm, hopefully they aren't generalised diophantines
20:31:39 <Deewiant> Solving diophantines in the sense that you're solving differential equations when you write distance = speed * time
20:31:39 <Gregor> Why is it that whenever I put music anywhere, there's a bunch of indifferent people, one or two people who like it, and one audiophile douchetard who complains about the reverb effect or a particular synth instrument.
20:31:45 <elliott> "s "Store Character" is the mirror image of the ' instruction: this instead pops a value off the stack and writes it into (position + delta).
20:31:57 <ais523> Gregor: is it the same audiophile every time?
20:31:59 <elliott> Gregor: Hey, I like your music
20:32:09 <Gregor> elliott: You're not the audiophile douchetard :P
20:32:12 -!- impomatic has quit (Quit: ChatZilla 0.9.86 [Firefox 3.5.16/20101130074636]).
20:32:37 <ais523> Gregor: elliott will just claim that the filename's written in Arial rather than Helvetica on the virtual album cover
20:33:08 <ais523> elliott: a friend of mine from work said that a certain range of PostScript printers actually detected that you were trying to print something in Arial and silently substituted Helvetica
20:33:15 <ais523> which is both evil and awesome
20:33:26 <ais523> (presumably it was to make the output look better than that of other printers')
20:33:27 <elliott> not that anyone would notice :P
20:34:48 <elliott> Deewiant: Holy shit @ negative j.
20:34:55 <fizzie> elliott: It also skips over the newly written character, which is a bit of a shame; I used to hope 's' was sort-of an "execute from stack" thing.
20:35:06 <elliott> Deewiant: Wait, j skips over *spaces*. So is it actually indifferent to speed?
20:35:18 <Deewiant> j is like # but with an argument.
20:36:08 <olsner> ah, xfwm4 can be restarted without logging out, which fixed the taskbar bug
20:36:12 <Gregor> Uhhh, are Arial and Helvetica even metric-compatible? I guess they must be ...
20:36:16 <ais523> most WMs can, actually
20:36:18 <elliott> Gregor: They're almost identical.
20:36:27 <elliott> Gregor: Except whenever they differ, Helvetica is significantly less ugly :P
20:36:41 -!- pumpkin has joined.
20:36:52 <Gregor> I love the joyous life of being neither a typefaceofile nor an audiophile :P
20:37:06 <Gregor> I'll stick with better philias thank you very much.
20:37:18 <Vorpal> elliott, >1j is same as >#
20:37:37 <zzo38> Have you ever tried to design typefaces using METAFONT or any other program?
20:37:38 <Vorpal> (where > shows direction of entry)
20:37:57 <ais523> zzo38: I've designed a couple of very small ones in pixel editors (MS Paint-like programs)
20:38:08 <Vorpal> elliott, not where it should
20:38:15 <Vorpal> elliott, which is directly after the s
20:38:20 <Gregor> zzo38: http://codu.org/gregor_handwriting.ttf BEST TYPEFACE EVER
20:38:22 <elliott> Vorpal: What, even ignoring the delta?
20:38:34 <Vorpal> elliott, directly after wrt delta of course
20:38:35 <elliott> Ray (x,y) (dx,dy) <- gets (ray . ip)
20:38:45 <elliott> Looks fine to me, bitches.
20:38:46 <fizzie> Remember to skip over it.
20:38:53 <elliott> Ray (x,y) (dx,dy) <- gets (ray . ip)
20:38:53 <elliott> push =<< peek (x+dx, y+dy)
20:38:55 <Gregor> elliott: If p[a]ed means both "foot" and "child", then what's the proper name for a foot fetish? ANSWER ME THAT
20:39:13 -!- copumpkin has quit (Ping timeout: 240 seconds).
20:39:18 <zzo38> Gregor: "Footfetish".
20:39:38 <elliott> `addquote <ineiros> HELLWORLD! <fizzie> It's like HELLO WORLD, except not *quite*. <ineiros> There is more agony.
20:39:39 <HackEgo> 299) <ineiros> HELLWORLD! <fizzie> It's like HELLO WORLD, except not *quite*. <ineiros> There is more agony.
20:40:13 <elliott> Ray (x,y) (dx,dy) <- gets (ray . ip)
20:40:50 <fizzie> Did notice it before the "poke line" comment, but only now on the second look.
20:40:54 <Vorpal> elliott, why aren't you using coq for all but the main loop?
20:41:04 <fizzie> Doesn't your compilator give a "x hides x" sort of warnings?-)
20:41:11 <elliott> then replicateM_ (fromIntegral n) advance
20:41:11 <elliott> else replicateM_ (fromIntegral n) retreat
20:41:17 <elliott> fizzie: Err, yes, I have -Wall turned off.
20:41:33 <elliott> Holy shit so many warnings
20:41:47 <zzo38> What would happen if you have some program to make music from a METAFONT output?
20:41:49 <elliott> Mostly because I use ip as the accessor name and variable name.
20:41:54 <elliott> Which will fix itself when I introduce Concurrent Funge.
20:41:57 <elliott> Because it'll turn into "ips".
20:42:29 <elliott> Hey Deewiant, I fixed it but your thing says it's still not-fixed, what givens
20:42:59 <elliott> then replicateM_ (fromIntegral n) advance
20:42:59 <elliott> else replicateM_ (fromIntegral (abs n)) retreat
20:43:01 <elliott> modifyRay (\(Ray (x,y) (dx,dy)) -> nextPos fs (Ray (x,y) (-dx,-dy)))
20:43:10 <elliott> That flips the delta permanently
20:43:15 <Vorpal> elliott, so is your code!
20:43:41 <elliott> I like how somehow Deewiant's code can recover from the delta flipping on negative j.
20:44:51 <Vorpal> elliott, it is a test suite
20:45:06 <Vorpal> it has to be able to give you errors
20:45:22 <lambdabot> forall a b (m :: * -> *). (Monad m) => (a -> b -> m a) -> a -> [b] -> m a
20:45:24 <Vorpal> elliott, and then I guess it just happens to go with > or such to the same place
20:45:54 <Deewiant> It's an obvious mistake to make.
20:46:09 <elliott> Deewiant: Obvious howso :P
20:46:30 <elliott> BAD: u doesn't reflect when stack stack has only one stack
20:46:30 <elliott> ...yes it does you stupid thing
20:46:49 <Vorpal> elliott, is that u or } ?
20:47:10 <Vorpal> and what Deewiant said
20:47:47 <elliott> Vorpal: Seems obvious because you didn't write it
20:47:48 -!- Lymia_ has joined.
20:47:49 <Vorpal> Deewiant, u doesn't reverse does it?
20:48:11 <Vorpal> okay so if u reverse, is it { and } that don't?
20:48:25 <Vorpal> I know ONE of them doesn't
20:48:26 <elliott> { reflects on out-of-memory.
20:48:29 <elliott> } reflects on empty stack stack.
20:48:33 <Vorpal> elliott, I mean when copying
20:48:34 <elliott> Err, *less than two elemented stack stack.
20:48:45 -!- impomatic has joined.
20:48:49 <elliott> Neither reflects when copying, I don't think,
20:48:53 <Vorpal> elliott, I would have said reflect otherwise
20:49:08 <elliott> "If count is negative, |count| cells are transferred (similarly in a pop-push loop) from the TOSS to the SOSS."
20:49:20 <Vorpal> elliott, I'm pretty sure u and {,} do different things for the order of copying
20:49:27 <Vorpal> the other is like memcpy
20:50:07 <Vorpal> yep I even use memcpy to do the job
20:50:38 <Vorpal> elliott, anyway u doesn't copy in the same order as { and }
20:50:46 <elliott> BAD: fedcba0{05-} doesn't leave 15 on stack
20:50:50 <elliott> OK, I had better fix this before going on any further.
20:50:58 -!- Lymia__ has quit (Ping timeout: 240 seconds).
20:51:10 <Vorpal> elliott, would be useful if it printed what it left on instead
20:52:43 <elliott> Deewiant: You really need something in the readme about that error :P
20:52:49 <elliott> I have no idea what kind of bug it implies in my {} impl.
20:53:07 <Vorpal> elliott, copy to another file. Add a print statement. Check.
20:53:21 <Deewiant> It doesn't even have a corresponding GOOD
20:53:30 <elliott> Deewiant: What's the desired result?
20:53:40 <elliott> Vorpal: Knowing what the stack ends with wouldn't help. Knowing what it should end with would.
20:53:42 <Vorpal> Deewiant, why on earth?
20:53:47 <elliott> Deewiant: I don't understand :P
20:53:48 <Deewiant> It looks like the 0{ doesn't do anything
20:53:55 <Deewiant> And then the 05-} drops 5 cells from the SOSS
20:54:09 <elliott> then transferBlock (fromIntegral n)
20:54:09 <elliott> else replicateM_ (fromIntegral (abs n)) $ push 0
20:54:19 <Vorpal> elliott, that's for { not for }
20:54:29 <Vorpal> elliott, they do different things for negative arguments...
20:54:49 <Deewiant> } doesn't push stuff with negative args
20:55:09 -!- oerjan has quit (Quit: Good night).
20:55:16 <elliott> Great, now I need to make y not reflect.
20:55:32 <elliott> Ehh, y doesn't sound that hard.
20:55:41 <Vorpal> elliott, y takes a lot of time to implement. Not because it is hard. But because it is a chore.
20:55:56 <Vorpal> elliott, though the y-as-pick can be tricky to get right
20:56:17 <elliott> Least Significant Bit 0 (0x01): high if t is implemented. (is this Concurrent Funge-98?)
20:56:17 <elliott> Bit 1 (0x02): high if i is implemented.
20:56:18 <elliott> Bit 2 (0x04): high if o is implemented.
20:56:20 <elliott> Bit 3 (0x08): high if = is implemented.
20:56:28 <elliott> Deewiant: Will Mycology only test t if I say it supports it?
20:56:38 <elliott> I plan to implement all of those, so I'd prefer to just construct one flag :P
20:57:04 <Deewiant> Something wrong with just pushing 0b1111 now?
20:57:18 <elliott> Deewiant: Because it'll probably die after shit fails? :P
20:57:36 <Vorpal> elliott, so push 0 for now and then change when it implements stuff
20:57:57 <Deewiant> That I always treat it as though you pushed 0b1111? :-P
20:58:11 <Vorpal> elliott, that would make no sense
20:58:20 <Deewiant> Why is that better than you just pushing it
20:58:37 <lambdabot> forall a. (Floating a) => a -> a -> a
20:58:45 <elliott> > logBase 2 (maxBound :: Int32)
20:58:46 <lambdabot> No instance for (GHC.Float.Floating GHC.Int.Int32)
20:59:20 <Vorpal> elliott, I'm not very surprised at that error
20:59:25 <impomatic> !bfjoust chainmail http://candlebags.co.uk/temp/3.txt
20:59:30 <elliott> > logBase 2 (fromIntegral $ maxBound :: Int32)
20:59:31 <lambdabot> No instance for (GHC.Float.Floating GHC.Int.Int32)
20:59:35 <Vorpal> static void push_yval(funge_cell request, instructionPointer * restrict ip, funge_stack * restrict pushStack)
20:59:42 <lambdabot> Prelude fromIntegral :: (Integral a, Num b) => a -> b
20:59:42 <lambdabot> Prelude realToFrac :: (Real a, Fractional b) => a -> b
20:59:42 <lambdabot> Unsafe.Coerce unsafeCoerce :: a -> b
20:59:44 <elliott> Vorpal: Nice indentation style.
20:59:46 <EgoBot> Score for impomatic_chainmail: 43.9
20:59:54 <elliott> > logBase 2 (fromIntegral $ (maxBound :: Int32))
20:59:56 <Deewiant> elliott: :: binds looser than $
21:00:13 <elliott> > ceil (logBase 2 (fromIntegral $ (maxBound :: Int32)) + 1)
21:00:17 <elliott> > ceiling (logBase 2 (fromIntegral $ (maxBound :: Int32)) + 1)
21:00:26 <elliott> <jix> elliott: Data.Bits.bitSize
21:00:35 <elliott> jix: COULDA HELPED ME BEFORE I RESORTED TO #HASKELL :P
21:01:02 <jix> I'm not following here ;)
21:01:10 <Vorpal> well that's fixed then
21:02:07 <Vorpal> elliott, you remember that y will have to act as pick into stack if you request a value past the range of y?
21:02:29 <Vorpal> elliott, also that the parameter is *cell*-based. Not "request"-based
21:02:34 -!- cheater- has quit (Ping timeout: 240 seconds).
21:03:19 <fizzie> And some requests are variable-size.
21:03:31 -!- cheater- has joined.
21:03:47 <Vorpal> Deewiant, I remember I managed to speed up mycology a lot by optimising the stuff HRTI used as a wait loop. I think you changed that since though.
21:04:12 <Deewiant> I don't think I changed it, maybe I did
21:04:28 <Vorpal> Deewiant, hm. The thing is to do the two values it end up sending to y there fast
21:04:40 <elliott> dons just thought i was a galois guy
21:05:29 <impomatic> !bfjoust test >(-{}>)*7(>+++[[-]])*21
21:06:32 <elliott> 1 vector containing the least point which contains a non-space cell, relative to the origin (env)
21:06:36 <elliott> that isn't the corner of the rectangle
21:06:42 <elliott> not even the minimal rectangle
21:06:54 <elliott> it has to contain a non-space cell
21:07:26 <Vorpal> elliott, that is the inner border of the infinitely thin rectangle between space and non-space
21:07:45 <EgoBot> Score for impomatic_test: 5.6
21:08:02 <Vorpal> elliott, of course not
21:08:08 <elliott> well nobody told me you had to keep track of that
21:08:13 <elliott> Vorpal: 1 vector containing the least point which contains a non-space cell, relative to the origin (env)
21:08:18 <elliott> containing the least point which CONTAINS A NON-SPACE CELL
21:08:24 <Vorpal> Deewiant, are we in trouble here?
21:08:26 <impomatic> 2 minutes for bfjoust results :-( It seemed like I was waiting forever. ;-)
21:08:45 <Vorpal> elliott, looks like it. But just do what everyone else does
21:08:51 <elliott> <elliott> Vorpal: 1 vector containing the least point which contains a non-space cell, relative to the origin (env)
21:08:52 <elliott> <elliott> containing the least point which CONTAINS A NON-SPACE CELL
21:08:55 <elliott> Deewiant: it's not the rectangle bounds
21:08:59 <fizzie> I think most people would just apply a smidgeon of sanity there.
21:08:59 <elliott> Deewiant: it's even more crazy
21:09:15 <elliott> fizzie: That's *not* *what* *it* *says*. The fact that 0k does two less than 1k is also insane :P
21:09:19 <Vorpal> elliott, it contradicts itself too
21:09:26 <Vorpal> elliott, because it says it is suitable for use with o
21:09:32 <elliott> 1 vector containing the least point which contains a non-space cell, relative to the origin (env)
21:09:32 <elliott> 1 vector containing the greatest point which contains a non-space cell, relative to the least point (env)
21:09:32 <elliott> These two vectors are useful to give to the o instruction to output the entire program source as a text file.
21:09:36 <Vorpal> elliott, and it no longer is with your way of reading it
21:09:42 <Deewiant> elliott: These two vectors are useful to give to the o instruction to output the entire program source as a text file.
21:09:48 <elliott> Deewiant: So? That's just a remark.
21:09:53 <Deewiant> For that to work, they can't be as described
21:09:57 <elliott> What it says isn't subjective.
21:10:03 <elliott> You are wilfully breaking the direct, clear specification.
21:10:06 <Deewiant> There is no single "least point containing a non-space cell"
21:10:14 <elliott> The point closest to the border.
21:10:18 <elliott> I guess you could have two equidistant :P
21:10:30 <elliott> Deewiant: I don't like how we ignore the spec when it makes no sense :P
21:10:34 <Vorpal> Deewiant, actually you mean
21:10:39 <Vorpal> rather than the other one
21:10:47 <fizzie> Doesn't everyone already ignore the direct, clear specification when it comes to t?-)
21:10:54 <elliott> 1 cell containing current ((year - 1900) * 256 * 256) + (month * 256) + (day of month) (env)
21:11:01 <Deewiant> elliott: According to the spec, t is a forkbomb
21:11:23 <EgoBot> Score for impomatic_scimitar: 8.9
21:11:38 <elliott> Deewiant: Is time local or UTC?
21:11:51 <Deewiant> Undef, I think I give UTC because there's no way of giving tz info
21:12:02 <Vorpal> at least that I use UTC
21:17:24 <ais523> <Deewiant> elliott: According to the spec, t is a forkbomb <--- does it not advance the IP in one of the threads?
21:18:06 <ais523> hmm, fingerprint suggestion: a feral fingerprint that changes the semantics of commands like k and t to something sane, and otherwise leaves everything much the same
21:18:11 <Deewiant> The child's delta is reversed but the position is unchanged
21:18:39 <Vorpal> Deewiant, you could have a thread overwrite the t?
21:18:54 <Deewiant> No, because the child is executed first
21:19:07 <Vorpal> Deewiant, yes so you get two threads
21:19:22 <ais523> Vorpal: no, the child is executed first, and executes t
21:19:42 <ais523> hmm, then what executes next? the grandchild, or original parent?
21:19:46 <Vorpal> I thought it was executed before parent is executed again but after other threads are executed
21:19:48 <ais523> if it's original parent, there's hope for t yet
21:20:09 <lambdabot> 115792089237316195423570985008687907853269984665640564039457584007913129639...
21:20:23 <ais523> also, 1cnis does bignum now
21:20:37 <elliott> [[size-of-stack-stack cells containing size of each stack, listed from TOSS to BOSS (ip)]]
21:20:39 <ais523> "use bignum;" isn't enough, I have to work out exactly where to use bignits
21:20:41 <ais523> Vorpal: geta better font
21:21:02 <Vorpal> ais523, my question remains even when spelling is corrected: 1cnis?
21:21:08 <ais523> http://esolangs.org/wiki/1cnis
21:21:22 <elliott> [[a series of sequences of characters (strings), each terminated by a null, the series terminated by an additional double null, containing the command-line arguments. (env)
21:21:22 <elliott> This means any isolated argument can be a null string, but no two consecutive arguments may be null strings - a rather contrived scenario, null string arguments being rare in themselves.
21:21:22 <elliott> The first string is the name of the Funge source program being run.]]
21:21:28 <Vorpal> elliott, why does that thing fail
21:21:50 <ais523> elliott: I have interps which accept two consecutive null strings as args, usefully
21:21:55 <Vorpal> elliott, and then there is the cmd line args ant the environment variables
21:21:56 <elliott> So what do you do if you get two consecutive null args
21:22:06 <ais523> not Befunge interps, though
21:22:19 <Vorpal> elliott, generally the befunge program becomes confused
21:22:22 <impomatic> !bfjoust voodoo >(-{}>)*8([(>[-])*21]>)*21
21:22:26 <EgoBot> Score for impomatic_voodoo: 20.6
21:22:50 <Vorpal> elliott, what about environment variables!?
21:24:38 <Vorpal> elliott, you need do provide it at some point
21:25:02 <Vorpal> elliott, don't you have a push-gnirts function yet?
21:25:23 <ais523> heh, I looked back at the scoreboard trying to figure out if tripstridewire had fallen off yet, and concluded that it had because I couldn't see it near the bottom
21:25:26 <Vorpal> elliott, it is even more useful for fingerprints
21:25:29 <elliott> But more importantly, I'd like to preprocess the arguments.
21:25:33 <impomatic> !bfjoust voodoo >(-{>}+)*8(>)*7([(>[-])*21]>)*21
21:25:37 <ais523> it seems it's somehow ended up doing much better while I went home
21:25:38 <EgoBot> Score for impomatic_voodoo: 1.5
21:25:42 <elliott> Vorpal: As I said, I refuse to make anything cleaner until it passes Mycology.
21:25:43 <Vorpal> elliott, well yes taking flags for program or such?
21:25:49 <elliott> Vorpal: And rejecting '' ''.
21:26:05 <ais523> that draw with mirage is still amazing, though
21:26:10 <elliott> toGregorian :: Day -> (Integer, Int, Int)Source
21:26:10 <elliott> convert to proleptic Gregorian calendar. First element of result is year, second month number (1-12), third day (1-31).
21:26:12 <ais523> given that it's not symmetrical at all
21:26:17 <Vorpal> elliott, generally we have this situation: ./interpreter -flags program.b98 argument1 argument2. The program should not get the flags
21:26:18 <elliott> You know, for the Y2^64 problem.
21:26:29 <Vorpal> it should get: program.b98 argument1 argument2
21:26:30 <Phantom_Hoover> The Church of Scientology is under investigation for slave labour.
21:26:54 <Vorpal> Phantom_Hoover, link...
21:27:22 <elliott> type Pico = Fixed E12Source
21:27:22 <elliott> resolution of 10^-12 = .000000000001
21:27:28 <impomatic> !bfjoust voodoo >(-)*8>(+)*8(>)*7([(>[-])*21]>)*21
21:27:30 <Phantom_Hoover> http://gawker.com/#!5753356/the-fbi-is-investigating-scientology-for-human-trafficking
21:27:34 <EgoBot> Score for impomatic_voodoo: 8.2
21:27:41 <Vorpal> Phantom_Hoover, even more extreme
21:27:45 <ais523> !bfjoust idea_stolen_from_quintopia ([](+)*99)*100000
21:27:53 <EgoBot> Score for ais523_idea_stolen_from_quintopia: 17.6
21:28:01 <elliott> TODO: Make alias for (push . fromIntegral).
21:28:03 -!- zzo38 has quit (Remote host closed the connection).
21:28:06 <elliott> Phantom_Hoover: When Gawker is more reliable than your original source...
21:28:12 <elliott> Also, jesus, that redesign.
21:28:27 <Vorpal> elliott, the new page seems to need javascript!
21:28:30 <ais523> impomatic: what happened to scimitar? did you rename it?
21:28:32 <impomatic> !bfjoust voodoo >(-{}>)*8([(>[-])*21]>)*21
21:28:36 <EgoBot> Score for impomatic_voodoo: 20.4
21:28:36 <elliott> Vorpal: Read Engadget, folks!
21:28:43 <Vorpal> elliott, sometimes I do that
21:28:50 <elliott> That the system's path separator is <CTCP>
21:28:58 <elliott> That the number of bytes per cell is 0
21:29:02 <ais523> that's a great path separator
21:29:05 <elliott> That the interpreter's handprint is 0
21:29:05 <elliott> That the interpreter's version is 98
21:29:11 <elliott> That the behaviour of = is unavailable
21:29:16 <elliott> That this Funge has 1388334 dimensions
21:29:18 <elliott> That this Funge has 1388334 dimensions
21:29:20 <elliott> That this Funge has 1388334 dimensions
21:29:23 -!- pikhq_ has quit (Read error: Operation timed out).
21:29:24 <Vorpal> elliott, you are off by something
21:29:31 <elliott> That the ID of the current IP is shiro: <<loop>>
21:29:43 <ais523> that dimension report makes no sense for being in the spec
21:29:45 <Vorpal> elliott, "shiro"? It said that?
21:29:52 <ais523> Vorpal: it looks to be a Haskell error
21:29:55 <quintopia> ais523: well it beat tripstridewire at least
21:29:55 <ais523> infinite loop detected
21:30:00 <elliott> Vorpal: "foo: <<loop>>" is when you make a really stupid infinite loop.
21:30:12 <impomatic> ais523: I tried replacing ((-)*128(>{(+.)*56}<)%8)*5 with ((-)*128(>{(+...)*28}<)%8)*10 etc all the way through thinking it might score better, but it scored exactly the same. I left the new version on (chainmail)
21:30:15 <Vorpal> elliott, haven't run into that yet
21:30:33 <ais523> impomatic: it would be very surprising if there were a difference
21:30:40 <elliott> After an execution of y with a non-positive argument, the stack contains many more cells (listed from top to bottom:)
21:30:41 <ais523> given the way the program works
21:30:45 <elliott> Turns out my whole thing is back-to-front.
21:30:55 <elliott> Say it with me now: FFFFFFFUUUUUUUUUUU
21:31:05 -!- pikhq has joined.
21:31:33 <ais523> elliott: that seems easily fixable
21:32:10 <impomatic> ais523: now I'm trying to write a program they score differently against!
21:32:45 <ais523> impomatic: it'd have to, umm, give up if it tried for too long to sink the flag
21:32:47 <Vorpal> <ais523> that dimension report makes no sense for being in the spec <-- why not
21:32:58 <ais523> Vorpal: because you can't interpret the result of y without knowing the dimension anyway
21:32:59 <Vorpal> or do you mean that specific value
21:33:08 <elliott> That the stack sizes are [ 1 0 98 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
21:33:21 <ais523> unless, I suppose, it's above all the vectors
21:33:25 <Vorpal> elliott, you fail at counting stack stacks
21:34:18 <Vorpal> why did I call comment that with "// Scalars / vector"
21:34:25 <Vorpal> while accurate that is a damn strange way to describe it
21:35:46 <Vorpal> elliott, does it work better now?
21:35:46 -!- augur has quit (Remote host closed the connection).
21:37:08 <impomatic> !bfjoust oneshot >(-{}>)*7(>[[>](>)*8([-])*21])*21
21:37:10 <EgoBot> Score for impomatic_oneshot: 0.0
21:37:29 <ais523> that doesn't look like valid syntax
21:37:36 <impomatic> !bfjoust oneshot >(-{-}>)*7(>[[>](>)*8([-])*21])*21
21:37:41 <EgoBot> Score for impomatic_oneshot: 0.0
21:37:46 <ais523> also, [>] is incredibly dubious in BF Joust, it generally either does nothing or suicides
21:38:09 <Vorpal> Going to test concurrent execution with 2 IPs.
21:38:14 <Vorpal> Deewiant, you never test with 3?
21:38:36 <Deewiant> I do use more than 2 at some points, I think
21:38:36 <Vorpal> Deewiant, hard to make sure you have the right order then
21:38:36 <Phantom_Hoover> Particularly: the complex numbers aren't a superset of the hyperreals, and it seems to be saying thatt there are non-transcendental, non-algebraic reals.
21:38:39 <fizzie> Deewiant: You should test with 0, 1 and infinity.
21:38:51 <Deewiant> Vorpal: But only in fingerprints
21:38:52 <elliott> It's the fourth and final number.
21:38:53 <impomatic> !bfjoust oneshot >(-{-}>)*7(>[[>](>)*7([-])*21])*21
21:38:56 <Vorpal> fizzie, what about jitfunge? Any progress?
21:38:58 <EgoBot> Score for impomatic_oneshot: 0.0
21:39:00 <Vorpal> Deewiant, which one(s)?
21:39:07 <ais523> impomatic: you mean (-{-}>)%7, surely?
21:39:07 <elliott> Phantom_Hoover: COUNTING NUMBERS
21:39:14 <Deewiant> Vorpal: The ones that do stuff with IPs. :-P
21:39:18 <elliott> I like how integers aren't whole somehow.
21:39:20 <fizzie> Vorpal: I'm pretty sure I'll blerb about it on-channel if I manage to make any process. Unfortunately, no.
21:39:35 <impomatic> !bfjoust oneshot >(-{-}>)%7(>[[>](>)*7([-])*21])*21
21:39:36 <Phantom_Hoover> elliott, well, the subsets of Z are a point of much contention.
21:39:38 <EgoBot> Score for impomatic_oneshot: 0.0
21:39:58 <ais523> even so, that program looks doomed to suicide off the right end of the tape
21:40:00 <elliott> That the interpreter's handprint is 1397248591
21:40:01 <impomatic> !bfjoust oneshot >(-)*8(>)*7(>[[>](>)*7([-])*21])*21
21:40:01 <Vorpal> fizzie, I don't know llvm asm, and I hate x86 asm. Otherwise I might give it a stab
21:40:04 <EgoBot> Score for impomatic_oneshot: 0.0
21:40:10 <Vorpal> fizzie, something like AVR would be cool as a target
21:40:10 <elliott> Deewiant: is that decimal?
21:40:12 <ais523> what it does is, when it finds a flag or decoy, keeps moving right until it finds an empty cell
21:40:13 -!- augur has joined.
21:40:21 <ais523> which is likely to be off the end of the tape, as programs rarely leave gaps in their decoys
21:40:25 <Deewiant> elliott: Yes, . only outputs decimal.
21:40:31 <impomatic> !bfjoust oneshot >(-)*8(>)*7(>[[>](>)*2(>[-])*21])*21
21:40:34 <EgoBot> Score for impomatic_oneshot: 1.8
21:40:35 <elliott> That the greatest point, relative to that point, is ( 180 909 )
21:40:35 <elliott> BAD: should have been ( 183 911 )
21:40:50 <elliott> That is the fucking stupidest...
21:40:51 <impomatic> ais523: I was looking for a gap... perhaps not a very good strategy :-(
21:41:03 <ais523> I can imagine programs it would beat, but IIRC there aren't any on the hill
21:41:15 <ais523> I can't think of any programs that leave gaps in decoys
21:41:37 <Vorpal> ais523, everything beats that program
21:42:18 <elliott> That the least point containing a non-space cell is ( -3 -2 )
21:42:18 <elliott> That the greatest point, relative to that point, is ( 0 0 )
21:42:18 <elliott> BAD: should have been ( 183 911 )
21:42:18 <Vorpal> <ais523> I can't think of any programs that leave gaps in decoys <-- one of my test ones did
21:42:21 <impomatic> I was looking for a program with no decoy that leaves a trail, e.g. (>)*9 ([-]+>)*21
21:42:29 <Vorpal> elliott, yep you fail :P
21:43:01 <EgoBot> Score for impomatic_target: 9.1
21:43:06 <elliott> let (minX,minY) = minCoords (fungeSpace st)
21:43:06 <elliott> let (maxX,maxY) = minCoords (fungeSpace st)
21:43:06 <elliott> pushVec (maxX-minX,maxY-minY)
21:43:21 <Vorpal> elliott, the second line
21:43:24 <Deewiant> elliott: You already know where the bug is, why do you do this
21:43:31 <Deewiant> We realize you make stupid mistakes :-P
21:43:33 <elliott> Deewiant: to mock myself :D
21:43:34 <Vorpal> elliott, minCoords should be maxCoords
21:43:42 <Deewiant> It was obvious from the output anyway
21:43:43 <elliott> ais523: an IDE which shows things that are both close and have low edit distance as REALLY NOTICEABLE
21:43:43 <impomatic> !bfjoust oneshot >(-)*8(>)*7(>[[>](>)*7(>[-])*21])*21
21:43:45 <EgoBot> Score for impomatic_oneshot: 0.0
21:43:49 <elliott> that way, close mistakes would stick out :D
21:43:58 <Deewiant> Although I expected maxX-maxX,maxY-maxY
21:44:14 <ais523> elliott: I had that idea already
21:44:19 <elliott> That the command-line arguments were: [ "b" null ]
21:44:21 <ais523> in fact, it would be 3D syntax coloring
21:44:27 <elliott> Why is there a null string there?
21:44:31 <ais523> giving redness, blueness, greenness according to similarity on other parts of code
21:44:32 <elliott> Or is that how it always displays?
21:45:03 <impomatic> !bfjoust oneshot >(-)*8(>)*7(>[[>](>)*1(>[-])*21])*21
21:45:07 <Deewiant> Did you push a zero after that?
21:45:08 <EgoBot> Score for impomatic_oneshot: 0.0
21:45:24 <Vorpal> elliott, 0 terminates string, 00 terminates list
21:45:27 <elliott> Deewiant: Yes, as the complete lack of command-line arguments.
21:45:32 <Vorpal> elliott, to terminate string and list you need 000
21:45:38 <elliott> Deewiant: Yes, as the complete lack of environment variables.
21:45:50 <ais523> !bfjoust idea_stolen_from_quintopia ([](+)*256)*100000
21:45:52 <Deewiant> Right, and it can't know where what ends.
21:46:04 <EgoBot> Score for ais523_idea_stolen_from_quintopia: 11.5
21:46:07 <Deewiant> So it treats that as a null argument at the end.
21:46:09 <elliott> Deewiant: You can, with magic.
21:46:46 <impomatic> !bfjoust oneshot >(-)*8(>)*7(>[[>](>)*8[-](.)*1000000])*21
21:46:49 <EgoBot> Score for impomatic_oneshot: 0.0
21:47:16 <ais523> impomatic: let me test that against some programs on my local "why a program loses" interp
21:47:30 <Vorpal> Deewiant, how comes you added a test for "GOOD: : on empty stack makes stack size 2 according to y"
21:47:40 <Vorpal> Deewiant, it ruins the nice bit about peek and push ;P
21:47:43 <Deewiant> Vorpal: Because you implemented it as push(top)
21:47:58 <Vorpal> Deewiant, oh you added it after me?
21:48:28 <elliott> <Vorpal> Deewiant, how comes you added a test for "GOOD: : on empty stack makes stack size 2 according to y"
21:48:30 <Vorpal> Deewiant, actually I never did \ that way
21:48:30 <elliott> is that /meant/ to happen?
21:48:42 <elliott> i'll have to fix that then :P
21:49:01 <Vorpal> elliott, it is defined as pop,push,push
21:49:24 <elliott> Vorpal: Hey, still... this is only my second day and it's already passing a large part of the stock-standard-Befunge Mycology, and quickly no less.
21:49:28 <elliott> Admittedly I had Deewiant on hand.
21:49:43 <Vorpal> elliott, well sure this far is easy to get
21:49:49 <Vorpal> elliott, t will require another day
21:49:59 <Vorpal> elliott, and also you aren't doing it in C. That helps.
21:50:20 <Vorpal> elliott, you don't have to spend time debugging memory leaks in stack and so on
21:50:22 <elliott> Vorpal: Have I mentioned that apart from file load, which isn't very optimised, Mycology up to this point displays instantly? :P
21:50:43 <Vorpal> elliott, well it does for cfunge too including file load
21:50:45 <impomatic> !bfjoust oneshot (>)*7(>[[>](>)*8[-]+[]])*22
21:50:51 <elliott> Vorpal: Yes, but cfunge is optimised to shit :P
21:50:53 <Vorpal> elliott, I hope you will mmap the file, since you love mmap
21:50:59 <elliott> Fingerprints will be fun if you ask me... of course I'm using a fancy modern language so I don't dread managing state. :)
21:51:21 <Vorpal> elliott, in other words you will copy cfunge :P
21:51:34 <elliott> Vorpal: I'm not gonna use asm.
21:51:55 <Vorpal> elliott, it doesn't for that
21:52:44 <ais523> impomatic: it seems your program is failing to sink the flag, even when it identifies it correctly
21:52:56 <Vorpal> elliott, do you reflect in { if you run out of memory btw?
21:53:11 <ais523> it's just really finicky
21:53:17 <impomatic> ais523: hmmm... I mist have messed something up then
21:53:23 <EgoBot> Score for impomatic_oneshot: 3.6
21:53:26 <ais523> the thing is, skip then trail is a reasonably bad strategy as-is
21:53:36 <ais523> /and/, the natural implementation of skip-then-trail leaves a gap of 7 not 8
21:53:49 <ais523> because otherwise it doesn't go into the loop properly
21:54:05 <ais523> the other issue is, there's a chance you end up overtaking the trail
21:54:11 <impomatic> !bfjoust oneshot (>)*7(>[[>](>)*7[-]+[]])*22
21:54:16 <EgoBot> Score for impomatic_oneshot: 3.6
21:54:17 <ais523> which always happens on short tapes, and a reasonable proportion of the time even on longer tapes
21:54:41 <Vorpal> elliott, cfunge reflects on OOM in {
21:54:48 <quintopia> !bfjoust when_will_it_explode [](+)*111(>)*9(-)*64(<)*9[](+)*128(>)*9[-](<)*9[](+)*111(>)*10(-)*64(<)*10[](+)*128(>)*10[-](<)*10[](+)*111(>)*11(-)*64(<)*11[](+)*128(>)*11[-](<)*11[](+)*111(>)*12(-)*64(<)*12[](+)*128(>)*12[-](<)*12[](+)*111(>)*13(-)*64(<)*13[](+)*128(>)*13[-](<)*13[](+)*111(>)*14(-)*64(<)*14[](+)*128(>)*14[-](<)*14[](+)*111
21:54:55 <elliott> Vorpal: No; Haskell's semantic model is based on a machine with infinite memory.
21:55:00 <EgoBot> Score for quintopia_when_will_it_explode: 11.5
21:55:03 <elliott> It's not my fault if your implementation incorrectly uses a finite amount.
21:55:06 <ais523> quintopia: interesting twist on defence
21:55:09 <Vorpal> elliott, but in practise that won't be the case
21:55:19 <elliott> Vorpal: Is it my fault that the universe implements Haskell incorrectly?
21:55:24 <quintopia> ais523: i should try the full version eh?
21:55:38 <impomatic> ais523: I think I'll give up on oneshot :-)
21:55:43 <ais523> quintopia: atm, it's only beating tripwire-dodgers and oneshot
21:55:53 <ais523> but I like the strategy, I'm just not sure why it isn't working
21:56:07 <Vorpal> ais523, you are fast at reading bfjoust!
21:56:10 <quintopia> ais523: it can't kill anyone on tapes longer than 14 atm :P
21:56:20 <elliott> UNDEF: can't test o without working i, may overwrite some existing file
21:56:25 <elliott> Deewiant: You could just ask the user for a filename. :p
21:56:55 <elliott> Deewiant: Easier than checking if a file is empty or not :-D
21:57:00 <ais523> quintopia: I know what's wrong
21:57:04 <Vorpal> Deewiant, wasn't it efunge that found you didn't handle o without i?
21:57:11 <ais523> it's because ] checks the value with the wrong timing
21:57:39 <Vorpal> elliott, mycology.b98 contains no user input
21:57:46 <Vorpal> elliott, you want mycouser.b98 for that
21:57:46 <ais523> so []+++ doesn't add in time, as although the ] could catch the zeroising in time, it reads the value before the decrement
21:57:58 <ais523> i.e. on the cycle it decreases from 1 to 0, it reads 1
21:57:59 <elliott> It could just ask for input if i isn't implemented, but whatever.
21:58:09 <elliott> BAD: ( reflects without popping correctly
21:58:10 <ais523> the cycle after, it stays at 0, it reads 0 but it's too late
21:58:16 <ais523> pity, the whole strategy seems not to work as a result
21:58:19 <Vorpal> elliott, that is fingerprint loading
21:58:21 <ais523> perhaps we should change that bit of the spec?
21:58:35 <Vorpal> elliott, this comes after: GOOD: null byte in string and zero compare as equal
21:58:47 <elliott> GOOD: \ on empty stack makes stack size 2 according to y
21:58:47 <elliott> BAD: ( reflects without popping correctly
21:58:47 <Vorpal> elliott, also handling of k with negative argument
21:59:02 <Vorpal> elliott, just pop n, then pop n bytes. Then refect
21:59:02 <quintopia> ais523: yes it does seem like ] should check the value at the end of the cycle and not the beginning
21:59:04 <elliott> UNDEF: can't test o without working i, may overwrite some existing file
21:59:04 <elliott> 1y says this is not Concurrent Funge-98, won't test t...
21:59:04 <elliott> GOOD: y acts as pick instruction if given large enough argument
21:59:04 <elliott> GOOD: ] turns flying IP right
21:59:04 <elliott> GOOD: : on empty stack makes stack size 2 according to y
21:59:04 <elliott> GOOD: \ on empty stack makes stack size 2 according to y
21:59:06 <elliott> BAD: ( reflects without popping correctly
21:59:14 <Vorpal> elliott, yes I meant after ( test
22:00:32 <elliott> The Mycology Befunge-98 test suite is practically done.
22:00:32 <elliott> Trying to quit with q. If the return status is 15, consider it GOOD...
22:00:32 <elliott> elliott@elliott-MacBookAir:~/Code/shiro$ echo $?
22:00:52 <elliott> UNDEF: k with a negative argument executes more often than the absolute value of the argument
22:01:04 <elliott> My k does the only logical thing
22:01:14 <elliott> If n <= 0, then it advances to the next instruction |n| + 1 times.
22:01:20 <elliott> That handles 0k without any ugly SPECIAL CASES.
22:01:33 <elliott> Vorpal: Best semantics or best semantics?
22:01:51 <elliott> UNDEF: the empty string wrapped around the edge of space contains 1 character(s) (hopefully spaces)
22:01:53 <ais523> elliott: I'm pretty sure Deewiant was just trying to cover all possibilities when working out that
22:01:55 <Vorpal> UNDEF: k with a negative argument reflects
22:01:57 <Vorpal> elliott, that is what I have
22:01:59 -!- impomatic has quit (Quit: ChatZilla 0.9.86 [Firefox 3.5.16/20101130074636]).
22:02:08 <elliott> Yours has special cases and stuff.
22:02:10 <elliott> <elliott> UNDEF: the empty string wrapped around the edge of space contains 1 character(s) (hopefully spaces)
22:02:14 <elliott> Shouldn't that be 0, "platonically"?
22:02:18 <Vorpal> UNDEF: the empty string wrapped around the edge of space contains 1 character(s) (hopefully spaces)
22:02:20 <ais523> elliott: so does yours, you just extended a special case from 0 to an entire halfspace
22:02:33 <Vorpal> UNDEF: ( with a negative count reflects and pops 0 times or less than the absolute value of the count
22:02:33 <Vorpal> UNDEF: ) with a negative count reflects and pops 0 times or less than the absolute value of the count
22:02:36 <elliott> ais523: That's more like a single branch.
22:02:42 <elliott> ais523: Which is better than an explicit special case.
22:02:49 <elliott> UNDEF: ( with a negative count reflects and pops 0 times or less than the absolute value of the count
22:02:49 <elliott> UNDEF: ) with a negative count reflects and pops 0 times or less than the absolute value of the count
22:02:57 <elliott> I should make it parse some AMICEDs.
22:03:13 <elliott> I'll make negative ( and ) reflect.
22:03:18 <elliott> Seems the sane thing to do.
22:03:23 <Vorpal> elliott, just to be different than me?
22:03:36 <elliott> By virtue of always reflecting.
22:03:46 <ais523> elliott: do you pop first?
22:03:54 <elliott> BAD: after spacing top-left corner, y should report least point as ( -2 -1 ), not ( -10 -2 )
22:03:54 <elliott> BAD: after spacing top-left corner, y should report greatest point as ( 182 910 ), not ( 190 911 )
22:03:54 <elliott> BAD: after spacing right edge, least point reported by y should remain ( -2 -1 )
22:03:54 <elliott> BAD: after spacing right edge, y should report greatest point as ( 181 910 ), not ( 190 911 )
22:03:54 <elliott> BAD: after spacing bottom edge, y should report greatest point as ( 181 909 ), not ( 190 911 )
22:03:56 <ais523> also, is the program vaguely optimised yet?
22:04:09 <Vorpal> elliott, that is to do with shrinking bounds
22:04:09 <ais523> elliott: aha, the evil bounds recalculation
22:04:18 <elliott> ais523: It runs Mycology with no fingerprints or concurrent testing pretty much instantly after it loads, so it's fast enough for now.
22:04:23 <Vorpal> Testing fingerprint HRTI... loaded.
22:04:23 <Vorpal> UNDEF: G gives clock granularity as 1 microseconds
22:04:23 <Vorpal> GOOD: T reflected when called before M
22:04:23 <Vorpal> UNDEF: S pushed 461923
22:04:23 <Vorpal> UNDEF: T after M pushed 9 and a second T, after 675 ys, pushed 13819
22:04:28 <Vorpal> elliott, waiting for you to say that!
22:04:33 <ais523> that's a huge improvement
22:04:36 <elliott> Vorpal: How hard can it be.
22:04:46 <elliott> ais523: Yes, I did the revolutionary thing of "cache the bounds rather than recalculate them constantly".
22:04:49 <Vorpal> elliott, well fingerprints semantics takes a bit of work
22:05:08 <ais523> elliott: and your reward was a bunch of BAD:
22:05:10 <Vorpal> elliott, I suggest this fingerprint implementation order: NULL, ROMA, MODU
22:05:10 <elliott> Vorpal: Yeah, but I've already worked out how to do it from the Haskell-side where every fingerprint can store its own state in both the global interpreter state and per-IP state.
22:05:21 <Vorpal> elliott, they are simple and they help you work out the fingerprint system
22:05:27 <elliott> ais523: and having to rewrite my wrapping code
22:05:27 <Phantom_Hoover> DID YOU KNOW: you need different work visas to teach in Edinburgh and Fife.
22:05:29 <Vorpal> elliott, see two last tests
22:05:34 <Vorpal> for why you want ROMA and MODU early on
22:05:44 <ais523> elliott: you could recalculate bounds whenever y ran, I suppose
22:05:44 <Vorpal> Deewiant, ... that's unhelpful
22:05:54 <Phantom_Hoover> Because we don't want that Fife scum coming over and stealing our jobs, evidently.
22:06:03 <ais523> elliott: not massively, but it's a lot of work
22:06:07 <Vorpal> elliott, no but TOYS cover every letter!
22:06:08 <elliott> Googling "TOYS befunge": "Befunge - Minecraft Forums"
22:06:11 <elliott> Blood pressure about to rise.
22:06:18 <elliott> "CHECK OUT #BEFUNGE ON IRC.ESPER.NET" HOW ABOUT NO
22:06:19 <ais523> now that seems like an interesting thread
22:06:32 <ais523> are people actually trying to do Minecraft funges/
22:06:45 <elliott> ais523: it's just in the off-topic forum or whatever
22:06:56 <elliott> ais523: which, for a forum with as stupid a population as the minecraft forum's, is a bad idea
22:07:12 <elliott> Does anyone have a copy of the TOYS specification that isn't HTML sent as XHTML?
22:07:15 <elliott> So that I can read the damn thing.
22:07:32 <elliott> Deewiant: You need to top this (wow, 2002): http://www.mail-archive.com/inline@perl.org/msg01110.html
22:08:16 <Vorpal> elliott, http://catseye.tc/projects/funge98/library/MODU.html http://catseye.tc/projects/funge98/library/ROMA.html and http://catseye.tc/projects/funge98/library/NULL.html
22:08:22 <Vorpal> elliott, they are good to start with
22:08:23 <elliott> "Under development." Comforting.
22:08:28 <elliott> Vorpal: I want to get all GOODs first.
22:08:39 <elliott> Vorpal: Which means bounds shrinking.
22:08:40 <Vorpal> elliott, Don't start with TOYS. It is not well defined
22:08:50 <elliott> What the fuck is a low-order and high-order copy of Funge-space.
22:08:59 <Vorpal> elliott, the butterfly operator mentioned in TOYS is cargo cult!
22:09:27 <elliott> Deewiant: Seriously though, what :-D
22:09:31 <elliott> That's worse than MKRY specifications.
22:10:02 <Vorpal> elliott, I invite you to GPL your program by not reinventing the wheel!
22:10:17 <elliott> I could just steal it from CCBI
22:10:28 <elliott> And it'd have less inline assembly, too :P
22:11:42 <Vorpal> elliott, not THAT file
22:11:53 <Vorpal> elliott, it is just part of the funge space setup code
22:12:44 <Vorpal> elliott, the television antenna instruction in TOYS is quite useful
22:12:47 <elliott> Does anyone want to see the most bloated Haskell file ever?
22:13:01 <elliott> Full of IRC quotes of Deewiant mocking Vorpal! Okay, one, and it's barely mocking.
22:13:40 <elliott> Also, lots of outdated comments.
22:13:45 <elliott> For instance, k is now fully fixed :P
22:14:26 <Vorpal> -- <elliott> Deewiant: Fuck. I forgot that one space != two spaces in string mode.
22:14:53 <elliott> that's why alltheoutputfromMycologylookedlikethistostartwith
22:15:22 <elliott> Vorpal: and it was so slow because of the bounds, plus the fact that i flushed every character
22:15:25 <elliott> Vorpal: so you saw it typing out
22:15:29 <elliott> GOOD::duplicatestopofstack
22:15:50 <elliott> Vorpal: in fact, I could tell the difference between the , works test and the : duplicates test
22:15:53 <Vorpal> elliott, what you don't have a switch for fully buffered output?
22:16:01 <elliott> Vorpal: because the "GOOD: , works" is printed out manually
22:16:07 <elliott> so the first was like 7 times faster to type
22:16:10 -!- MigoMipo has quit (Read error: Connection reset by peer).
22:16:12 <elliott> Vorpal: I use fully buffered output always now.
22:16:17 <elliott> Because it was so fucking slow.
22:16:32 <Vorpal> elliott, no you probably use line buffered
22:16:35 <Vorpal> rather than unbuffered
22:16:46 <elliott> Make a fingerprint to switch it in-program. :)
22:16:51 <Vorpal> elliott, cfunge has an option for fully buffered
22:17:02 <elliott> Apart from inflating benchmark results.
22:17:05 <Vorpal> elliott, nifty and useful
22:18:26 <Vorpal> elliott, you need to fix those placeholders too
22:18:32 <Vorpal> even if they don't say BAD as such
22:18:39 <Vorpal> -- PLACEHOLDER: ENVIRONMENT VARIABLES
22:18:39 <Vorpal> -- PLACEHOLDER: ARGUMENTS
22:18:49 <elliott> That's for when I actually have an interface, instead of:
22:18:55 <elliott> mycology <- B.readFile "mycology.b98"
22:18:55 <elliott> let st = fungeStateFromByteString mycology
22:18:56 <elliott> let FungeSpace m minXY maxXY = fungeSpace st in print $ (Map.size m, minXY, maxXY)
22:18:57 <elliott> ignore (evalShiro interpret st)
22:19:06 <Vorpal> elliott, env you can easily get hold of?
22:19:26 <elliott> Yes, but it's not exactly high-priority. :P
22:21:07 <Vorpal> elliott, will you render TURT to an svg?
22:21:27 <Vorpal> elliott, if so may I suggest efunge as state-of-the-art
22:21:39 <Vorpal> elliott, in svg rendering
22:21:50 <elliott> I'm sure there's a Haskell library for that :P
22:22:08 <Vorpal> elliott, efunge is state-of-the-art in svg backends for TURT
22:22:29 <Vorpal> elliott, no cfunge has a tiny bug in overlapping lines and dots
22:22:41 <Vorpal> it isn't specified really
22:22:46 <Vorpal> but efunge does it better
22:23:00 <elliott> (if x == minX || x == maxX || y == minY || y == maxY then
22:23:01 <elliott> FungeSpace (Map.delete k m) minXY maxXY -- TODO: Shrink
22:23:03 <elliott> This is how I check things
22:23:13 <Vorpal> elliott, look, cfunge assumes that dots go on top of lines. efunge does it in order of drawing :P
22:23:27 <Vorpal> elliott, thus cfunge uses a magic pen for the turtle robot
22:23:32 <Vorpal> thus it is correct. As well.
22:24:05 <elliott> Shrinking bounds really does need a population count, right?
22:24:06 -!- Phantom_Hoover has quit (Quit: Leaving).
22:24:25 <Vorpal> elliott, you could just recalculate them the hard way
22:24:26 <elliott> Because I'm too stupid to see how to do it even vaguely-efficiently otherwise.
22:24:43 <Vorpal> elliott, cfunge uses pop could per row and column yes
22:25:02 <Vorpal> elliott, no clue what ccbi does
22:25:11 <Vorpal> elliott, presumably it involves a CAS!
22:25:20 <elliott> Vorpal: An array of population count things
22:25:26 <elliott> Vorpal: But he wants to make it a something something k-d tree of them
22:25:30 -!- nrkn has joined.
22:25:47 <elliott> Isn't that right Deewiant "Computer Science Is My One True Love, Especially If It's Needlessly Academic" Deewiant
22:25:49 <Deewiant> I don't keep population counts, just the space itself
22:26:02 <Vorpal> Deewiant, so how do you shrink bounds
22:26:11 <elliott> Oh hi there, Vorpal "I Saved One Cycle In 2000 Lines, The Code Is Better Now" Vorpal.
22:27:00 <Vorpal> elliott, I actually iterate through my hash table if the bounds are large instead. This is because I suspect it to be rather sparse
22:27:07 <Vorpal> so enumerating the values is better
22:27:37 <Vorpal> elliott, more importantly it makes slowdown.b98 work
22:28:43 <Vorpal> oh that is of course the hash table for column/row counts I enumerate
22:29:06 <Vorpal> given small bounds I just try to shrink step by step
22:30:15 <elliott> BAD: after spacing right edge, y should report greatest point as ( 181 910 ), not ( 182 910 )
22:30:34 <elliott> if x == minX || y == minY || x == maxY || y == maxY then [RECALCULATE INCREDIBLY SLOWLY]
22:31:16 <Vorpal> elliott, off by one error I suspect
22:31:48 <elliott> https://github.com/github/github-services/issues/closed#issue/54
22:31:58 <elliott> GitHub, the premier free website host!
22:33:49 <elliott> No off-by-one error that I can see.
22:34:01 <Vorpal> elliott, you are doing it wrong btw. You aren't lazy in recalculating the bounds!
22:34:14 <elliott> I actually am, just that they get forced immediately after :P
22:34:26 <Vorpal> elliott, well you don't defer it until you need it for y or for wrapping
22:34:37 <Vorpal> (not that wrapping needs exact bounds)
22:34:43 <elliott> Except I guess GHC decides to optimise it into strictness
22:34:51 -!- kar8nga has quit (Remote host closed the connection).
22:34:56 <Vorpal> elliott, cfunge doesn't do it until required
22:36:00 <elliott> Vorpal: Look at the code snippet I pasted
22:36:03 <elliott> <elliott> if x == minX || y == minY || x == maxY || y == maxY then [RECALCULATE INCREDIBLY SLOWLY]
22:36:12 <elliott> GOOD: y reports shrunk bounds correctly after spacing top-left corner
22:36:13 <elliott> BAD: after spacing right edge, y should report greatest point as ( 181 910 ), not ( 182 910 )
22:36:15 <elliott> GOOD: y reports shrunk bounds correctly after spacing bottom edge
22:36:50 <elliott> Reading takes a bit under a second though
22:37:12 <Vorpal> $ time env -i build/cfunge -SF mycology/mycology.b98 >/dev/null
22:37:18 <Vorpal> elliott, that is approx the same as your
22:37:26 <elliott> Vorpal: ...by what metric?
22:37:28 <Vorpal> elliott, no env args, no fingerprints, no i and o
22:37:43 <Vorpal> elliott, I meant approx the same work done
22:37:43 <elliott> Vorpal: Was it that fast and compliant on day 2?
22:37:57 <elliott> The fact that you can disable _features_ after it's _compliant and fast_ is irrelevant :P
22:38:03 <Vorpal> elliott, no. Day 4 more like it. I mean it's C
22:38:19 <Vorpal> elliott, anyway -F disables fingerprints only
22:38:21 <elliott> I doubt that's possible, unless you had as direct a connection to Deewiant as I have
22:38:41 <Vorpal> elliott, I didn't until a bit later. So like a few weeks
22:38:56 <elliott> Let's see where I am in a few weeks :P
22:39:04 <Vorpal> elliott, anyway. your cpu is faster
22:39:11 <Vorpal> elliott, this is a sempron at 2 GHz
22:39:21 <elliott> Deewiant: How does CCBI do: UNDEF: the empty string wrapped around the edge of space contains 1 character(s) (hopefully spaces)
22:39:26 <Vorpal> elliott, sempron has 128 kB cache
22:39:34 <elliott> I think I'd prefer to make it 0, either that or 2^32 - 1 :P
22:39:37 <Deewiant> elliott: Didn't you grab CCBI already?
22:40:21 <Vorpal> elliott, YOU KNOW WHAT?
22:40:31 <Vorpal> elliott, I timed a debug build -O0 -ggdb3
22:40:59 <elliott> SLOCDirectorySLOC-by-Language (Sorted)
22:41:00 <Vorpal> $ time env -i build_opt/cfunge -SF mycology/mycology.b98 >/dev/null
22:41:11 <Vorpal> elliott, I implement fingerprints too
22:41:18 <Vorpal> elliott, and env args and so on
22:41:21 <elliott> Vorpal: cp those files out before doing it
22:41:21 <Vorpal> elliott, so not fair at all
22:41:42 <Vorpal> elliott, what tool did you use
22:41:42 <elliott> Env args, sure, but that's a few lines.
22:41:57 <elliott> It should be "sloccount" in your nearest repository.
22:42:11 <elliott> It is quite noisy in its output but the relevant statistic is the one that looks like what I pasted.
22:42:16 <Vorpal> elliott, not in pacman. Too much work. But iirc with fingerprints and everything it is about 9000 lines of code.
22:42:27 <elliott> Sloccount isn't in pacman??
22:42:49 <elliott> I was about to say, didn't think the repos were THAT bad :D
22:42:55 <Vorpal> elliott, anyway about 9000 lines of code + external code adding another 1000 or so
22:43:01 <elliott> Vorpal: sloccount ignores whitespace and comments
22:43:08 <Vorpal> elliott, I used ohcount to get that iirc
22:43:42 <Vorpal> elliott, anyway I cache a stack with env vars and cmd line arguments so I can just memcpy it onto the stack if required :P
22:44:00 <elliott> But what if the environment variables change?
22:44:12 <Vorpal> elliott, I don't implement ENVR or whatever it is
22:44:16 <Vorpal> elliott, so a non-issue
22:44:23 <elliott> Ah, so yours is less useful
22:44:39 <Vorpal> elliott, not compared to *current* state
22:44:58 <Vorpal> oh sure compared to CCBI I do fewer fingerprints
22:45:08 <Vorpal> elliott, when did you last build CCBI from source?
22:45:16 <Vorpal> elliott, no... nor does ccbi
22:45:34 <Vorpal> elliott, I implement some that CCBI doesn't
22:46:03 <Vorpal> elliott, well mycology doesn't test it. Or didn't last I looked
22:46:13 <elliott> New fingerprints, from Rc/Funge-98:
22:46:24 <Vorpal> elliott, does mycology test them?
22:46:29 <Vorpal> elliott, I implement those two
22:46:38 <elliott> Deewiant: Can FNGR be reconciled with the specification?
22:47:00 <Deewiant> FNGR just enables FNGR-mode or some such
22:47:06 <Vorpal> oh you mean the "spec no longer used bit"
22:47:44 -!- pumpkin has quit (Quit: Computer has gone to sleep.).
22:48:34 <Vorpal> elliott, anyway you will have less embedded asm. This is bad.
22:48:49 <elliott> This probably even runs on Windows
22:48:54 -!- evitable has quit (Read error: Connection reset by peer).
22:49:05 <Vorpal> elliott, bug: cpp isn't lisp macros
22:49:20 <Vorpal> solution: use workaround (using cpp)
22:49:39 <Vorpal> elliott, bug: no preprocessor
22:49:49 <elliott> Vorpal: Solution: Template Haskell
22:49:57 <elliott> All the elegance of Haskell with all the pain of Haskell's AST
22:50:03 <Vorpal> elliott, or. A literate perl script!
22:50:08 -!- myndzi_ has joined.
22:50:11 <elliott> GHC is a literate Perl script based on regexps.
22:50:12 <Vorpal> elliott, that munges your stuff
22:56:17 <elliott> Deewiant: I'm TOTALLY optimising.
22:56:21 <elliott> File loading, to be specific :P
22:56:47 <elliott> "Note: this operation may break referential transparency! If any other process on the system changes the file when it is mapped into Haskell, the contents of your ByteString will change."
23:04:56 -!- Laugarhraun has joined.
23:05:26 <elliott> Deewiant: I need dependent types :D
23:06:38 <elliott> "Hey, @jonharrop is following me. Unrelated hasn't Common Lisp been scientifically measured as being 10 times as awesome as OCaml or F#?" --James Iry
23:10:15 -!- Lymia_ has changed nick to Lymia.
23:10:16 -!- Lymia has quit (Changing host).
23:10:16 -!- Lymia has joined.
23:12:23 <Lymia> My BF Joust evolver hasn't crashed.
23:13:06 <Lymia> !bfjoust evolved-1006-0 -.+-><-.-[..[.++.]]+><.++>-.-<<..-.+[.+<.><]--<-.>.<>.+<.--<->>(+<>..>><>)*1>><->-<++.-..+-.<+.->>+<-<<>(+++<+-++..[>[.].]..+.-<<<.<>[<-][]>-[].<>-<..[>-<<-][]-.)*3>
23:13:10 <Lymia> In before it completely flunks.
23:13:45 <EgoBot> Score for Lymia_evolved-1006-0: 20.4
23:14:31 <Lymia> (If you must ask, evo-1 is an attempt to evolve the hill, instead of starting from scratch)
23:15:58 <Lymia> I do believe that's ~16 or so hours of evolving.
23:16:09 <Lymia> Is that a defensive bot?
23:16:32 <elliott> Lymia: suggestion: download the current hill, and after, say, 1000 generations, introduce the best warrior left from the hill every 100 or so generations
23:16:41 <elliott> generation 1000 - best warrior from the current hill is added
23:16:45 <elliott> generation 1100 - second-best warrior from the current hill is added
23:16:54 <Lymia> From the egobot hill?
23:16:59 <elliott> yes, the current one as it is now
23:16:59 <elliott> that way, your warriors start to evolve against the current competition
23:17:04 <elliott> Lymia: oh, omit the evolved ones though
23:17:08 <elliott> (that are on the current hill)
23:17:21 <elliott> that way, once the warriors start getting good, they gradually have to fight against the current hill
23:17:23 <Lymia> I might just make it autoupdate the targets.
23:17:38 <Lymia> elliott, it's coded so that the hill dosn't actually get into the evolver's generations.
23:17:42 <Lymia> But they are counted as part of the score.
23:18:29 <elliott> Lymia: Oh, so it is fighting against the current hill?
23:18:37 <Lymia> It goes off the tape as soon as [..[.++.]] exits.
23:18:40 -!- myndzi_ has quit (Quit: -a-).
23:18:59 <elliott> Lymia: you might want to modify egobot to print when some code is never executed when fighting against the hill
23:19:01 <elliott> so that you can strip it off
23:19:13 <elliott> otherwise it'll keep mutating dead code
23:19:47 <elliott> Deewiant: When you pop an 0gnirts, the first thing you pop is the start of the string, right?
23:19:50 <Lymia> elliott, and output it into what?
23:20:00 <elliott> Lymia: Or stdout, if that's not already being used.
23:20:08 <Lymia> I'm using the return value only.
23:20:10 -!- nrkn has quit (Quit: Page closed).
23:20:45 <Lymia> I could just manually strip off dead code before posting it to egobot.
23:20:59 <Lymia> Mutation is basicly the quickest process.
23:22:49 <elliott> Deewiant: Also, if the least significant bit of the flags cell is high, i treats the file as a binary file; that is, EOL and FF sequences are stored in Funge-space instead of causing the dimension counters to be reset and incremented.
23:23:30 <Lymia> Right now, it only reads the hill when it's started up.
23:23:48 <Lymia> This is obviously a problem.
23:25:01 <elliott> Deewiant: Aaarrgh! I just discovered something even worse.
23:25:08 <elliott> Lymia: not really, it won't change that much
23:25:31 <Lymia> I could make it update every 100 generations or so.
23:25:34 <elliott> Deewiant: I can't just return the last (x,y).
23:25:39 <elliott> Lymia: Way too often, try every 500.
23:25:56 <Lymia> 100 generations is often
23:26:09 <Lymia> Considering how long a generation takes, it's not that fast.
23:31:05 <elliott> Deewiant: Can mycology test i without o? :p
23:31:07 -!- TLUL has joined.
23:33:30 <Lymia> > 0xFFFFFFFFFFFFFFFF + 1
23:33:40 <Lymia> > 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF + 1
23:33:40 <lambdabot> 340282366920938463463374607431768211456
23:33:45 <Lymia> Screw you and your bignums.
23:34:25 <Lymia> :t 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
23:34:37 <elliott> Lymia: If you want to put off learning Haskell, just look at that code I pasted ealier.
23:34:49 <lambdabot> Control.Applicative empty :: Alternative f => f a
23:34:50 <lambdabot> Data.ByteString empty :: ByteString
23:35:51 -!- Sgeo has joined.
23:35:55 -!- augur has quit (Remote host closed the connection).
23:36:38 -!- augur has joined.
23:37:36 -!- augur has quit (Remote host closed the connection).
23:37:49 -!- calamari has joined.
23:39:07 <elliott> Deewiant: What happens if you use o on a section of fungespace with non-ASCII bytes?
23:42:38 <Sgeo> Ok. Maybe it's a bad idea to try to teach someone bad at math my mental shortcut of trying to see how to get units to fit together in order to figure out what to do
23:42:58 <elliott> methinks that Deewiant is away
23:45:17 -!- ais523 has quit (Ping timeout: 240 seconds).
23:47:56 <elliott> all the people who know anything have disappeared
23:49:09 -!- cheater00 has joined.
23:51:03 <Sgeo> elliott, I'm still here
23:52:29 -!- cheater- has quit (Ping timeout: 240 seconds).
23:57:33 <variable> http://scientopia.org/blogs/goodmath/2011/02/06/computability/ --> may interest people here