00:00:06 <pikhq> elliott: THE FAIL IS SO STRONG.
00:00:48 <oerjan> elliott: i think i'd like to see the code for y, too
00:01:04 <elliott> oerjan: erm are you sure, it _may_ scare you; shall i just show the relevant lines?
00:01:09 <oerjan> i don't see how the bug can be in what you showed me
00:01:17 <elliott> let (minX,minY) = minCoords (fungeSpace st)
00:01:19 <elliott> let (maxX,maxY) = maxCoords (fungeSpace st)
00:01:19 <elliott> pushVec (maxX-minX,maxY-minY)
00:01:24 <elliott> oerjan: when i recalculated bounds the really slow way
00:01:36 <elliott> oerjan: i.e. whenever we're at an extremity in either x or y, recalculate them from every key in the map from scratch
00:01:41 <elliott> that y code worked just fine
00:01:45 <elliott> all i've changed is fungespace.hs
00:02:26 <elliott> pikhq: [[Sometimes when someone has a shameful or socially unacceptable death, such as suicide or the above mentioned alchohol poisioning and such, the media will blame fan death even when it is clearly evident that they were killed by some other means. It is possible for the death someone with a gun shot wound to be blamed on fans.] [[I was recently discussing this via email with a friend, his (humorous) comments follow:
00:02:26 <elliott> "The explanation of fan death is accepted by many Korean medical professionals. In summer, mainstream Korean news sources regularly report on cases of fan death, even if more likely causes (e.g. heart attack, ****gunshot****, alcohol poisoning) are evident."]]
00:02:50 <quintopia> wtf. i just noticed that how_stupid_is_it beats wireless XD
00:02:55 <pikhq> elliott: THE FAN PUT A BULLET IN MY HEART
00:03:33 -!- Phantom_Hoover has quit (Remote host closed the connection).
00:03:45 <elliott> pikhq: [[I'm a South Korean, and my family also has used the function in summer nights. However, it's not because of the only "fan death" belief. My family uses the function because of not only "fan death" belief but also other various reasons:
00:03:45 <elliott> to prevent to be sick with air-conditioningitis (냉방병; 冷房病)
00:03:45 <elliott> to save electric charges: When we already fell asleep in usual summer night, although fans are turned off, we can sleep comfortable continually if the windows are opened (except abnormally hot night).
00:03:45 <elliott> I want to ask you not to think a "timer snob" of Korean fans as "just" a equipment to prevent "fan death". ― 韓斌/Yes0song (談笑 筆跡 다지모) 07:16, 19 February 2008 (UTC)]]
00:03:51 <elliott> pikhq: PREVENT TO BE SICK WITH AIR-CONDITIONINGITIS
00:04:40 <Sgeo> Koreans are just particularly suseptible to hypothermia
00:04:46 <elliott> pikhq: wow, i didn't realise jhc was such a cool compiler
00:04:49 <quintopia> and by adding a single + to the beginning of wireless, it now gets almost two more points than the next best program. crazy.
00:04:55 <elliott> pikhq: http://repetae.net/computer/jhc/jhc.shtml (out of date apparently but mostly correct)
00:05:17 <pikhq> Sgeo: s/hypo/hyper/
00:05:22 <elliott> pikhq: "No pre-written runtime. other than 20 lines of boilerplate all code is generated from the Grin intermediate code and subject to all code simplifying and dead code elimination transformations." "Second Intermediate language is based on Boquist's graph reduction language. This allows all unknown jumps to be compiled out leaving standard case statements and function calls as the only form of flow control. Combined with jhc's use of region in
00:05:22 <elliott> ference, this means jhc can compile to most any standard imperative architecture/language/virtual machine directly without special support for a stack or tail-calls." ""All indirect jumps are transformed away, jhc's final code is very similar to hand-written imperative code, using only branches and static function calls. A simple basic-blocks analysis is enough to transform tail-calls into loops."
00:05:24 <elliott> pikhq: "E is a pure type system based on Henk and the lambda-cube. An important property of E is that there is no distinction between types and values, this is important for jhc's implementation of type classes."
00:05:36 <pikhq> Sgeo: They get temperatures and humidity high enough to cause hyperthermia during the summer.
00:05:52 <Sgeo> pikhq, I was making a joke explanation for air-conditionitis
00:07:05 <Sgeo> I asked my dad what if I talked to someone who looked at my college courses. He said they wouldn't know me, and about my tending to not get stuff done on time, and said that anywhere else, I'd have failed a lot of courses
00:07:47 <elliott> Sgeo: Your dad is a moron, ignore him, you should move out, blah blah why do I even bother typing this shit
00:08:46 <pikhq> Sgeo: Your course of study qualifies you to ask "would you like fries with that?". His argument is invalid.
00:09:54 <nescience> what is the max length of a bf joust program?
00:11:04 <oerjan> elliott: are you sure that insertFS is the only function updating your fungespace?
00:11:27 <oerjan> also, have you tested it directly
00:12:13 <elliott> oerjan: haven't tested it directly, I will now; nothing else modifies it directly
00:13:17 <elliott> oerjan: *Shiro.FungeSpace Data.Map> insertFS (10,10) 42 $ insertFS (-10,10) 42 emptyFungeSpace
00:13:18 <elliott> FungeSpace {spaceMap = fromList [((-10,10),42),((10,10),42)], minCoords = (-10,0), maxCoords = (10,10), rowPopulation = fromList [(10,2)], colPopulation = fromList [(-10,1),(10,1)]}
00:13:21 <elliott> oerjan: now to try removing
00:13:34 <elliott> *Shiro.FungeSpace Data.Map> insertFS (10,10) 32 $ insertFS (10,10) 42 $ insertFS (-10,10) 42 emptyFungeSpace
00:13:35 <elliott> FungeSpace {spaceMap = fromList [((-10,10),42)], minCoords = (-10,10), maxCoords = (-10,10), rowPopulation = fromList [(10,1)], colPopulation = fromList [(-10,1)]}
00:13:39 <elliott> oerjan: (32 is space obviously)
00:13:53 <elliott> rowPopulation got updated correctly
00:14:04 <elliott> but minCOords/maxCoords didn't
00:14:10 <elliott> maxCoords went *negative*??
00:14:20 <elliott> oerjan: figured it out? :P
00:14:46 <oerjan> no, you got the correct result then...
00:15:04 <Sgeo> quintopia, someone quoted something that someone said about people worrying about air conditioner death too
00:15:55 <elliott> *Shiro.FungeSpace Data.Map> insertFS (10,10) 42 $ insertFS (-10,10) 42 emptyFungeSpace
00:15:56 <oerjan> um yes, those are the correct minCoords/maxCoords
00:15:57 <elliott> FungeSpace {spaceMap = fromList [((-10,10),42),((10,10),42)], minCoords = (-10,0), maxCoords = (10,10), rowPopulation = fromList [(10,2)], colPopulation = fromList [(-10,1),(10,1)]}
00:15:57 <elliott> *Shiro.FungeSpace Data.Map> insertFS (999,999) 32 $ insertFS (999,999) 42 $ insertFS (10,10) 42 $ insertFS (-10,10) 42 emptyFungeSpace
00:15:57 <elliott> FungeSpace {spaceMap = fromList [((-10,10),42),((10,10),42)], minCoords = (-10,10), maxCoords = (10,10), rowPopulation = fromList [(10,2)], colPopulation = fromList [(-10,1),(10,1)]}
00:16:03 <elliott> oerjan: those two results should be identical
00:16:26 <elliott> *Shiro.FungeSpace Data.Map> insertFS (999,999) 42 $ insertFS (10,10) 42 $ insertFS (-10,10) 42 emptyFungeSpace
00:16:27 <elliott> FungeSpace {spaceMap = fromList [((-10,10),42),((10,10),42),((999,999),42)], minCoords = (-10,0), maxCoords = (999,999), rowPopulation = fromList [(10,2),(999,1)], colPopulation = fromList [(-10,1),(10,1),(999,1)]}
00:16:34 <elliott> (easier to understand with wide irc window)
00:17:24 <oerjan> oh (-10,0) and (-10,10)...
00:18:06 <elliott> oerjan: want me to try less confusing coordinates?
00:18:35 <oerjan> no i want you to shut up so i can look at what's already there
00:21:41 <oerjan> ah hm... lessee the code again
00:23:26 <elliott> oerjan: you want me to put it on sprunge again? :-P
00:24:01 <oerjan> um isn't it what it was previously?
00:25:25 <oerjan> the rowPopulation and colPopulation are correct at all times, it seems
00:25:49 <elliott> right. so it's the calculation of bounds that is wrong
00:26:37 <lambdabot> Overlapping instances for GHC.Show.Show
00:28:12 <oerjan> elliott: i note that minCoords and maxCoords are correct in the case above where the space was added
00:28:57 <oerjan> which makes me suspect the _other_ branch
00:29:58 <oerjan> but (min x minX, min y minY) (max x maxX, max y maxY)
00:30:03 <oerjan> ought to be correct...
00:32:28 -!- Mathnerd314 has quit (Ping timeout: 245 seconds).
00:33:01 <elliott> oerjan: yeah that branch is correct
00:33:03 -!- cheater- has joined.
00:33:04 <elliott> it was in the old correct version too
00:33:15 <quintopia> wireless = #1 program on the hill, with almost 5 more points than the second best
00:33:20 <elliott> oerjan: well obviously the modm part wasn't
00:35:33 <oerjan> elliott: there's just the tiny problem that the examples above that give the wrong result are cases where _only_ that branch should be used
00:35:34 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
00:36:15 -!- cheater00 has quit (Ping timeout: 240 seconds).
00:36:19 <elliott> (modm (+1) y popRow) (modm (+1) x popCol)
00:36:33 <oerjan> the error is in emptyFungeSpace
00:36:51 <oerjan> it is empty, it shouldn't _have_ minima or maxima
00:37:10 <elliott> emptyFungeSpace = FungeSpace Map.empty (0,0) (0,0) Map.empty Map.empty
00:37:15 <elliott> oerjan: in all my examples,
00:37:20 <oerjan> this causes min 10 0 = 0, the wrong result once you add one element
00:37:21 <elliott> oerjan: i add before removing
00:37:25 <elliott> oerjan: and findMin/... aha
00:37:45 <elliott> oerjan: hm what's the solution though :D
00:37:54 <elliott> apart from an ugly Maybe around everything
00:38:32 <oerjan> well you just need to know when it's empty in the second branch
00:39:07 <elliott> (if m == Map.empty then (x,y) else (min x minX, min y minY))
00:39:30 <elliott> oerjan: so my minimum bound has been broken this whole time heh
00:39:54 <oerjan> oh and btw you might get a crash from the first branch if you empty fungespace again, not that i know whether this is possible
00:40:04 <elliott> i think it is but i'll deal with that later
00:40:06 <elliott> oerjan: just fixed that AND... drumroll ... ... wait for it
00:40:14 <elliott> that's right!! nothing changed
00:40:37 <elliott> FungeSpace (Map.insert k v m)
00:40:37 <elliott> (if m == Map.empty then (x,y) else (min x minX, min y minY))
00:40:37 <elliott> (modm (+1) y popRow) (modm (+1) x popCol)
00:41:07 -!- Mathnerd314 has joined.
00:41:07 <oerjan> um you need that on max too
00:41:58 <oerjan> although indeed that should have changed that error part...
00:42:56 <elliott> BAD: after spacing top-left corner, y should report least point as ( -2 -1 ), not ( -10 -10 )
00:42:58 <elliott> BAD: after spacing top-left corner, y should report greatest point as ( 182 910 ), not ( 190 919 )
00:42:58 <elliott> BAD: after spacing right edge, least point reported by y should remain ( -2 -1 )
00:42:58 <elliott> BAD: after spacing right edge, y should report greatest point as ( 181 910 ), not ( 190 919 )
00:42:58 <elliott> BAD: after spacing bottom edge, y should report greatest point as ( 181 909 ), not ( 190 918 )
00:44:34 <oerjan> well that particular error just corrected cannot give anything but a misplaced 0 somewhere, i think
00:44:46 <oerjan> so that cannot be the cause
00:46:05 <elliott> oerjan: this is the most wtf bug ever...
00:46:15 <elliott> oerjan: the algorithm does make sense right?
00:46:25 <elliott> taking the minimum and max keys of a population count map where there are no 0 values
00:46:44 <elliott> oerjan: what if there's a value at (0,500) and a value at (700,0)
00:48:34 <elliott> oerjan: so err... any clues
00:49:58 <oerjan> elliott: is it possible for you to get a print of the fungespace at that point when the bad thing happens?
00:50:16 <elliott> oerjan: i could print it out on every y, but IIRC Mycology tests y a shitload. but it could be worth a try.
00:50:27 <elliott> oerjan: except that that would be /hopelessly/ impractical, unless i omitted the space map
00:50:35 <elliott> oerjan: because mycology is a 100K text file even to start with
00:50:42 <elliott> would just the min/max coords and population lists do?
00:50:45 <oerjan> elliott: try putting in a test for the faulty values 190 919 it mentions above
00:50:45 <elliott> (population lists will be very long)
00:50:54 <elliott> just print out the value at that point?
00:51:21 -!- poiuy_qwert has joined.
00:52:19 -!- augur has joined.
00:52:22 <elliott> oerjan: btw just so you know:
00:52:28 <elliott> ("YYYYYY","190 919 --> ",32)
00:52:28 <elliott> y claims all of the following:
00:52:30 <elliott> That the least point containing a non-space cell is ( -3 -2 )
00:52:36 <elliott> That the greatest point, relative to that point, is ( 183 911 )
00:52:36 <elliott> note: relative to that point
00:52:42 <elliott> oerjan: tl;dr whenever y is called, 190,919 is 32
00:52:50 <elliott> my hunch is that it's always 32.
00:53:01 <elliott> oerjan: remember that even if (x,y) is the tightest max bound it can be space
00:53:09 <elliott> oerjan: because consider (32,0) and (0,32)
00:53:13 <elliott> which will just have a space at it
00:55:00 <oerjan> well but _is_ the separate maxx and maxy which should be reported, not some actually filled cell, i presume
00:55:22 <elliott> oerjan: (well technically the spec contradicts that but then it contradicts itself a line later, so we just ignore it)
00:55:37 <elliott> oerjan: it's the topleftmost point of the smallest bounding rectangle and its size, basically
00:56:16 <elliott> by basically, i mean exactly
00:56:27 <elliott> SO ER ANY IDEAS :D ... maybe it's a GHC bug!
00:56:41 <oerjan> and you said this worked before you optimized insertFS's minmax calculations
00:56:42 <elliott> as far as I can tell, the logic is flawless. so i'm dumbfoundergasted.
00:56:58 <elliott> oerjan: yes; for posterity here is the original version of insertFS
00:57:28 <oerjan> elliott: try calculating the min and max at that point directly from the main Map
00:57:43 <elliott> oerjan: er, if you let me paste, that's exactly what insertFS /used/ to do
00:57:45 <elliott> stupid sprunge is being slow
00:57:51 <elliott> oerjan: http://sprunge.us/GhCM
00:58:12 <elliott> this worked perfectly apart from the minor "empty fungespace min/max" bug which did _not_ trigger in mycology
00:58:26 <elliott> ofc there were no population count maps
00:59:49 <elliott> oerjan: so we know that the population counts are being updated perfectly.
01:00:12 <elliott> oerjan: and we know that the non-shrink case updates the ... wait
01:00:23 <elliott> oerjan: and we know that the non-shrink case updates the bounds perfectly
01:00:34 <elliott> oerjan: so the error _must_ be in the calculation of bounds from population counts in the shrink case
01:00:41 <elliott> newMinX = fst . Map.findMin $ colPopulation fs'
01:00:43 <elliott> newMaxX = fst . Map.findMax $ colPopulation fs'
01:00:43 <elliott> newMinY = fst . Map.findMin $ rowPopulation fs'
01:00:43 <elliott> newMaxY = fst . Map.findMax $ rowPopulation fs'
01:02:04 <oerjan> so you _have_ checked that colPopulation and rowPopulation are correct at the BAD point?
01:02:37 <oerjan> (or, whatever mycology wants it to be)
01:03:09 <elliott> oerjan: well no. but thanks to my exhaustive two-line test, i assume that code is perfect
01:03:43 <elliott> *Shiro.FungeSpace Data.Map> insertFS (10,12) 22 $ insertFS (10,11) 22 $ insertFS (10,10) 22 emptyFungeSpace
01:03:44 <elliott> FungeSpace {spaceMap = fromList [((10,10),22),((10,11),22),((10,12),22)], minCoords = (0,0), maxCoords = (10,12), rowPopulation = fromList [(10,1),(11,1),(12,1)], colPopulation = fromList [(10,3)]}
01:03:44 <elliott> *Shiro.FungeSpace Data.Map> insertFS (10,11) 32 $ insertFS (10,12) 22 $ insertFS (10,11) 22 $ insertFS (10,10) 22 emptyFungeSpace
01:03:44 <elliott> FungeSpace {spaceMap = fromList [((10,10),22),((10,12),22)], minCoords = (10,10), maxCoords = (10,12), rowPopulation = fromList [(10,1),(12,1)], colPopulation = fromList [(10,2)]}
01:03:54 <elliott> oerjan: there is no way i can test col/rowPopulation on mycology
01:03:58 <elliott> oerjan: as i said, it's 100K + some
01:04:00 <oerjan> elliott: not _that_ test
01:04:14 <oerjan> elliott: that many columns and rows?
01:04:34 <elliott> oerjan: what do you mean? obviously there can be an empty row
01:04:38 <elliott> and it won't be in the list
01:04:55 <oerjan> i mean 100K doesn't mean 100K rows or 100K columns
01:05:14 <oerjan> although i guess rows are often larger
01:05:25 <oerjan> ok so just check the columns
01:05:35 <elliott> oerjan: same with columns, it was an example
01:05:36 <oerjan> they were reported in error too, after all
01:05:43 <elliott> oerjan: mycology explicitly puts something a way out of space
01:05:49 <elliott> with both blank columns and rows separating it from anything else
01:06:03 <oerjan> elliott: well that doesn't matter unless it puts things in _every_ column
01:06:25 <elliott> oerjan: well i'm not sure what you want me to print them
01:06:36 <elliott> io $ print ("YYYYYY","190 919 --> ", fungeSpace st !@ (190,919))
01:07:30 <oerjan> just print minimum . keys ... and maximum . keys ... for colPopulation directly
01:08:10 <oerjan> we want to see if colPopulation itself contains an error before assuming that the error is in calculating data _from_ it
01:08:23 <oerjan> so calculate the data in a different way
01:08:40 <elliott> oerjan: ok, where do yo uwant the output from?
01:08:56 <elliott> ("minkeys are monkeys",-10,"but maxkeys are for life",180)
01:08:57 <elliott> ("minkeys are monkeys",-10,"but maxkeys are for life",180)
01:08:57 <elliott> BAD: after spacing top-left corner, y should report least point as ( -2 -1 ), not ( ("minkeys are monkeys",-10,"but maxkeys are for life",180)
01:08:57 <elliott> [same coords for the rest of the errors]
01:08:59 <oerjan> some point where you know mycology is complaining about the result of y
01:09:24 <elliott> ("minkeys are monkeys",-3,"but maxkeys are for life",180)
01:09:28 <elliott> That the least point containing a non-space cell is ( -3 -2 )
01:09:28 <elliott> That the greatest point, relative to that point, is ( 183 911 )
01:09:32 <elliott> (note that it's offset so 183-3 = 180 is the real greatest point)
01:09:40 <elliott> (the debug output is absolute)
01:09:51 <elliott> oerjan: and it turns to -10,180 here:
01:09:56 <elliott> GOOD: read written data to (-10, -10)
01:09:57 <elliott> GOOD: read data in binary mode to (-10, -10)
01:09:57 <elliott> ("minkeys are monkeys",-10,"but maxkeys are for life",180)
01:10:17 <oerjan> ok so that means colPopulation _is_ in error
01:10:29 <oerjan> or so i would assume now
01:10:44 <oerjan> (that -10 should have been -2)
01:11:30 <oerjan> ooh i think i know again!
01:11:58 <oerjan> i asked you about why you didn't check if Map.lookup k m == Nothing
01:11:59 -!- pikhq_ has joined.
01:12:09 -!- pikhq has quit (Ping timeout: 265 seconds).
01:12:18 <elliott> the problem is that if it's nothing,
01:12:27 <elliott> it still subtracts from popcount!
01:12:47 <elliott> if fs !@ k == space then fs else
01:13:20 <elliott> BAD: after spacing top-left corner, y should report least point as ( -2 -1 ), not ( ("minkeys are monkeys",-10,"but maxkeys are for life",180)
01:13:22 <elliott> ("minkeys are monkeys",-10,"but maxkeys are for life",180)
01:13:31 <elliott> oerjan: wtf, we (you) keep discovering and fixing all these fatal bugs, but they don't change shit
01:14:47 <oerjan> oh wait ... the other branch has the _opposite_ error :D
01:14:59 <oerjan> you add 1 even if it _wasn't_ space :D
01:15:12 <elliott> oerjan: have i ever told you i'm retarded?
01:15:38 <elliott> (if fs !@ k == space then modm (+1) y popRow else popRow)
01:15:40 <elliott> (if fs !@ k == space then modm (+1) x popCol else popCol)
01:15:51 <elliott> oerjan: i love how perfect the code looked at first
01:16:14 <elliott> GOOD: y reports shrunk bounds correctly after spacing top-left corner
01:16:18 <elliott> GOOD: y reports shrunk bounds correctly after spacing right edge
01:16:22 <elliott> GOOD: y reports shrunk bounds correctly after spacing bottom edge
01:16:23 <elliott> oerjan: you, sir, are a scholar and a gentleman
01:16:44 <elliott> oerjan: you've finally put your phd to good use!
01:16:59 <elliott> no but seriously :DDDDDD ENDLESS HAPPIES THANK YOU
01:17:28 -!- copumpkin has joined.
01:17:28 -!- copumpkin has quit (Changing host).
01:17:28 -!- copumpkin has joined.
01:19:05 <elliott> oerjan: now i have to backport my optimised mergeByteString to this new structure :-D
01:20:02 -!- oerjan has quit (Quit: Good night).
01:23:07 <elliott> TODO: actually port the optimise mergeByteString :D
01:23:57 -!- myndzi\ has changed nick to myndzi.
01:24:04 <myndzi> btw the bot tries to msg back the wrong nick
01:24:11 <myndzi> i think it tried to msg myndzi_
01:24:27 <myndzi> it just didn't send for some reason
01:34:45 -!- zzo38 has joined.
01:34:47 -!- elliott has quit (Quit: Leaving).
01:39:23 <myndzi> someone doesn't know the difference between dcc and msg?
01:41:02 -!- pikhq_ has changed nick to pikhq.
01:44:29 -!- poiuy_qwert has changed nick to p_q.
01:44:44 -!- p_q has changed nick to poiuy_qwert.
01:52:19 -!- poiuy_qwert has quit (Changing host).
01:52:19 -!- poiuy_qwert has joined.
01:55:19 -!- hagb4rd has quit (Ping timeout: 276 seconds).
02:24:54 <quintopia> careful beats wireless every time on one polarity, and vice versa on the other XD
02:25:27 <myndzi> i thought you meant you submitted wireless with a reversed polarity
02:25:51 <quintopia> fuckin polarities, how do they work
02:26:12 <quintopia> it's designed to work better on one polarity?
02:26:12 <myndzi> here, i'll even it out
02:26:57 <quintopia> geez man, wanna shorten that thing a bit?
02:27:21 <myndzi> ha, that actually didn't do what i thought it would
02:27:58 <myndzi> btw what are you doing, tweak2win? :P
02:28:33 <quintopia> well just now, i was just trying to figure out a way to beat shudder consistently, cuz the old version just basically beat it on length 30
02:28:53 <myndzi> who cares about shudder :P
02:29:13 <quintopia> well i already beat most everything else
02:29:24 <quintopia> wiggle3 is my bane, but i don't know what to do about that
02:29:47 <myndzi> wiggle3 -> set bigger decoys than it offsets
02:30:05 <myndzi> guess maybe you just attack too slow then
02:30:10 <myndzi> in the order it clears them
02:30:15 <myndzi> the first ones it clears are small
02:30:24 <myndzi> actually, i am misremembering
02:30:32 <myndzi> you just want to force it into the deepest loop
02:30:48 <myndzi> as for the thing with careful
02:30:51 <myndzi> it only attacks in one direction
02:31:06 <myndzi> so obviously if you have defensive mechanisms, decoys, etc. in the other direction it won't work well in that combination
02:31:23 <myndzi> i thought i could balance it out if i added an attack in the opposite direction but that didn't happen
02:32:07 <quintopia> my decoys are l2r, -127,129,-129,-19,18,-1,1
02:32:52 <myndzi> well wiggle was optimized agaisnt slowrush lol
02:33:02 <myndzi> so you go to 20 and it'll help
02:33:13 <myndzi> i actually cheated a little, bumped the decoys just a bit to get him back for that
02:33:22 <quintopia> nah, it looked like it was optimized against 20 when i read it
02:33:36 <myndzi> well yeah, he went one over
02:33:37 <quintopia> but yeah, those decoys worked better than 20 when i tested them
02:33:43 <myndzi> at the time every time i changed it he edited it to match
02:33:48 <myndzi> same with other people on the hill
02:34:24 <quintopia> it's a built-in game of the the traveller's dilemma :P
02:35:25 <myndzi> well you can see ais avoiding doing that sort of thing
02:35:44 <myndzi> i try to too, slowrush was a special case for me because it was back and forth between 1 and 2 with wiggle back then and now i get to have the last word ;)
02:35:53 <myndzi> apparently alternating attacks isn't enough
02:36:32 <quintopia> well, any idea how to stop drawing against shudder?
02:36:56 <myndzi> maybe you aren't reaching the last cell
02:37:03 <myndzi> oh, drawing on all BUT one
02:37:21 <quintopia> i think i can detect it, but no idea what sequence of shifts would kill it
02:37:36 <myndzi> you have to counter its attack
02:37:42 <myndzi> ++ when it -- or something
02:37:49 <myndzi> and at the right time, too
02:37:55 <myndzi> basically it's a waste of time
02:38:20 <quintopia> yeah, but it'll get me a lot of points without costing me in other matches, so....
02:38:25 <myndzi> i'm curious why our programs behave that way too
02:38:37 <myndzi> it will cost you in other matches
02:38:42 <myndzi> because you have to spend a lot of time on your attack to beat it
02:38:49 <myndzi> just tie with it and call it good
02:38:59 <myndzi> if you tie with it every round except the last one, that's enough to beat it actually
02:39:14 <myndzi> tying means don't fall out of the attack loop
02:39:26 <myndzi> you don't get more points for beating it more
02:39:45 <myndzi> afaik the only point gain is from win or loss
02:39:47 <myndzi> not how much you won or lost by
02:41:02 <quintopia> Each program gains one point per win and loses one point per loss, with ties
02:41:02 <quintopia> neither gaining nor losing points. The duel points have the range -84 to 84,
02:41:02 <quintopia> The sum of these duel points total is then divided by 84, the total number of
02:41:02 <quintopia> configurations, such that the point range is -M to M inclusive, where M is one
02:41:04 <quintopia> less than the total number of programs.
02:41:27 <myndzi> that's points, but you're ranked by score
02:41:36 <myndzi> score is based on the points of the programs you beat, yes?
02:41:40 <quintopia> Scores are derived from the basic points, but giving more emphasis to defeating
02:41:43 <quintopia> good programs. Every program is given a worth of (points+N)/(M*2), where N is
02:41:46 <quintopia> the number of programs and M is N-1.
02:42:09 <myndzi> maybe i should be optimizing a little more ;)
02:42:49 <quintopia> i can detect when i'm facing shudder already, and only do the long attack loop in that case
02:43:00 <quintopia> but i don't know what sequence will kill it fastest
02:43:22 <myndzi> well if you want both polarities you have to spend like 256 cycles on both
02:44:03 <myndzi> dunno by how much though
02:44:15 <myndzi> anyway look at it like this
02:44:20 <myndzi> shudder makes the flag cell sequence go:
02:44:30 <myndzi> 0 1 0 1 2 1 2 3 2 3 4 3 4 5....
02:45:02 <myndzi> so what you need to do is hit it with a - or + at the right time, and then you beat it
02:45:12 <myndzi> you can see that the 'right time' is basically every other cell
02:45:37 <myndzi> but you have to be lined up with it
02:45:51 <myndzi> let's see what happens if you do something like -..-..-..-..-..
02:46:36 <quintopia> i started to work it out like this on paper but then i was like BAH THIS WILL TAKE FOREVER
02:46:59 <quintopia> but that sequence is basically what i'm doing already, and it doesn't work
02:47:15 <myndzi> i am thinking out loud here ;p
02:47:19 <myndzi> obviously -. won't work properly
02:47:22 <quintopia> (i'm actually doing [+.] which is equivalent)
02:47:27 <myndzi> so you need a sequence that is relatively prime to its progress
02:47:50 <myndzi> +.. will not work better than -..
02:48:11 <myndzi> nah, that's a 4 cycle loop
02:48:15 <myndzi> oh, but i see what you mean
02:50:59 -!- cal153 has quit (Ping timeout: 240 seconds).
02:52:23 <myndzi> well, two cycles is relatively prime to 3
02:52:36 <myndzi> if it's a net positive, then a two cycle negative loop will beat it very slowly
02:52:48 <myndzi> now to try the reverse
02:53:07 <quintopia> how many cycles does it take there?
02:53:31 <myndzi> because it progresses at a rate of like 1 every 6
02:53:40 <myndzi> so it could be as much as 255*6
02:53:49 <myndzi> the problem is that if the polarity switches you're SOL
02:54:23 <myndzi> anyway unless you manage to get exactly in synch with it
02:54:29 <quintopia> what happens if you put a tripwire there
02:54:31 <myndzi> there isn't a real good solution
02:54:36 <myndzi> i was thinking about that just now
02:54:43 <myndzi> if you are guaranteed not to run this code unless you are facing shudder
02:54:50 <myndzi> then you should be able to synch up fairly easily
02:54:56 <myndzi> by waiting until it hits 0 on its own
02:55:04 <myndzi> then what you want to do is assume it's going one way
02:55:10 <myndzi> and attack in a way that would kill it
02:55:14 <myndzi> then wait again and do it the other direction
02:55:23 <myndzi> that's probably the fastest way to do it
02:55:49 <myndzi> [] checks at the beginning of the cycle
02:55:53 <myndzi> death checks at the end
02:56:01 <myndzi> so when your tripwire falls through
02:56:06 <myndzi> the cell will have moved on to the next instruction
02:56:15 <myndzi> and it hits 0 three times
02:56:31 <myndzi> to synch up you'd have to do some craziness actually
02:56:41 <myndzi> like, say that it is running +--
02:56:49 <myndzi> then when your code runs it will be -1
02:56:56 <myndzi> so to get it back to 0 for two cycles
02:57:15 <myndzi> you would have to run +.+
02:57:26 <myndzi> because the + would counteract the second -
02:57:30 <myndzi> . lets it bring itself to 0
02:57:33 <myndzi> and + counteract the first -
02:57:39 <myndzi> then you can have another loop to check if that failed
02:57:45 <myndzi> if so, you try another sequence
02:57:53 <myndzi> so you could have like
02:58:06 <myndzi> well there's timing remember
02:58:11 <myndzi> say it hits it on the second instruction
02:58:22 <myndzi> which could happen depending on when you arrive, i guess
02:58:30 <myndzi> i'd go with the most probable one first, which is to be on the 'leading edge'
02:58:35 <quintopia> but is there a sequence of additions that can cover multiple polarities and timings?
02:58:38 <myndzi> we'll assume you get there and you are waiting for it to find 0 on its own
02:58:54 <myndzi> maybe, but it's probably convoluted and takes a long time
02:59:04 <myndzi> but you've said we can "detect" it and therefore run specific code
02:59:07 <myndzi> so here's how i'd do it
02:59:08 <quintopia> so ++- is most likely to hit the second +
02:59:27 <myndzi> if it's a net positive, it will first hit 0 on the second +
02:59:39 <myndzi> your trip falls through and it will be running the backwards step
02:59:52 <myndzi> then when your code runs it is 0 again
03:00:13 <myndzi> if you ran [] when it wasn't in the middle of "being near zero"
03:00:17 <myndzi> and if it's a net negative
03:00:24 <myndzi> then it first hits zero on the second minus
03:01:08 -!- mtve has quit (Ping timeout: 255 seconds).
03:01:21 <myndzi> then it runs +--+-- and you run .- which makes it become -1 and it's on the second minus
03:01:30 <myndzi> so you counteract that with a +, making it -1 again
03:01:36 <myndzi> and it runs + making it 0
03:01:40 <myndzi> then you counteract the - with a +
03:02:11 <myndzi> unless you happen to enter [] in an unlucky spot
03:02:16 <myndzi> but that can be fixed by looping on the above code
03:02:48 <myndzi> !bfjoust shutter (>[[].-+.+])*29
03:03:15 <myndzi> damn, stop stealing my breakdown
03:03:21 <myndzi> i goofed on one polarity somehow
03:03:43 <EgoBot> Score for myndzi_shutter: 7.7
03:04:34 <zzo38> I would like to able to have something like: phrase("destroy",6,"target","creature") which "creature" might converted to and(is(entity.object.permanent),has_type(type.creature)) and then "target" to something like target(...) and then deal with multiple targets, with actions, and then move target(...) outside and make it referenced within the action, and so on...
03:04:36 <quintopia> welp...no luck...looks like i'm not detecting it right :P
03:04:55 <myndzi> well i can't help you there ;)
03:05:19 <myndzi> why would you copy paste my code and reenter it?
03:05:30 <myndzi> it's going to have the exact same result except you look like a dick! :p
03:05:34 <myndzi> besides i'm about to fix it
03:06:02 <quintopia> i didn't see the result the first time
03:06:04 <EgoBot> Score for quintopia_shutter: 7.7
03:06:24 <myndzi> !bfjoust shutter (>[[].-++])*29
03:06:28 <myndzi> off by one, always the problem
03:06:47 <myndzi> Vorpal_shudder.bfjoust vs myndzi_shutter.bfjoust:
03:06:47 <myndzi> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>
03:06:47 <myndzi> myndzi_shutter.bfjoust wins
03:07:06 <EgoBot> Score for myndzi_shutter: 9.9
03:07:08 <myndzi> waiting on the inverse one
03:07:15 <myndzi> myndzi_shutter.bfjoust vs quintopia_one_o_them_shudder_thangs.bfjoust:
03:07:15 <myndzi> <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<<
03:07:16 <myndzi> myndzi_shutter.bfjoust wins
03:08:54 -!- Slereah has quit (*.net *.split).
03:08:54 -!- shachaf has quit (*.net *.split).
03:08:57 <myndzi> !bfjoust shutter ----->+++++>(-)*25>(+)*25>>>>>(>[-][[].-++])*29
03:09:15 <EgoBot> Score for myndzi_shutter: 19.3
03:09:18 <myndzi> that didn't work out, forgot i could get stuck
03:09:23 <myndzi> !bfjoust shutter ----->+++++>(-)*25>(+)*25>>>>>(>[---][[].-++])*29
03:09:47 <myndzi> i don't want to use a loop based attack
03:10:05 <EgoBot> Score for myndzi_shutter: 27.4
03:10:13 <myndzi> !bfjoust shutter ----->+++++>(-)*25>(+)*25>>>>>(>(-)*128.[[].-++])*21
03:10:57 <myndzi> i guess i don't need the noop there
03:11:16 <EgoBot> Score for myndzi_shutter: 13.2
03:11:35 <quintopia> meh, the original wireless that ignores shudder gets more points :P
03:12:18 <quintopia> that there is some program that looks like shudder
03:13:08 <myndzi> why does that last one get ties
03:13:18 <myndzi> all it does is add a fixed attack?
03:13:33 <myndzi> i need to move after that
03:13:44 <Gregor> crapping_turtle <40 :(
03:14:09 <Gregor> First time ais hasn't been in the top two since the recent revival!
03:14:36 <myndzi> there, i tromp shudder perfectly again
03:15:13 <myndzi> but i get shit points against anything else
03:15:47 <myndzi> maybe a looping attack is ok, but i want to beat shudder 100% so i need to do something that will eventually fall out of alignment in any eventuality
03:16:23 <quintopia> your tripwire loop doesn't work for me. i need a graphical referee to see what is happening
03:16:41 <myndzi> assume you are looping when shudder is far away from zero
03:16:51 <myndzi> you mean it doesn't work when you put it in your code
03:16:54 <myndzi> it's obviously looping in the wrong place
03:17:00 <myndzi> be sure you don't run it after, say, making a cell nonzero
03:18:36 <myndzi> if [] is landing on shudder's cell, then it will work; that means if it doesn't work, it's not landing on shudder's cell
03:19:40 -!- x43112609 has joined.
03:19:57 <Gregor> !bfjoust i_regret_everythiiiiiiiiiing <
03:20:09 <EgoBot> Score for Gregor_i_regret_everythiiiiiiiiiing: 0.0
03:20:13 <myndzi> the sad thing is [---] gets the most points but doesn't 100% shudder
03:20:21 <myndzi> [--] gets fewer points but 100%s it
03:20:22 <quintopia> yeah, apparently it's not landing on shudder's flag because it isn't working
03:20:42 <myndzi> let's try with an offset clear
03:20:58 -!- cal153 has joined.
03:21:19 <quintopia> is there a bfjoust sim that lets me see what happened at each step of the match?
03:21:37 <myndzi> i thought about how handy it would be earlier today
03:22:02 <Gregor> !bfjoust i_regret_everythiiiiiiiiiing <
03:22:44 <EgoBot> Score for Gregor_i_regret_everythiiiiiiiiiing: 0.0
03:23:20 <Gregor> quintopia: Because I have magic powers.
03:23:25 <Gregor> x43112609: You'd better be armed with BFJoust programs X-P
03:25:35 <Gregor> quintopia: I'm still #16 :)
03:25:56 <quintopia> my score has gone down by 2 points since myndzi showed up :P
03:26:49 <quintopia> a bf joust debugger would be p neat though
03:27:16 <Gregor> x43112609: http://esolangs.org/wiki/BF_Joust
03:27:25 <Gregor> x43112609: And TECHNICALLY you don't have to do BFJoust here, but everybody else is right now :P
03:27:51 <quintopia> i would make one myself if i weren't so worried i screw the rules up when i wrote the interp :P
03:28:10 <Gregor> quintopia: EgoJoust is open.
03:28:12 <myndzi> you could always test for same results as the hill
03:29:22 <myndzi> you can modify the attack to not require a tripwire
03:29:50 <myndzi> you just have to understand that you can fall out of the loop at another point in the cycle
03:30:01 <myndzi> so you will have a longer attack
03:30:09 <myndzi> it'll go from 5 cycles to probably 20
03:30:29 <Gregor> !bfjoust rapping_turtle -(>+>-)*4>([(+)*120[+].+>]+>[(+)*120[+].->]->)*11
03:30:36 <myndzi> i may as well solve this while i'm at it
03:30:43 <EgoBot> Score for Gregor_rapping_turtle: 16.9
03:30:46 <quintopia> Gregor: yeah, but i'm no good at graphics in C
03:30:53 <myndzi> YO MY NAME IS MC TURTLE AND I'M HERE TO SAY / BRAINFUCK HURTS MY HEAD IN THE VERY BEST WAY
03:31:30 <myndzi> I SCOOT ALONG THE TAPE / MY SIGHTS ARE SET ON RAPE / BUT I'M SLOW SO WHEN I GO IT MAY JUST TAKE ALL DAY
03:31:42 <Gregor> !bfjoust rapping_turtle -(>+>-)*4>([(+)*126[+].+>]+>[(+)*126[+].->]->)*11
03:31:47 <myndzi> that was actually more of a limerick and only if you pronounce it weirdly
03:31:55 <myndzi> RIGHT so i'm going to solve shudder
03:31:57 <EgoBot> Score for Gregor_rapping_turtle: 17.5
03:33:10 <Gregor> !bfjoust rapping_turtle -(>+>-)*4>([(+)*112(+.)*32.+>]+>[(+)*112(+.)*32.->]->)*11
03:33:23 <EgoBot> Score for Gregor_rapping_turtle: 39.3
03:34:05 <Gregor> !bfjoust rapping_turtle -(>+>-)*4>([(+)*120(+.)*16.+>]+>[(+)*120(+.)*16.->]->)*11
03:34:16 <EgoBot> Score for Gregor_rapping_turtle: 40.0
03:34:24 <quintopia> Gregor: i love how dirk hangs on so diliGENTLY
03:34:30 <quintopia> even though it hits the bottom regularly
03:34:49 <Gregor> !bfjoust rapping_turtle (-)*64(>+>-)*4>([(+)*120(+.)*16.+>]+>[(+)*120(+.)*16.->]->)*11
03:35:00 <EgoBot> Score for Gregor_rapping_turtle: 31.7
03:35:09 <quintopia> Gregor: do the points add up to zero?
03:35:13 <Gregor> !bfjoust rapping_turtle -(>+>-)*4>([(+)*120(+.)*16.+>]+>[(+)*120(+.)*16.->]->)*11
03:35:27 <Gregor> quintopia: In principle, modulo rounding error on output.
03:35:33 <EgoBot> Score for Gregor_rapping_turtle: 40.0
03:35:46 <quintopia> so this is a zero sum game. neat :P
03:36:01 <Gregor> quintopia: Points are not the final score.
03:36:10 <Gregor> quintopia: And score does not add to anything meaningful.
03:36:21 <Gregor> !bfjoust snapping_turtle <
03:36:31 <EgoBot> Score for Gregor_snapping_turtle: 0.0
03:36:55 <Gregor> quintopia: http://codu.org/eso/bfjoust/SCORES
03:37:33 <quintopia> Gregor: yeah, i was just about to suggest you rewrite that so it didn't take a million years of reading to figure out what it means
03:37:58 -!- x43112609 has left (?).
03:38:06 <Gregor> Didn't think he'd last :P
03:38:26 <Gregor> quintopia: It's really not that complicated X-P
03:38:37 <quintopia> then why is the description so complicated
03:39:37 -!- Slereah has joined.
03:39:37 -!- shachaf has joined.
03:40:10 <Gregor> #1: I do believe I am blind as a fucking bat.
03:40:10 <Gregor> Me: "Most species of bats have a second set of opaque eyelids which close only during sexual intercourse, protecting the eyes from damage due to mid-coital scratching or biting." -- Wikipedia
03:40:10 <Gregor> Hmm. Did not know. Explains the post though.
03:40:10 <Gregor> #3: My favorite part is you looking that up.
03:40:20 <Gregor> My favorite part is being able to make pseudowikipedia that people apparently think is real :P
03:41:43 <quintopia> i think you should add it to wikipedia
03:41:52 <quintopia> and preemptively tag it with citation needed
03:42:05 <Gregor> I was thinking citing something irrelevant.
03:48:13 -!- pingveno has quit (Ping timeout: 255 seconds).
03:54:16 <myndzi> universal shudder killer:
03:54:55 <myndzi> you have to let me be the first to submit though
03:55:16 -!- pingveno has joined.
03:55:16 <quintopia> go quick cuz i'm about to stick it in wireless to see what happens
03:56:02 <myndzi> not even gonna bother trying to alter the timings
03:56:06 <myndzi> i am content it should work
03:56:22 <quintopia> you have to add ---- to the end if it's in a loop right?
03:56:25 <myndzi> turned out to be simpler than i thought
03:56:34 <myndzi> you don't need to loop this
03:57:01 <quintopia> but i need to be in a loop to detect i need it in the first place XD
03:57:10 <myndzi> or at least the last cell should not be + or -
03:57:31 <myndzi> it doesn't have to be this long, the original would work fine most times
03:57:36 <myndzi> but this handles all fringe cases
03:57:43 <myndzi> it works on net positive and net negative
03:57:52 <myndzi> if the loop falls through after any time it hits 0
03:58:04 <myndzi> there are three times it can hit zero
03:58:22 <myndzi> so if you want a loop to fall through
03:58:24 <myndzi> you need . so shudder dies
03:58:30 <myndzi> then put it back to zero
03:58:34 <myndzi> then the loop will fall through properly
03:58:41 <myndzi> if it's not shudder, then no probz
03:58:47 <myndzi> i wonder if some of my programs can benefit from this
03:58:57 <myndzi> i don't know if they consistently win against those two or what
03:59:34 <myndzi> careful and careless don't use loops so it wouldn't apply to them, they probably lose some and there's not much help
03:59:37 <myndzi> slowrush might benefit though
04:01:43 <myndzi> there's ONE program on the hill making it this slow lol
04:02:04 <quintopia> !bfjoust good_vibrations (++--+++)^100000
04:02:10 <myndzi> and the others i guess
04:02:16 <quintopia> !bfjoust good_vibrations (++--+++)*100000
04:02:22 <myndzi> we don't need that shit ;p
04:03:18 <quintopia> defend13 does surprisingly well for being so easy to beat
04:04:39 <myndzi> hahah you still fail against shudder
04:05:08 <quintopia> i still can't figure out what i'm doing wrong against it
04:05:24 <EgoBot> Score for quintopia_good_vibrations: 23.5
04:05:25 <EgoBot> Score for quintopia_good_vibrations: 23.5
04:06:44 <myndzi> i didn't implement it right in slowrush either when i tried that
04:08:42 -!- zzo38 has quit (Remote host closed the connection).
04:09:17 <quintopia> !bfjoust superfast_jellyfish (>([{+[--[(-[{(+)*22[.+].--++++++.----}])%22]]}])%4)*29
04:09:39 <EgoBot> Score for quintopia_superfast_jellyfish: 17.4
04:11:00 <myndzi> gonna stop messing with stuff
04:11:18 <myndzi> remember, the loop has to exit
04:12:12 <myndzi> probably not getting stuck
04:12:38 <myndzi> but are you sure that syntax even works?
04:13:54 <quintopia> it may be broked. i was wrong about beating defend13
04:14:47 <quintopia> !bfjoust when_will_it_explode (>[.+].--++++++)*29
04:15:38 <EgoBot> Score for quintopia_when_will_it_explode: 23.0
04:16:43 <quintopia> it ties with shudder for all of two polarities and half of the other two
04:19:59 -!- myndzi\ has joined.
04:21:00 <myndzi\> is it exiting the loop, is the question
04:21:20 <myndzi\> ----->+++++>(-)*25>(+)*25>>>>>(>[--].--++++++)*21
04:21:38 <myndzi\> hmm, i think i may have forgotten something important
04:21:49 <myndzi\> let me see how this plays out if the last instruction before ] is a math instruction
04:22:17 <myndzi\> result (you + enemy) = 0, ] falls through
04:22:22 -!- myndzi has quit (Ping timeout: 240 seconds).
04:22:26 <myndzi\> this is different from it reaching 0 naturally
04:22:43 <myndzi\> but it can't happen if you oppose the enemy, only if you are moving in the same direction
04:22:46 <myndzi\> which means it is premature
04:29:41 -!- augur has quit (Remote host closed the connection).
04:31:31 <myndzi\> that assumes the + "helped" it along
04:31:49 <myndzi\> though to be honest my head is severely hurting from this spreadsheet being hard to read
04:31:52 -!- myndzi\ has changed nick to myndzi.
04:32:23 <myndzi> i synched it up so that the + in the loop makes it hit 0 in each of the three places
04:32:30 <myndzi> for each of the six cases
04:32:39 <quintopia> !bfjoust superfast_jellyfish (>([{+[--[(-[{(+)*22[.+]--.--+++++++++.-----}])%22]]}])%4)*29
04:32:50 <myndzi> it's interesting that a straight row of +s or -s at the right location takes care of it
04:33:02 <EgoBot> Score for quintopia_superfast_jellyfish: 17.3
04:33:04 <myndzi> we only really shortcut this for one direction
04:33:14 <quintopia> which is why (+)*10000 probably works
04:33:41 <myndzi> actually i guess it's obvious that a straight row of +/- takes care of it
04:33:45 <quintopia> Vorpal_shudder.bfjoust vs quintopia_superfast_jellyfish.bfjoust:
04:33:45 <quintopia> XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX
04:33:57 <myndzi> you're obviously doing it wrong
04:34:09 <myndzi> i already did, with my original thing!
04:34:18 <myndzi> why don't you just go like
04:34:49 <myndzi> also that wasn't an insult, it was t + wat
04:35:26 <myndzi> i have no idea why it would tie
04:35:30 <myndzi> but try the simpler one
04:35:46 <myndzi> i want to at least see that that works
04:36:06 <myndzi> the instruction immediately before ] can skew it, that's why i had to revise
04:36:11 <quintopia> !bfjoust simpler_one (>[.+]--.--+++++++++.-----)*29
04:36:38 <EgoBot> Score for quintopia_simpler_one: 9.8
04:36:41 <myndzi> i made a shorter sequences
04:36:49 <quintopia> Vorpal_shudder.bfjoust vs quintopia_simpler_one.bfjoust:
04:36:50 <quintopia> XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX
04:36:51 <myndzi> i started in the wrong direction that's why it was so long
04:37:07 <quintopia> i think your spreadsheet is lying to you
04:37:35 <myndzi> !bfjoust wat (>[.+]++.-------)*29
04:37:57 <EgoBot> Score for myndzi_wat: 25.3
04:38:07 <myndzi> !bfjoust wat (.>[.+]++.-------)*29
04:38:14 <quintopia> Vorpal_shudder.bfjoust vs myndzi_wat.bfjoust:
04:38:14 <quintopia> XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXX
04:38:16 <myndzi> whoops, did that wrong
04:38:23 <myndzi> !bfjoust wat .(>[.+]++.-------)*29
04:38:26 <EgoBot> Score for myndzi_wat: 26.7
04:38:29 <myndzi> i'm trying to use your attack loop
04:38:40 <myndzi> instead of the one i used, which worked :P
04:39:02 <myndzi> !bfjoust wat ..(>[.+]++.-------)*29
04:39:13 <quintopia> the one you used would fail against timing based progs like defend7
04:39:14 <EgoBot> Score for myndzi_wat: 24.8
04:39:15 <EgoBot> Score for myndzi_wat: 24.8
04:39:15 <myndzi> anyway, as you can see it is a timing issue
04:39:31 <myndzi> i skew the cycles by one and get different results
04:39:45 <myndzi> i think it must be missing the 0 on those ties
04:39:47 <myndzi> getting stuck infinitely
04:40:06 <myndzi> and you only win sometimes when it lines up with the -
04:40:33 <myndzi> instead of -1 0 1 0 1 2 1 2 3 it goes like
04:40:52 <myndzi> make the cycles something that will wind up at 0 at some point
04:42:02 <myndzi> with my original pattern even
04:42:13 <myndzi> shutter: ----->+++++>(-)*25>(+)*25>>>>>(>[--].--++++++)*21
04:42:19 <myndzi> well, change the pattern
04:42:29 <myndzi> just don't change it to something that can synch up in certain tape lengths
04:42:45 <myndzi> though that'll be trickier to calculate
04:42:48 <myndzi> it'd have to be something like
04:42:50 <quintopia> !bfjoust shutter2 ----->+++++>(-)*25>(+)*25>>>>>(>[---].--++++++)*21
04:42:54 <myndzi> and then crazier stuff
04:43:06 <EgoBot> Score for quintopia_shutter2: 27.4
04:43:19 <myndzi> also: make your own damn spreadsheet ;p
04:43:25 <myndzi> this shit goes A through U
04:43:34 <myndzi> only reason i can read it at all is conditional formatting
04:43:59 <myndzi> could probably make a program to calculate what must trail a loop of any kind
04:44:27 <myndzi> needs to wait till i get home though
04:44:31 <myndzi> still at work, it's 9pm jesus
04:47:52 -!- poiuy_qwert has quit (Quit: This computer has gone to sleep).
04:48:50 -!- poiuy_qwert has joined.
04:57:45 <quintopia> i came up with one that gets a slightly lower score than before but beats all the shudders...i think i'm gonna leave it like that :P
04:59:14 -!- augur has joined.
04:59:41 <quintopia> oh wait, no i'm not. because it loses to decoytuner and decoybooster2 now :P
05:00:50 -!- Sgeo has quit (Read error: Connection reset by peer).
05:01:16 -!- Sgeo has joined.
05:11:55 -!- poiuy_qwert has quit (Ping timeout: 272 seconds).
05:12:32 -!- poiuy_qwert has joined.
05:19:35 -!- asiekierka has joined.
05:23:57 -!- Sgeo_ has joined.
05:24:12 -!- Mathnerd314 has quit (Remote host closed the connection).
05:24:32 <myndzi> right, so i was making things too complicated i think
05:24:39 <myndzi> it's easier to go through this in my head than messing with a spreadsheet
05:24:48 <myndzi> if the instruction before ] is a -, here are the cases
05:25:36 <myndzi> polarity --+, first instruction: double-decrement; it can hit 0 if it was 2, then it goes to -1, then it goes to 0 on its own
05:26:17 <myndzi> polarity --+, second instruction: double-decrement; it can hit 0 if it was 2, then it goes to 1, then it goes to 0 on its own
05:26:21 -!- Sgeo_ has quit (Read error: Connection reset by peer).
05:26:43 -!- Sgeo has quit (Ping timeout: 240 seconds).
05:26:44 <myndzi> polarity --+, third instruction: net change: 0; it cannot hit 0, the loop will never fall through
05:26:46 -!- Sgeo_ has joined.
05:26:59 <myndzi> in the f irst two cases, the next instruction is - and so you should increment to kill it
05:27:56 <myndzi> leaving only the other polarity cases to deal with
05:28:19 <myndzi> polarity ++-, first instruction: no change; it cannot hit 0, the loop will not fall through
05:28:23 <myndzi> polarity ++-, second instruction: no change; it cannot hit 0, the loop will not fall through
05:29:03 <myndzi> polarity ++-, third instruction: double decrement; it can hit zero if it was at 2; then it goes to 1, 2, 2 during the ] . +
05:30:05 <myndzi> the next two instructions are + so we have to ward it off: --
05:30:16 <myndzi> the one after is -, so - gives us a double decrement, bringing us to zero
05:30:31 <myndzi> and finally the one after that is a +, so one more - seals the deal
05:31:17 <myndzi> therefore: a loop concluding in -].+---- should kill all shudders
05:31:30 <myndzi> so long as the timing resolves such that it can fall through
05:32:38 <quintopia> well, i determined that using [.-] as the kill loop works much better than basically any thing else, so i gave up on expecting to be able to kill shudder without ruining my score
05:33:10 <myndzi> interestingly, my modified shutter does much worse
05:33:17 <myndzi> even though it has a simpler kill
05:33:51 <quintopia> your new shutter appears to kill good_vibrations too
05:33:57 <myndzi> ...that was my initial conclusion ;P
05:34:42 <quintopia> not 100% like with the other shudder
05:34:54 <myndzi> only when it lines up with the same set of instructions
05:35:12 <myndzi> i'm sure i could extend it to cover that but then someone would just make a bigger one and ugh
05:35:30 <quintopia> i bet it would fare well against almost all shudders that do okay though
05:35:58 <quintopia> the real trick here is to figure out what to put after ?-][
05:36:10 <quintopia> so you don't do anything if it's *not* shudder
05:36:26 <quintopia> ---.+++++++++. works but that's long
05:36:53 <myndzi> well see what i said above; it's going to be zero in that cell
05:37:03 <myndzi> so it will skip it even if it is shudder
05:37:08 <myndzi> you would have to add a .
05:37:14 <myndzi> then make a longer loop
05:37:28 -!- Sgeo__ has joined.
05:38:10 <myndzi> like i said, you'd just have to add more instructions
05:38:18 <myndzi> it can be so short because you catch it at a convergence
05:38:26 <myndzi> but the longer you wait, the more you have to struggle to swing to the other side
05:38:52 <myndzi> look at what i said above
05:38:55 <myndzi> figure it out for yourself
05:39:09 <quintopia> you said something along the lines of tl;dr
05:39:44 <myndzi> look man, there's only so much work i'm going to do for YOU
05:39:53 <myndzi> i have satisfied myself
05:39:58 <myndzi> if you aren't satisfied, then do some damn homework
05:40:13 <myndzi> i laid it out quite simple above, just extend the pattern
05:40:19 -!- Sgeo_ has quit (Ping timeout: 240 seconds).
05:40:22 <quintopia> and trying to make heads or tails of it
05:40:30 <myndzi> i went through every applicable case
05:40:53 <myndzi> only three cases where a -] loop will end when executing on a "shudder cell"
05:42:38 <quintopia> oh i see what format you're writing it out in now
05:42:57 <quintopia> "second instruction" means "the second of the three coincides with the - inside the loop"
05:45:05 <myndzi> here, i've got a good form for you
05:45:23 <myndzi> yeah, but this will look so obvious
05:47:08 <myndzi> yeah it makes it super long
05:47:34 <myndzi> but, it may be that you can use the second loop to your advantage to make the code succinct
05:47:38 <myndzi> not that it matters since it's gonna skip all this
05:48:12 <quintopia> i could spell out the cases like you do
05:48:17 <myndzi> Shudder : - - + - - + -
05:48:17 <myndzi> Attacker: - ] . [ + . +
05:48:17 <myndzi> Cell Val: 0 -1 0 -1 -1 0 0
05:48:17 <myndzi> Shudder : - + - - + - -
05:48:17 <myndzi> Attacker: - ] . [ + . +
05:48:20 <myndzi> Cell Val: 0 1 0 -1 1 0 0
05:48:37 <myndzi> actually i guess they are equivalent
05:48:56 <myndzi> and yeah, the long string of -s is necessary
05:49:05 <myndzi> it only goes down by one every three cycles
05:49:18 -!- cal153 has quit (Ping timeout: 240 seconds).
05:49:34 -!- cal153 has joined.
05:49:50 <myndzi> it should only enter that loop if you are running on a shuddering program
05:50:01 <quintopia> -].[.++--------.++++++] will do it
05:50:04 <myndzi> so it's kinda pointless to try and bring it back to what it was at the start
05:50:11 <myndzi> you also don't need to pause
05:50:25 <quintopia> wasn't sure whether i finished it or not
05:50:27 <myndzi> and all of them are required
05:50:37 <myndzi> Shudder : - + + - + + - + + - + + - + + - + + - +
05:50:38 <myndzi> Attacker: - ] . [ + . + - - - - - - - - - - - - -
05:50:38 <myndzi> Cell Val: 0 1 2 1 3 4 4 4 4 3 3 3 2 2 2 1 1 1 0 0
05:51:16 <quintopia> - + + - + + - + + - + + - + + - + +
05:51:29 <myndzi> that's the third case: the opposite polarity
05:53:16 <myndzi> but i counted wrong, you're right
05:53:39 -!- nddrylliog has joined.
05:54:04 <quintopia> good point about not trying to make it match up tho
06:00:45 -!- nddrylliog has quit (Ping timeout: 240 seconds).
06:01:30 <quintopia> wireless_frownie not pwns shudder and outscores wireless
06:01:53 -!- pikhq_ has joined.
06:01:56 -!- pikhq has quit (Ping timeout: 255 seconds).
06:02:59 <myndzi> seems to me the beest way to beat them all is just to rely on a loop that doesn't synch up and takes advantage of the -+ switch
06:03:03 -!- sebbu has quit (Read error: Connection reset by peer).
06:03:10 <myndzi> it always switches from + to - regardless of polarity
06:03:32 -!- sebbu has joined.
06:04:49 <quintopia> it only beat wireless because it beat wireless
06:05:09 <quintopia> when i remove the original wireless...the new one sucks
06:05:33 <quintopia> soooo...back to the one that loses :P
06:07:53 -!- asiekierka has quit (Ping timeout: 246 seconds).
06:30:06 -!- pikhq_ has changed nick to pikhq.
06:45:39 <quintopia> Gregor: is there a max depth that ({})% can be expanded?
07:31:10 -!- Sgeo_ has joined.
07:34:10 -!- Sgeo__ has quit (Ping timeout: 260 seconds).
07:53:10 -!- oerjan has joined.
07:53:58 -!- MigoMipo has joined.
07:56:27 <oerjan> <myndzi> someone doesn't know the difference between dcc and msg? <-- EgoBot uses dcc for responses of more than one line. msg would be inappropriate when the response can be up to 4096 characters (iirc)
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:04:55 <oerjan> hm... (a(b{c{d}e}f)%m g)%n as an abbreviation of (a(b)*m c))*n d (e(f)*m g)*n is actually perfectly effectively executable
08:05:24 <oerjan> if the former matches []'s textually
08:08:37 <oerjan> ((a[b)*p)*q((c]d)*q)*p would be a bitch to expand
08:08:42 <quintopia> anyway, it doesn't work in egojoust
08:09:03 <quintopia> when the constant is too large it fails to parse
08:09:06 <oerjan> quintopia: i'm not sure anyone has thought of this before
08:09:29 <quintopia> oerjan: are you going to reimplement egojouse to work and work quickly?
08:09:35 <oerjan> quintopia: egojoust expands ({})% textually, as you know
08:10:03 <oerjan> quintopia: i'm not sure if i have the sufficient initiative
08:10:17 <oerjan> but i _do_ have ideas for how it _could_ be done
08:11:03 -!- pikhq has quit (Ping timeout: 240 seconds).
08:11:10 -!- pikhq has joined.
08:11:17 <oerjan> right now i'm pondering how to convert the currently accepted format to something which _does_ have lexically matching [], for which that (({{}})%)% notation would be _very_ useful
08:11:56 <oerjan> however for that ((a[b)*p)*q((c]d)*q)*p is a problem
08:12:20 <oerjan> (imagine p and q being primes, any expansion has to do that one fully afaict
08:12:48 <oerjan> (imagine a b c d don't contain [])
08:13:39 <oerjan> because i am thinking that a conversion preprocessing stage would be a bitch to do in C, but you only needed to do it once for each program and the _result_ would be easy to interpret in C
08:15:07 <fizzie> oerjan: Isn't that particular one just identical to (a[b)*<p*q>(c]d)*<p*q> = (a[b{}c]d)%<p*q> (where <p*q> means substitute-the-product) since you don't have anything else inside the two "top-level" parens?
08:16:11 <oerjan> fizzie: sheesh i _tried_ to put a b c d to avoid such a simple fix
08:16:25 <oerjan> ok you need content somewhere else in that
08:17:02 <oerjan> (a([b)*p)*q c((]d)*q)*p perhaps?
08:18:12 <fizzie> That sounds more problematical, though maybe (c(]d)*q)*p as the latter half for symmetry?
08:21:51 <oerjan> hm maybe even (a([b[)*p)*q(c(]d])*q)*p
08:22:54 -!- FireFly has joined.
08:23:13 <fizzie> For the first one, p=3, q=5 → a[b[b[b a[b[b[b a[b[b[b a[b[b[b a[b[b[b c]d]d]d]d]d c]d]d]d]d]d c]d]d]d]d]d → a [b[b [ba [b [b [ba [b[b [ba [b [b [ba [b[b [bc] d]d] d] d] dc] d] d]d] d] dc] d] d] d]d] d which does look quite messy.
08:23:26 -!- hagb4rd has joined.
08:23:35 <oerjan> (a([b[)*p)*<3*q>(c(]d]])*q)*<2*p>, now the expansion won't even preserve textual matching of parentheses
08:24:05 <oerjan> well obviously since there aren't the same number of [ and ] textually
08:24:19 -!- mtve has joined.
08:29:29 <oerjan> quintopia: oh the expansion numbers have a limit of 10000
08:29:50 <oerjan> anything not between 0 and 10000 is turned into 10000
08:30:06 <quintopia> oerjan: in egojoust it breaks if you use anything above like 20
08:30:21 <oerjan> however this check afaict doesn't happen if the loop isn't expanded
08:30:29 <oerjan> quintopia: hm that's weird
08:34:19 <quintopia> oerjan: this is why wireless_frownie's code is so damn ugly at the moment. the compressed version always failed to parse
08:41:12 <oerjan> hm perhaps there is an actual bug there, and not just the size of the resulting expansion
08:45:36 -!- ndd has joined.
08:45:48 -!- ndd has changed nick to nddrylliog.
08:46:23 -!- nddrylliog has quit (Client Quit).
08:46:41 -!- nddrylliog has joined.
08:46:46 -!- nddrylliog has quit (Client Quit).
08:47:11 -!- nddrylliog has joined.
08:52:13 <oerjan> given that you imply it works for values < 20, seems a bit strange
08:52:55 <quintopia> i never figured out exactly what value it first failed for
08:53:12 <quintopia> but i think it still failed sometimes for 19
08:53:34 <quintopia> (depending on whether the loops had to ever be expanded)
08:58:50 <oerjan> hm i'm detecting some dubious testing for the _end_ of the program during the iteration
08:58:57 <oerjan> for (i = 0; i < prog.bufused; i++) {
08:59:13 <oerjan> but while expanding he is _not_ keeping prog.bufused accurate
08:59:44 <oerjan> because he is ignoring the length of the actual iteration _number_
09:00:21 <oerjan> prog.bufused = prog.bufused - llen - 2 + temp.bufused;
09:00:50 <quintopia> so, if it expands so that the brackets fall off the *old* end of the program, it might come up that they look mismatched to the parser
09:00:57 <oerjan> it is _possible_ that he could be parsing uninitialized memory at the end
09:01:26 <quintopia> not sure what you're saying then :P
09:01:40 <oerjan> i don't think his code actually _copies_ anything into a wrong place
09:02:12 <oerjan> quintopia: he is using realloc. realloc gives no guarantee on the contents of the buffer outside the already used part, iiuc
09:02:46 <oerjan> quintopia: the thing is that after expansion his variable for telling the _length_ of the program might be too large
09:03:40 <quintopia> so what would be better? calloc a whole new bit of memory and copy to it when realloc doesn't give back enough memory?
09:03:46 <fizzie> "#esoteric is not a very noob-friendly channel, and you can expect to receive abuse at the drop of a hat" -- what, are we really that angry?
09:04:21 <oerjan> quintopia: what does realloc not giving back have to do with this?
09:04:32 <oerjan> fizzie: THE ELLIOTT FACTOR
09:05:11 <quintopia> iunno oerjan. i don't understand exactly what the problem here is
09:05:26 <quintopia> fizzie: i was referring to the elliott factor, as oerjan said.
09:05:51 <quintopia> "you people are as like as not idiots, so you should probably not talk"
09:06:02 <quintopia> but that would be insulting to the ones who aren't idiots
09:06:30 <oerjan> quintopia: MAYBE _YOU_ SHOULD PROBABLY NOT TALK
09:06:55 * oerjan swats quintopia -----###
09:07:45 <fizzie> Perhaps a CHATroom. What, I get a "Tr" ligature on this input line?
09:08:41 <fizzie> Maybe it's just a kerning thing now that I look closely enough; the r is under the T though.
09:08:59 <oerjan> quintopia: oh f wait i found a much worse bug in the size calculation
09:09:38 <oerjan> he is _reusing_ llen only inside the % code for a _much_ smaller part only from ( to { ...
09:10:10 <oerjan> the _same_ llen that he is later using to calculate the size of the final program
09:11:04 <oerjan> ok so basically he is overestimating the program size after expansion, _particularly_ much if using ()%
09:11:39 <oerjan> and the more he overestimates, imho, the more likely he might end up interpreting uninitialized memory
09:13:42 -!- poiuy_qwert has quit (Ping timeout: 276 seconds).
09:14:16 <oerjan> @tell Gregor I have been looking a bit at your egojoust parsing code and i think you are miscalculating the new size of the program after expansion, particularly if using ({})% (you are clobbering llen for a different use) but also elsewhere (ignoring the atoi length). might you not end up looking at unitialized memory?
09:14:28 <nddrylliog> fizzie, technically speaking they *are* in a room.
09:15:03 <quintopia> from which we access the same channel
09:16:34 <fizzie> Are you sure oerjan is in a room instead of, say, a cave? (I can easily picture him in a cave.)
09:16:51 -!- poiuy_qwert has joined.
09:16:56 <oerjan> well this _looks_ like a room.
09:17:05 <fizzie> You know, the "bearded recluse of which the local populace tell strange stories of" style of cave.
09:17:45 <oerjan> fizzie: i recall we had one such here in trondheim, not sure if he still lives outside
09:18:46 <oerjan> there's also a recent more national example... hm latest i heard he had managed to attract fleas or something from animals
09:19:12 <quintopia> if i could find a virgin one and lock it up
09:19:25 <quintopia> i'd totes build something just inside the entrance
09:20:29 <quintopia> i was thinking that if i got rich one day, i'd add speleothems and slanted floors and stuff in the basement so i could feel like i was in a cave
09:20:38 <oerjan> @tell Gregor I started looking because quintopia tells he cannot get ({})% to use with iteration count more than 20 or so, at least if the contents are slightly complicated iiuc
09:21:29 <oerjan> quintopia: well if that actually _affects_ things...
09:21:59 <oerjan> and he might be more likely to take a look if the bug actually affects something...
09:22:37 <oerjan> although i'm not sure they're _really_ related, i don't see how the calculation bug would be affect by the actual iteration size used
09:24:34 <oerjan> oh hm i see, the memmove(prog.buf + i + temp.bufused, prog.buf + end + 1, prog.bufused - end - 1);
09:24:40 <oerjan> might interact with this
09:25:36 <oerjan> in fact it might be that _that_ line breaks things more horrible but only due to a _nested_ expansion when prog.bufused has _already_ been miscalculated
09:26:59 <oerjan> @tell Gregor the interaction of this with memmove(prog.buf + i + temp.bufused, prog.buf + end + 1, prog.bufused - end - 1); after a _nested_ expansion when prog.bufused has _already_ been miscalculated particularly worries me, that _could_ be the case giving quintopia problems...
09:27:01 <quintopia> i was putting ()* inside of ({})% when it happened
09:27:46 <quintopia> gregor is going to get a flood when he next talks and it will be hilarious
09:28:25 <oerjan> quintopia: lambdabot initially only tells him there _is_ a message
09:29:04 <oerjan> yes. the ({})% is expanded first, giving a particularly wrong calculation of prog.bufused (basically, approximately by the length between { and ) )
09:29:24 <quintopia> it was cpressey's bot that just said it without any prelude
09:30:17 <oerjan> if this is large enough then when the program is rearranged uninitialized memory will end up _inside_ the program
09:35:28 <oerjan> hm wait no i don't think that memmove actually can do that
09:36:37 <oerjan> the prog.bufused is only used to tell how _much_ to copy, and it will only end up beyond the program anyway
09:39:09 <quintopia> @tell Deewiant maglev currently draws with shudder. it's easy to make it beat it. just change the the *21 to *20>(.+)*10000. this shouldn't hurt its performance elsewhere much at all.
09:41:11 <Deewiant> !bfjoust maglev (>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(+)*9[-]])*20>(.+)*10000
09:41:11 <lambdabot> Deewiant: You have 1 new message. '/msg lambdabot @messages' to read it.
09:41:18 <oerjan> oh wait the atoi thing is _not_ a problem because he doesn't actually _remove_ the number from the program. or wait...
09:41:43 <EgoBot> Score for Deewiant_maglev: 47.4
09:42:16 <Deewiant> Loses to egodeath instead of drawing with it now, but still a net improvement, yes
09:43:35 <quintopia> you could also try the anti-shudder trick myndzi and i worked out earlier. it might work for you even better.
09:43:42 <quintopia> or it may not be worth the effort :P
09:51:48 <quintopia> i don't understand decoybooster2 at all at all
09:52:18 <quintopia> why would he set that decoy to size 85, then decrease it to 42? wouldn't it make more sense to increase it to 128?
09:55:02 <oerjan> @tell Gregor actually won't the memmove(prog.buf + i + temp.bufused, prog.buf + end + 1, prog.bufused - end - 1); end up copying the ) as well... _that_ would surely be a problem when nesting...
09:56:07 <oerjan> @tell Gregor Scratch that last, i cannot read. also the atoi length is of course not a problem. the reuse of llen inside the % branch still is, i believe.
09:58:31 <oerjan> quintopia: i think i was wrong about there being something subtly wrong with the ()* case as well, i realize it doesn't _matter_ if the *n (or %n for that matter) is left in the program after expansion
09:59:43 <lambdabot> tell provides: tell ask messages messages? clear-messages
09:59:52 <lambdabot> clear-messages. Clears your messages.
10:00:41 <oerjan> it doesn't say whether it's messages sent or received though...
10:02:56 <oerjan> @tell gregor Summary (I don't know whether the previous messages were cleared or not): i think the reuse of llen in the % branch of egojoust.c's parseFile function is a problem that causes the prog.bufused to be calculated wrong when using ({})%, conceivable leading to reading of unitialized memory
10:10:41 <oerjan> seems @clear-messages clears messages _to_ you, not from you :D
10:28:45 -!- cheater- has quit (Ping timeout: 240 seconds).
10:29:55 -!- cheater- has joined.
10:30:15 <oerjan> xkcd is synchronistic with bfjoust today
10:33:07 <fizzie> Now I have spurious )s after seeing those on multiple channels.
10:36:33 -!- ineiros has quit (Ping timeout: 246 seconds).
10:36:50 -!- ineiros has joined.
10:40:58 -!- cheater- has quit (Ping timeout: 240 seconds).
10:42:08 -!- cheater- has joined.
10:46:30 -!- nescience has quit (Quit: -a-).
10:46:50 -!- nescience has joined.
11:18:25 -!- BeholdMyGlory has joined.
11:48:13 -!- nddrylliog has quit (Quit: Leaving).
11:50:43 -!- sebbu has quit (Ping timeout: 250 seconds).
11:50:56 -!- poiuy_qwert has quit (Ping timeout: 240 seconds).
11:52:01 -!- poiuy_qwert has joined.
12:13:22 -!- Tritonio has joined.
12:16:51 -!- Tritonio has quit (Client Quit).
12:35:39 -!- Phantom_Hoover has joined.
12:58:30 -!- Tritonio has joined.
13:00:27 -!- Tritonio has quit (Client Quit).
13:00:32 -!- elliott has joined.
13:01:08 -!- pikhq has quit (Ping timeout: 255 seconds).
13:01:13 -!- pikhq_ has joined.
13:01:19 -!- elliott_ has joined.
13:01:20 -!- elliott_ has quit (Client Quit).
13:01:22 <elliott> 02:00:48 <myndzi> someone doesn't know the difference between dcc and msg?
13:01:31 <elliott> myndzi: oh i thought you meant egobot
13:01:35 <elliott> which sends errors via dcc chat
13:01:55 <elliott> 02:49:59 <quintopia> well just now, i was just trying to figure out a way to beat shudder consistently, cuz the old version just basically beat it on length 30
13:01:55 <elliott> 02:50:08 <quintopia> still haven't quite got it
13:01:58 <elliott> quintopia: submit in channel dammit
13:03:00 -!- Behold has joined.
13:06:30 -!- BeholdMyGlory has quit (Ping timeout: 260 seconds).
13:07:49 <elliott> $ time ~/Code/shiro/shiro mycology.b98 >/dev/null 2>&1
13:11:33 <elliott> that's before porting forwards my optimised mergeByteString
13:17:15 <elliott> $ time ~/Code/shiro/shiro mycology.b98 >/dev/null 2>&1
13:17:24 <elliott> Only 900x speed improvement before I equal or beat cfunge
13:17:47 <oerjan> small piece of cake, clearly
13:18:07 <elliott> Actually CCBI only does Mycology in 0.94 to 0.73 seconds here.
13:18:14 <elliott> So it's more like 10x-20x-30x improvement.
13:18:23 <elliott> Which is totally feasible.
13:18:34 <elliott> I'm using a dumb hashmap and haven't even started unpacking and strictifying things.
13:19:29 <oerjan> that ClearBF page got updated
13:19:32 <elliott> Of course it's a bit unfair, since CCBI implements a lot more fingerprints than I do.
13:19:52 <Gregor> !bfjoust very_stupid_turtle -(>+>-)*4>([(+.)*255.+>]+>[(+.)*255.->]->)*11
13:19:52 <lambdabot> Gregor: You have 7 new messages. '/msg lambdabot @messages' to read them.
13:20:02 <elliott> CCBI gets 0.028, 0.027, 0.41s with fingerprints disabled here.
13:20:03 <Gregor> lambdabot: Yeah, fuck oerjan, that guy's a loser.
13:20:09 <oerjan> it's still a bit weird, but no longer a candidate for deletion, i should think.
13:20:17 <elliott> Why would anyone message Gregor with _lambdabot_
13:20:34 <oerjan> elliott: he wasn't here and i couldn't remember if he read logs.
13:20:42 <elliott> oerjan: " ● Ability to make comments using "%" to start a comment. The comment ends at the end of the line.
13:20:42 <elliott> ● All new identifiers (variables) will be awarded automatically initialized to zero."
13:20:53 <oerjan> also i got a bit carried away with the blathering.
13:20:57 <elliott> oerjan: wow, I got "basic commands" almost exactly right with my direct cipher of brainfuck
13:21:18 <elliott> 09:35:55 <oerjan> @tell Gregor I have been looking a bit at your egojoust parsing code and i think you are miscalculating the new size of the program after expansion, particularly if using ({})% (you are clobbering llen for a different use) but also elsewhere (ignoring the atoi length). might you not end up looking at unitialized memory?
13:21:26 <elliott> Gregor: btw ()*-1 lets you write *10000 easily
13:21:28 <elliott> or with one more 0 whatever
13:21:48 <elliott> Gregor: If I write lance will you rejig the scoreboard system to use it? :-P
13:21:59 <elliott> It'll do ()* and ()% efficiently and all.
13:22:20 <oerjan> elliott: yeah i noticed ais523 has one program on the hill that actually has *-something and it then means *10000
13:22:30 <elliott> it's *-160 for some strange reason
13:22:39 <elliott> oerjan: and IIRC they're [s
13:22:43 <Gregor> elliott: If you write it to exit with the same status as egojoust, there's virtually nil rejigging to do.
13:22:52 <elliott> so it's [[[...10000 [s... blah ...10000 ]s...]]]
13:23:03 <elliott> Gregor: What's egojoust's exit status :P
13:23:11 <Gregor> elliott: Number of points.
13:23:22 <Gregor> elliott: Negative for left.
13:23:26 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
13:23:33 <elliott> Forgot how points are calculated.
13:23:56 <elliott> Gregor: Yay, lance will result in IMMENSE POINT DEFLATION by not running redundant polarities :P
13:24:12 <Gregor> I should be more clear :P
13:24:20 <Gregor> elliott: EgoJoust returns right wins - right losses.
13:24:40 <EgoBot> Score for Gregor_very_stupid_turtle: 16.7
13:24:44 <elliott> Gregor: 'Sok, I can make it do that, and the fact that it returns lower than egojoust all the time is your code's problem :P
13:25:47 <Gregor> I won't put it in EgoBot unless you multiply by two.
13:25:59 <Gregor> And it also prints the breakdown to stdout.
13:26:19 <elliott> Gregor: (1) Dude, s/egojoust/lance/ is as much work as s//*2/
13:28:00 <elliott> Returning an array of label pointers: BEST IDEA???
13:28:01 <oerjan> elliott: note that some people turned out to be sorta attached to the ([)*n notation
13:28:17 <elliott> oerjan: s/some people/impomatic/, and he uses it unmatched, which is just perverse
13:28:26 <elliott> everyone else is just doing it because it's faster on the current hill afaik
13:28:39 <oerjan> yeah only impomatic did it completely unmatched
13:28:43 <elliott> anyway lance will end up running things like 50x faster than egojoust this way, so I'm going to reject such programs outright. well maybe ([)*nfoo(])*n I can do.
13:28:51 <elliott> but i'd rather people just use %.
13:29:01 <elliott> maybe i'll write a preconverter and plug it into lance to handle the 90% case.
13:29:46 <oerjan> elliott: btw what about my (({{}})%)% variation idea?
13:29:58 <elliott> oerjan: what was that again?
13:30:01 <oerjan> it's quite easy to do efficiently too
13:31:24 <oerjan> basically you can abbreviate (([)*m{...}(])*m)%n as (([{...}])%m)%n
13:31:42 <elliott> well right now i'm implementing without any () stuff, just to get the basics down
13:32:18 <elliott> KETTLE, /* for right warrior, DINK and DONK are swapped */
13:32:24 <elliott> This is what real engineers do, Gregor.
13:32:48 <oerjan> elliott: basically ( pushes starting count on the stack, { iterates back to matching ( or pops, } pushes like (, and ) iterates or pops
13:33:26 <oerjan> and provided [] matches inside () and inside {} like the rule is supposedly already, it should all work
13:34:18 <oerjan> hm i guess } and ) need to count the reverse way of ( and {
13:34:23 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
13:34:39 <elliott> oerjan: well myndzi is the one who came up with supar-efficient ways to do ()*n (well that's trivial) and ()%n (harder)
13:34:43 <elliott> the latter i'll have to ask him about
13:34:53 <elliott> or was it ais who came up with that.
13:34:58 <oerjan> elliott: mine is just a generalization of a ()%n method
13:35:25 <elliott> Gregor: Are you serious about that "won't put it in EgoBot unless you pointlessly multiply by two" thing?
13:35:25 <oerjan> i just realized you didn't have to put {} immediately inside () always, you can have intervening ()'s
13:35:48 <oerjan> with a stack regime for matching
13:37:09 <oerjan> elliott: and the notation looks like it could be useful, too
13:37:23 <elliott> oerjan: i'll implement that as soon as it can run ()-less programs then
13:42:32 <elliott> oerjan: hm what's the maximum number of loops a warrior can get into, ... oh wait, it's 100000
13:42:51 <elliott> oerjan: well i'm not changing that for lance
13:43:24 <elliott> 781 kilobytes on the stack, nice :D
13:44:10 <Phantom_Hoover> elliott, looks like the TV Tropes people are eviscerating the Troper Tales and Fetish Fuel namespaces.
13:44:43 <elliott> Phantom_Hoover: So first they move everything to Troper Tales, and then they demolish it?
13:45:52 <elliott> oerjan: it irks me that I can't optimise loops in BF Joust sanely :(
13:46:01 <elliott> because the normal way basically turns it into a while loop that recurses the interpreter
13:46:06 <elliott> which obviously fucks up cycles
13:46:12 <elliott> but [ scanning for the matching ] is shitty
13:47:13 <oerjan> elliott: um Gregor's method of caching matching [] positions is quite adequate, you can just do it in a preprocessing pass if you want
13:47:28 <elliott> oerjan: i haven't read the egojoust code
13:47:35 <elliott> it just irks me that i can't do it the normal way
13:48:04 <oerjan> elliott: caching [] _is_ equivalent to the normal way of compiling into something with jumps
13:48:21 <Vorpal> <elliott> it just irks me that i can't do it the normal way <-- "the normal way"?
13:48:35 <elliott> Vorpal: give loop instructions a ->body, just do "while (tape[ptr]) interpret(ins->body)"
13:49:01 <Vorpal> also, the weather is horrible over here.
13:49:18 <Vorpal> elliott, are you implementing brainfuck?
13:49:32 <Vorpal> or more accurately bfjoust I guess
13:49:38 <oerjan> elliott: the jump method is better for implementing () efficiently, i think. it leaves you free from needing handling [] on the stack as well
13:50:15 <Vorpal> elliott, congrats on the befunge project being alive until now. That is a record in continuous time spent on a given project I think!
13:50:53 <elliott> Vorpal: um i'm just taking a break after getting mycology all passing apart from text IO, including all the FILE tests, having instant bounds shrinking, and getting Mycology running fully in less than a second
13:50:59 <elliott> I think I've earned the right to write a little C program :D
13:51:12 <Vorpal> elliott, text IO isn't that hard really.
13:51:23 <elliott> i know, but it's also boring, so i've skipped it for now
13:51:30 <elliott> i can read in text and binary mode, just not write in text mode
13:51:38 <Vorpal> elliott, especially with a high level languages you could quite easily do a possibly-slow variant
13:52:09 <elliott> well sure i could in haskell too, it'd just feel wrong.
13:52:14 <Deewiant> map (reverse . dropWhile (==' ') . reverse) . lines
13:52:33 <Deewiant> elliott: BS.pack . unlines . map (reverse . dropWhile (==' ') . reverse) . lines . BS.unpack
13:53:11 <Vorpal> Deewiant, that won't work though. Consider literal \n bytes in the funge space being written out
13:53:17 <oerjan> Deewiant: "you better pray that fuses"
13:53:35 <Vorpal> Deewiant, or wait, what should you do in that case even?
13:54:03 <Deewiant> Vorpal: You should do exactly that, and I think Mycology tests that.
13:54:12 <elliott> Deewiant: Pack is slow :-P
13:54:16 <elliott> Deewiant: But, uhh, B8.lines exists.
13:54:28 <Vorpal> Deewiant, guess I does then
13:54:31 <elliott> I _write_ with \ns in rectangleToByteString.
13:54:34 <elliott> <Deewiant> Vorpal: You should do exactly that, and I think Mycology tests that.
13:54:43 <elliott> <oerjan> Deewiant: "you better pray that fuses"
13:54:47 <elliott> oerjan: i have the utmost faith in GHC!
13:55:27 <elliott> Vorpal: So have you implemented the O(1) wrapping yet :P
13:55:52 <Vorpal> elliott, no. I just got home today. As I told you before. Likely not until the weekend
13:56:10 <Deewiant> Right, it's UNDEF, but I think it's preferable. :-P
13:56:10 <Vorpal> still got university stuff to do
13:56:32 <elliott> Deewiant: Rite, because then binary reading works with text output.
13:56:37 <elliott> @hoogle (a -> Bool) -> [a] -> [a]
13:56:37 <lambdabot> Prelude dropWhile :: (a -> Bool) -> [a] -> [a]
13:56:38 <lambdabot> Prelude filter :: (a -> Bool) -> [a] -> [a]
13:56:38 <lambdabot> Prelude takeWhile :: (a -> Bool) -> [a] -> [a]
13:56:51 <elliott> textify = B8.unlines . map (reverse . dropWhile (== ' ') . reverse) . B8.lines
13:56:55 <elliott> I think that has a good chance of fusing.
13:57:12 <Vorpal> recent snowfall of rather dry snow + hard wind orthogonal to direction of road = horrible
13:57:18 <Deewiant> elliott: Of course reverse won't work there since they're bytestrings
13:57:54 <Deewiant> elliott: You want map (fst . BS.spanEnd (==' '))
13:58:00 <elliott> Oh, there's a function for that?
13:58:16 <elliott> Deewiant: P.S. you mean == space
13:58:23 <elliott> (We need OverloadedChars.)
13:58:26 <Deewiant> Well I don't know your data types
13:58:33 <elliott> Deewiant: space is just 32
13:58:39 <elliott> Obviously a bytestring contains word8s, not chars
13:58:47 <elliott> So yours doesn't work anywhere
13:58:51 <elliott> oerjan: initsWhile f === reverse . dropWhile f . reverse
13:59:01 <elliott> I guess it should be initWhile
13:59:13 <Vorpal> elliott, do you ever get such conditions in UK btw? Snow blowing over road. So much that you can only see about half a meter in front of the car.
13:59:13 <fizzie> The ' ' would work for a Data.ByteString.Char8 bytestring.
13:59:21 <Deewiant> elliott: Mine works on the abominable Char8 ByteStrings... which are the only ones that provide lines/unlines
13:59:34 <elliott> Deewiant: The Char8 type is the same as the regular type.
13:59:43 <elliott> Deewiant: So you can happily use Char8 (B8) functions on regular ByteStrings when you need to.
13:59:43 <Deewiant> elliott: No it's not, it's Char vs Word8
13:59:51 <elliott> Deewiant: Or at least it types for me.
13:59:53 <Deewiant> Oh, the ByteString type is the same
13:59:57 <elliott> This might be an implementation detail, but it works :-P
14:00:45 <elliott> Wrote to mycotmp3.tmp with o in linear text mode.
14:00:45 <elliott> GOOD: o removed space prior to newline
14:00:45 <elliott> UNDEF: o removes spaces prior to newline-valued cells
14:00:45 <elliott> BAD: i misread or o miswrote
14:00:45 <elliott> Odd. But it's better than last time.
14:01:04 <elliott> Deewiant: Oh, do you expect there to be no trailing newline, or something of that sort?
14:01:39 -!- asiekierka has joined.
14:01:52 <Vorpal> elliott, hm it doesn't tell how it miswrote/misread?
14:02:00 <elliott> textify = B8.unlines . filter (/= empty) . map (fst . B.spanEnd (== space)) . B8.lines
14:02:01 <Vorpal> oh wait, of course not. It is mycology
14:02:05 <elliott> Oh wait, I only want to strip them off at the end.
14:02:10 <elliott> initsWhile, in other words.
14:02:29 <Deewiant> Vorpal: It's much more of a pain to preserve info and print stuff out in Befunge than it is in your interpreter
14:03:01 <Deewiant> When working on CCBI I practically ignore Mycology's BAD info other than seeing what instruction it's testing
14:03:20 <Vorpal> Deewiant, yeah indeed. But sometimes knowing what you expected would be nice. It isn't always obvious.
14:03:29 <elliott> Deewiant: The problem is that everyone who doesn't have fancy-super-debuggers because they're trying to get compliance first has a bit of a problem :-P
14:03:47 <elliott> Anyone who writes over 100K of comprehensive Befunge-98 test suite has done enough for the world already :P
14:03:51 <Deewiant> elliott: You don't need a fancy-super-debugger, you just need the ability to put traceShow in the right function
14:03:52 <elliott> (Perhaps more than they should have.)
14:04:01 <elliott> Deewiant: That counts as fancy-super-debugger in my book.
14:04:09 <Deewiant> elliott: You have that ability :-P
14:04:26 <elliott> Well, yeah, but I do it by printing tuples with ridiculous first values so they stand out :-P
14:04:38 <Vorpal> elliott, I actually think I change ccbi to print a trace in the same format as cfunge -t does and then diffed at one point. That was for some threading stuff though. IIRC that one was a bug in mycology and ccbi. Was quite long ago.
14:04:48 <elliott> fizzie: "Nokia will partner with Microsoft and use Windows Phone"
14:04:53 <elliott> fizzie: Ha ha, Finnish Nokia losers
14:05:05 <elliott> "The biggest impact will be to Finland's economy as Nokia is preparing to lay off thousands of workers." Joy
14:05:07 <Deewiant> elliott: Windows is an improvement over Symbian
14:05:10 -!- ais523 has joined.
14:05:15 <elliott> Enjoy going back to the ice age where you belong, dirty Finns!
14:05:24 <elliott> (This is what happens when Nokia collapses, I'm told.)
14:05:26 <Vorpal> Deewiant, meego looked good
14:05:42 <Deewiant> That might've been better but it's still an improvement over what they have
14:05:55 <elliott> I can't imagine actually wanting to use it... more importantly, I don't see how it could work on a tiny device.
14:05:57 <Deewiant> And it might even be a good business move; in case you didn't know, there's a lot of Windows machines out there :-P
14:06:11 <elliott> http://upload.wikimedia.org/wikipedia/commons/2/29/Meego_Architecture.jpg
14:06:14 <elliott> is the very image of brain damage.
14:06:28 <elliott> Although I do like how they've lumped huge chunks of Linux into the tiny bottom box.
14:06:40 <elliott> And apparently consider X11 on the same level as device sync and single sign-on.
14:06:53 <elliott> (Wait, they used X? Thank god nobody uses it.)
14:07:04 <elliott> <Deewiant> And it might even be a good business move; in case you didn't know, there's a lot of Windows machines out there :-P
14:07:08 <elliott> Deewiant: Windows != Windows Phone. :p
14:07:17 <Deewiant> Windows Phone talks to Windows
14:07:24 <elliott> Deewiant: So do other phones.
14:07:34 <elliott> iOS talks to Windows too :-P
14:07:36 <Deewiant> I imagine they'll be much more synergistic
14:07:46 <Vorpal> <elliott> is the very image of brain damage. <-- what in specific? It looks rather complex...
14:07:48 <elliott> You just said synergistic wrt a business strategy, congrats
14:07:52 <Deewiant> Especially if you use hotmail and the works, whatever
14:07:59 <elliott> Hotmail? ITYM WINDOWS LIVE MAIL
14:08:31 <Deewiant> Actually it's Windows Live Hotmail which I can abbreviate to Hotmail if I so choose
14:08:38 <Vorpal> elliott, hm I think it might be the picture that is brain damaged. "3D Graphics" is listed twice in "Visual Svcs"
14:09:07 <Deewiant> elliott: Also, synergistic wrt software, not the strategy :-P
14:09:17 <elliott> You still said synergistic :-)
14:09:27 <ais523> elliott: it was renamed to Windows Live Mail, but they quickly had to change it to Windows Live Hotmail on the basis that their customers wanted hotmail, not just ordinary mail
14:09:29 <Vorpal> elliott, in generally that image looks rather unprofessional. What with the text going outside boxes and so on
14:09:31 <Deewiant> If you find the word offensive that's your problem
14:09:40 <elliott> Deewiant: Not offensive, just meaningless
14:09:48 <ais523> I don't blame Microsoft for that sort of thing, but I can definitely blame their customers
14:10:06 <ais523> actually, Microsoft's business model - marketing to idiots - is probably a pretty good one
14:10:34 <elliott> ais523: I wish Microsoft would just, for once, cater to second-stupidest people out there and disregard the absolute stupidest.
14:11:16 <elliott> Deewiant: Because the rest of us have to deal with the result
14:11:16 <ais523> elliott: perhaps; but the absolute stupidest are more likely to spend money on things they don't actually need
14:11:22 <Vorpal> elliott, what would the stupidest do. Possibly annoy other people than microsoft instead? Which sounds worse.
14:11:33 <ais523> I've been in a computer shop where the salesman convinced someone who clearly didn't need Office - and probably not any other office suite either - to buy it
14:11:37 <Deewiant> elliott: The result being hotmail instead of mail? I don't mind much :-P
14:11:58 <elliott> Deewiant: IT WOULD BE A START
14:12:48 <ais523> it's as if the customers didn't realise that people trying to sell them things generally don't have their best interests in mind
14:13:43 <elliott> ais523: I have thought long and hard* about this matter and have concluded that most people are, in fact, dumb as bricks.
14:13:56 <elliott> At least I don't see any other explanation :-P
14:14:29 <ais523> elliott: well, I tend not to meet really really stupid people much
14:14:38 <ais523> because of the methods I use to meet and virtual-meet people
14:14:47 <elliott> if not stupid then at leats gullible
14:14:54 <ais523> hmm, gullible I can believe
14:14:55 <elliott> and not very critically-minded
14:14:56 <Vorpal> <ais523> elliott: perhaps; but the absolute stupidest are more likely to spend money on things they don't actually need <-- you know what
14:15:08 <Vorpal> make it "windows live mail" and then offer "hotmail" as an upgrade
14:15:09 <elliott> not really surprising considering the state of the school system
14:15:22 <elliott> Turn up in Redmond tomorrow.
14:15:38 <ais523> elliott: it seems the ClearBF people turned up and added details about the lang
14:15:49 <elliott> ais523: indeed, it's ... odd
14:15:52 <Vorpal> change logo, add possibly one or two features so somewhat less stupid people can't complain about you selling nothing
14:15:52 <ais523> admittedly, I almost thought it was spam
14:15:53 <elliott> it's like PEBBLE, except useless
14:16:07 <Vorpal> say, $2 / month or such for it?
14:16:46 <elliott> Vorpal: and then just team up with ISPs
14:16:46 <ais523> obvious extra feature is to remove the ads in the sig space
14:16:50 <elliott> to try and get people to buy it when they sign up
14:16:54 <elliott> dear god, it would make millions
14:17:04 <elliott> ais523: hmm, I bet sufficiently stupid people like them
14:17:05 <ais523> but unfortunately, you have to be Microsoft to make it work
14:17:08 <elliott> ais523: say, they click them on other people's emails
14:17:12 <elliott> because they interest them
14:17:21 <Vorpal> ais523, that could be an actual useful one. No idea how much money they make from the ads. But price it after that I guess
14:17:32 <ais523> Vorpal: I doubt it's $2/month per user
14:17:43 <elliott> have it advertise that the person is a VIP hotmail user
14:17:48 <ais523> Vorpal: I doubt it's that much
14:17:56 <elliott> "This person uses Hotmail, the email service for [...]. Do you? http://hotmail.com/"
14:18:03 <elliott> where [...] is some self-congratulatory bullshit
14:18:24 <ais523> or change it to an "upgrade to" advert if the email they're sending to is @live.com
14:18:26 <Vorpal> elliott, and offer veryhotmail for $3 / month that lets you turn that off?
14:18:45 <elliott> Deewiant: OKAY, HOTMAIL USER
14:18:46 <ais523> Deewiant: ah, they did last I checked, but that was a couple of years ago
14:19:15 <Deewiant> I don't remember (or might not even know) when exactly
14:19:24 <ais523> it's worth noting that hotmail/live.com blocks emails from yahoo.com addresses
14:19:36 <ais523> I discovered that one by accident, but it was easy enough to confirm
14:19:55 <ais523> elliott: it might have been a temporary spat
14:19:58 <elliott> because Yahoo is still pretty damn commonly used
14:20:18 <ais523> basically, I ended up in charge of an existing mailing list that had previously been run by someone else
14:20:36 <ais523> and emails sent to hotmail addresses from it didn't work
14:20:52 <elliott> that seems more like yahoo blocking hotmail if anything
14:21:40 <Vorpal> I wonder what sort of spam mail you get to emails under the .ng domain.
14:22:07 <elliott> and i hear you're a prince
14:22:13 <elliott> and want to give me lots of money, if i give you some
14:22:25 <elliott> do you think you could give me $1,000,000?
14:22:32 <ais523> a few quick searches imply it was a case of hotmail blocking yahoo, but only april-june 2007
14:22:36 <ais523> so presumably it doesn't happen any more
14:22:42 <Vorpal> elliott, ha. Nice reversing of sum
14:23:14 <ais523> elliott: you have to ask for the $1,000,000 first
14:23:30 <ais523> otherwise you're, umm, advance-fee defrauding yourself, in case the other person just never sends the million
14:23:50 <elliott> ais523: insert "THAT'S THE JOKE" macro
14:24:10 <ais523> oh, I thought the joke was what Vorpal pointed out
14:24:25 <Vorpal> ais523, I think the joke was that the *whole* thing was reversed
14:24:54 <Vorpal> ais523, dude asking a prince, instead of the reverse. That is also part of the joke
14:25:32 <Deewiant> elliott: I like how you tend to call other people's jokes poor, but always end up being all "WHOOSH" when you tell a joke yourself
14:25:45 <ais523> in that case, the money bit would work more like this: "I hear your uncle died last week, and you're having trouble moving the money, TEN BILLION POUNDS, to the UK. I'd be willing to pay your 10% processing fee in order for a 50% split of the resulting funds."
14:25:54 <elliott> Deewiant: I have a state-sanctioned monopoly on bad jokes, you see
14:26:17 <Vorpal> Deewiant, it would indeed not be inaccurate to say that elliott's behaviour is somewhat hypocritical.
14:26:26 <Deewiant> elliott: I see. That /would/ be the simplest explanation.
14:26:35 <elliott> It's not the case that double negatives don't not not not make you sound more not unneutral.
14:26:41 <ais523> wow, ClearBF is actually sub-TC
14:26:54 <Vorpal> elliott, ah. That is UK only though. I have the one in Sweden.
14:27:12 <elliott> the only way you can have bignum coordinates violates the spec (like efunge does)
14:27:15 <ais523> elliott: well, Funge-98 is a push-down automaton
14:27:19 <Gregor> I notice that yet again when I update the report style, nobody showers me with gratitude.
14:27:20 <elliott> because y requires you to push the number of bits
14:27:21 <ais523> ClearBF's finite state
14:27:26 <ais523> Gregor: we haven't looked at it yet
14:27:27 <elliott> Gregor: You updated it again?
14:27:42 <elliott> ais523: but it's amusing because people go "oh, Funge-98 lifted the restriction and it's TC now!!"
14:27:45 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
14:27:50 <Vorpal> <ais523> elliott: well, Funge-98 is a push-down automaton <-- err... I thought it was BSM?
14:27:53 <ais523> ah, it's a reasonably small change
14:28:06 -!- poiuy_qwert has quit (Quit: This computer has gone to sleep).
14:28:11 <Vorpal> elliott, only for implementing it :P
14:28:12 <ais523> actually, I think it /is/ TC
14:28:18 <Gregor> I added the position >_<
14:28:21 <elliott> well, the stack stack is infinite
14:28:27 <elliott> ais523: you have to push stack stack length and stack length on stack
14:28:31 <Vorpal> <ais523> ah, it's a reasonably small change <-- what is it? I can't find it.
14:28:35 <ais523> you can use the junction of the top of the SOSS and the top of the TOSS as a zipper
14:28:46 <ais523> and that's fine so long as you never call y
14:29:12 <Vorpal> ais523, befunge-98 is TC if you allow bignum implementations like efunge. (Though of course efunge is not TC in practise either.)
14:29:22 <ais523> i.e. it's not a case of "the existence of y means you can never make a change that would make y fail"; it's more "the specification of y means it can't manage certain possible states on the stack"
14:29:27 <ais523> y should simply reflect in such cases
14:29:36 <elliott> y dictates the rest of the implementation
14:29:44 <elliott> because it's _system_ info
14:29:50 <elliott> i.e. information that exists in /every system/
14:29:58 <elliott> so it must already be there
14:30:24 <ais523> it is there, nothing about y implies that the information is restricted to the size of a stack element
14:30:27 <ais523> except the fact that y pushes it
14:30:39 <ais523> so, the information is /there/, just y is incapable of pushing it, therefore should reflect
14:30:41 <Deewiant> Then you need tagged cells, of course
14:30:51 <elliott> Deewiant: I don't think that's spec-compliant :P
14:31:06 <Deewiant> But if it's a value that works transparently like infinity then I guess it would be allowed
14:31:31 <ais523> Deewiant: heh, are you arguing that there's no way from within standard Funge to determine that someone hasn't just pushed infinity on the stack?
14:31:36 <elliott> Point is, regular Befunge-98 isn't TC because of Funge-space being relaxed, like people think it is :P
14:31:38 <Vorpal> Deewiant, I'm not sure you can consistently handle cells with the value infinity
14:31:39 <oerjan> simply push a value that is too huge for your program to ever detect it is not infinite
14:31:47 <ais523> elliott: yep, it clearly doesn't have infinite fungespace
14:31:51 <ais523> but it does have multiple stacks
14:32:00 <Vorpal> Deewiant, as in mathematically consistently
14:32:04 <Deewiant> ais523: I don't think there is, as such
14:32:12 <elliott> Infinity isn't inconsistent
14:32:13 <Deewiant> Some fingerprints can cause problems, of course
14:32:23 <oerjan> and then take the limit of that behavior
14:32:24 <elliott> oerjan: wow, that's such an engineer way of thinking about it
14:32:29 <elliott> oerjan: oh, do you mean that
14:32:31 <elliott> since fungespace is infinite
14:32:39 <elliott> that there's a value and a value+1 that no Funge-98 program can distinguish?
14:32:44 <elliott> since fungespace is finite
14:32:45 <elliott> that there's a value and a value+1 that no Funge-98 program can distinguish?
14:32:46 <Vorpal> elliott, not as such. But if you aren't careful in how you handle it you can get issues. Besides what infinity is it? Aleph-zero?
14:32:48 <Deewiant> Well, you have to figure out what to do about infinity-infinity and infinity/infinity
14:32:51 <elliott> oerjan: if so, that's genius
14:32:57 <ais523> what about doing it Feather-style: just push 8 or something, if any other value in the program ever end up becoming more just go back in time and increase the number you pushed
14:32:59 <elliott> have the same possible range as cells
14:33:04 <elliott> so no such value exists oerjan :(
14:33:17 <elliott> Vorpal: Aleph-null is a cardinality, not relevant here
14:33:20 <Deewiant> ais523: That'd work TRDS-style if it weren't for the fact that there's I/O
14:33:40 <oerjan> elliott: what i'm really saying is that _if_ you make things actually infinite you can do it in such a way that no befunge program can prove you did it
14:33:58 <ais523> Deewiant: I/O doesn't fit well into Feather's worldview
14:34:27 <Vorpal> Deewiant, Some fingerprints might interact badly with it. Is there any pow() for non-floating point in fingerprints?
14:34:37 -!- ultra1 has joined.
14:34:56 <elliott> I have to flood 12 lines for their sheer ugly insanity, please forgive me:
14:34:57 <Deewiant> ais523: Just saying that this isn't Feather, which may complicate things
14:35:00 <elliott> mergeByteString :: Bool -> ByteString -> FungeSpace -> Vector -> (Vector, FungeSpace)
14:35:00 <elliott> mergeByteString is2D s (FungeSpace m minXY maxXY rowPop colPop) offset@(ox,oy) = ((bx,by),FungeSpace m' (min offset minXY) (max (bx-1,by-1) maxXY) rp cp)
14:35:00 <elliott> where ((_,by),m',rp,cp,_,bx) = B.foldl' byte ((ox,oy),m,rowPop,colPop,False,0) s
14:35:00 <elliott> byte (p@(x,y),!m,!rp,!cp,lastWasCR,!biggestX) w
14:35:00 <elliott> | is2D && (w == ff || (w == lf && lastWasCR)) = (p, m, rp, cp, False, biggestX)
14:35:02 <elliott> | is2D && (w == cr || w == lf) = ((ox,y+1), m, rp, cp, w == cr, biggestX)
14:35:04 <elliott> | w == space = ((x+1,y), m, rp, cp, False, max (x+1) biggestX)
14:35:06 <elliott> | otherwise = ((x+1,y), Map.insert p (fromIntegral w) m, if Map.findWithDefault space p m == space then modm (+1) y rp else rp, if Map.findWithDefault space p m == space then modm (+1) x cp else cp, False, max (x+1) biggestX)
14:35:12 <elliott> where modm f = Map.alter (\x ->
14:35:13 <oerjan> elliott: the befunge program cannot prove you didn't just choose a finite number too large to distinguish during the lifetime of the universe. since you are _actually_ doing it infinite, this still applies if the estimate for universe lifetime increases (as long as not infinite)
14:35:24 <Vorpal> elliott, sprunge.us works too
14:35:28 <elliott> oerjan: lifetime of the universe? please, we're not restrained by such petty constraints
14:35:31 <elliott> Vorpal: EVERYONE HAD TO SEE THAT.
14:35:37 <ais523> oerjan: it easily can: just run :- on it
14:35:50 <elliott> infinity-infinity can be 0 :P
14:35:50 <ais523> you end up with 0 if it pushed Graham's Number, and NaN if it's an actual infinity
14:35:58 <elliott> infinity-infinity can be 0 :P
14:36:00 <Deewiant> Vorpal: There is such a pow(), in FIXP IIRC, slowdown.b98 uses it
14:36:10 <Vorpal> ais523, NaN only if floating point surely?
14:36:33 <elliott> obviously infinity=infinity
14:36:59 <elliott> ofc you could have a stack of infinities :)
14:37:03 <elliott> and infinity+1 -> infinity+1
14:37:12 <ais523> what I mean is that infinity == infinity+1
14:37:15 <Vorpal> Deewiant, now I'm not sure what sort of infinity we use, so what would 10^infinity do in that case?
14:37:20 <elliott> ais523: yep, but you could make that not be the case
14:37:30 <ais523> whereas A(G_64,G_64) != A(G_64,G_64)+1
14:37:39 <elliott> you could make infinity+1 be a distinct value
14:37:54 <ais523> Deewiant: that contradicts typical mathematical theory
14:37:58 <elliott> Deewiant: nope, 10^infinity = 10^infinity
14:38:01 <elliott> just store it algebraically
14:38:28 <Deewiant> ais523: Eh? lim n 10^n = infinity, surely?
14:38:54 <ais523> Deewiant: it's a different infinity, the cardinality of reals rather than the cardinality of ints
14:39:08 <Deewiant> Only if we're talking about cardinalities
14:39:11 <oerjan> actually you want to choose a hyperreal number of some sort
14:39:28 <elliott> oerjan: we're going to reinvent ordinals soon
14:39:33 <elliott> but that has the 1+infinity vs infinity+1 problem
14:39:38 <oerjan> no, ordinals are inadequate for this
14:39:44 <ultra1> c est quoi ce charabbia
14:39:48 <elliott> ORDINALS ARE INADEQUATE. WE NEED MORE INFINITY!!
14:40:03 <Vorpal> elliott, what is the cardinality of the set of all ordinals btw?
14:40:06 <elliott> ultra1: esteda moude emt ablee?
14:40:13 <oerjan> you want a number that can give answers to all your questions as if it were finite, but actually isn't
14:40:14 <elliott> Vorpal: there is no set of all ordinals, surely you know that
14:40:21 <elliott> such a set is inconsistent
14:40:33 <oerjan> and hyperreals fit that
14:41:01 <Gregor> I'm all the way down to #20? D-8
14:42:33 <elliott> hmm, can & read an integer with - in front of it?
14:43:27 <lambdabot> System.IO hLookAhead :: Handle -> IO Char
14:44:03 -!- ultra1 has quit (Ping timeout: 240 seconds).
14:48:45 <elliott> Deewiant: What does mycouser do between saying "UNDEF: got (char you entered) which is hopefully correct." and saying "All done checking the following instructions: / % & ~"?
14:48:50 <elliott> It waits on a newline for me.
14:50:15 <Gregor> !bfjoust raping_turtle -(>+>-)*4>([(+.)*144+>]+>[(-.)*144->]->)*11
14:50:52 <elliott> Gregor's warrior names get steadily more classy.
14:51:01 <elliott> But invariably turtle-oriented.
14:51:06 <Deewiant> elliott: It reads another char, can't remember why.
14:51:35 <elliott> Please input a number: UNDEF: got 3 which is hopefully correct.
14:51:35 <elliott> Please input a character: UNDEF: got 120 'x' which is hopefully correct.
14:51:35 <elliott> shiro: <stdin>: hGetChar: end of file
14:51:45 <Vorpal> Deewiant, it swallows newline iirc
14:52:46 <lambdabot> System.IO hIsEOF :: Handle -> IO Bool
14:53:06 -!- Slereah has quit (*.net *.split).
14:53:06 -!- shachaf has quit (*.net *.split).
14:53:07 -!- ais523 has quit (*.net *.split).
14:53:07 -!- asiekierka has quit (*.net *.split).
14:53:08 -!- Phantom_Hoover has quit (*.net *.split).
14:53:08 -!- cheater- has quit (*.net *.split).
14:53:08 -!- miekko has quit (*.net *.split).
14:53:08 -!- Herobrine has quit (*.net *.split).
14:53:08 -!- Mannerisky has quit (*.net *.split).
14:53:09 -!- MigoMipo has quit (*.net *.split).
14:53:10 -!- dbc has quit (*.net *.split).
14:53:10 -!- mtve has quit (*.net *.split).
14:53:10 -!- myndzi has quit (*.net *.split).
14:53:11 -!- coppro has quit (*.net *.split).
14:53:11 -!- ineiros has quit (*.net *.split).
14:53:12 -!- jix has quit (*.net *.split).
14:53:12 -!- SimonRC has quit (*.net *.split).
14:53:12 -!- rodgort has quit (*.net *.split).
14:53:13 -!- Deewiant has quit (*.net *.split).
14:53:13 -!- aloril has quit (*.net *.split).
14:53:13 -!- tswett has quit (*.net *.split).
14:53:14 -!- Behold has quit (*.net *.split).
14:53:15 -!- olsner has quit (*.net *.split).
14:53:15 -!- lifthrasiir has quit (*.net *.split).
14:53:15 -!- Gregor has quit (*.net *.split).
14:53:21 <elliott> oerjan: yay you're still here
14:53:37 <elliott> oerjan: but more importantly, I use ioReflect
14:53:42 <oerjan> elliott: we're on the same server
14:53:50 <elliott> so it should just be _reflecting_
14:53:59 <elliott> unless isEOF doesn't throw an exception...
14:54:08 <elliott> does error "foo" count as an IOException?
14:54:22 <elliott> hope not, since that would fuck up some of my "wtf?" error prints :D
14:54:33 <oerjan> no, although you _can_ catch it
14:54:51 <oerjan> with the more general exception catching
14:55:01 -!- pikhq_ has quit (Ping timeout: 240 seconds).
14:55:03 <elliott> oerjan: I use Control.Exception, which is probably that
14:55:04 <EgoBot> Score for Gregor_raping_turtle: 30.0
14:55:19 -!- pikhq has joined.
14:56:43 <oerjan> !haskell import System.IO; main = hGetChar >>= print
14:57:05 <oerjan> hm i guess that won't really print anything
14:57:51 <oerjan> elliott: if you want to only catch IOExceptions, you have to restrict it i think...
14:58:16 <elliott> oerjan: ioReflect :: IO a -> Shiro a
14:58:18 <elliott> io . hPutStrLn stderr $ "*** [Reflecting on IO exception: " ++ show e ++ "]"
14:58:20 <elliott> throw (ShiroIOException st)
14:58:24 <elliott> (print is just for dbeugging)
15:00:07 <elliott> if eof then return i else do
15:00:14 -!- SimonRC has joined.
15:00:14 -!- ais523 has joined.
15:00:14 -!- asiekierka has joined.
15:00:14 -!- Behold has joined.
15:00:14 -!- Phantom_Hoover has joined.
15:00:14 -!- cheater- has joined.
15:00:14 -!- ineiros has joined.
15:00:14 -!- mtve has joined.
15:00:14 -!- MigoMipo has joined.
15:00:14 -!- myndzi has joined.
15:00:14 -!- shachaf has joined.
15:00:14 -!- Slereah has joined.
15:00:14 -!- jix has joined.
15:00:14 -!- Mannerisky has joined.
15:00:14 -!- Deewiant has joined.
15:00:14 -!- aloril has joined.
15:00:14 -!- tswett has joined.
15:00:14 -!- rodgort has joined.
15:00:14 -!- coppro has joined.
15:00:14 -!- miekko has joined.
15:00:14 -!- dbc has joined.
15:00:14 -!- olsner has joined.
15:00:14 -!- lifthrasiir has joined.
15:00:14 -!- Herobrine has joined.
15:00:14 -!- Gregor has joined.
15:00:15 <elliott> hard to get more direct than that kind of checking :)
15:00:32 <elliott> it's read with the other instruction
15:00:33 <elliott> Gregor: 30.0 for the raping turtle btw
15:00:41 -!- asiekierka has quit (Excess Flood).
15:00:48 <oerjan> i don't think HackEgo has ghc
15:01:04 <ais523> wow, there's quite a renaissance of slow-rush programs in BF Joust
15:01:10 <oerjan> also that would be `run
15:01:11 -!- asiekierka_ has joined.
15:02:42 <elliott> oerjan: hm my catch should be working actually
15:02:58 <oerjan> ioReflect works other places?
15:03:38 -!- tswett_ has joined.
15:03:40 -!- Behold has quit (*.net *.split).
15:03:41 -!- olsner has quit (*.net *.split).
15:03:41 -!- lifthrasiir has quit (*.net *.split).
15:03:41 -!- Gregor has quit (*.net *.split).
15:03:42 <oerjan> so can you show the actual use case which isn't working?
15:03:52 -!- Deewiant_ has joined.
15:04:01 <Vorpal> Deewiant_, not sure if this got through last time:
15:04:07 <Vorpal> <Vorpal> Deewiant, it swallows newline iirc
15:04:08 <Vorpal> <Vorpal> Deewiant, no?
15:04:17 <elliott> oerjan: coreIns '~' = io (hFlush stdout) >> (push . fromIntegral . ord =<< io getChar)
15:04:18 <Vorpal> elliott, well to us, but to him I meant
15:04:22 <elliott> i suppose hFlush could be failing :)
15:04:32 <Vorpal> elliott, we two were on the same side of the split. He wasn't :P
15:04:40 -!- Phantom_Hoover has quit (Ping timeout: 240 seconds).
15:05:02 <oerjan> elliott: and that's all wrapped inside ioReflect?
15:05:02 <Vorpal> Deewiant_, anyway I'm pretty sure mycouser wants to eat a newline there.
15:05:11 -!- Behold has joined.
15:05:11 -!- olsner has joined.
15:05:11 -!- lifthrasiir has joined.
15:05:11 -!- Gregor has joined.
15:05:19 <elliott> oerjan: ioReflect is like io except reflecting
15:05:36 <elliott> and makes choosing \n as the character odd :)
15:05:50 <elliott> Vorpal: well why read the newline?
15:05:56 <Vorpal> elliott, if you implement STRN it will test it's input function afterwards
15:05:59 <ais523> you probably PMed me during the netsplit and it got lost as a result
15:06:05 <Vorpal> elliott, same for BASE iirc
15:06:12 <Vorpal> elliott, so it would mess up those tests
15:06:12 <elliott> quintopia: stop CONSPIRING
15:06:23 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
15:06:33 <elliott> by "input a string" does MKRY mean "line" or what :)
15:07:07 <Vorpal> elliott, what I do is give the rest of the input line buffer as the result of that (unless it is empty in which case I read a line)
15:07:27 <Gregor> !bfjoust raping_turtle -(>+>-)*4>([([+)*144(])*144+>]+>[([-)*144(])*144->]->)*11
15:07:29 <Vorpal> elliott, I forgot if I strip away the trailing \n or not
15:07:37 <oerjan> <quintopia> check your pms <-- THAT'S VERY INSENSITIVE TO THE WOMEN HERE
15:07:53 <EgoBot> Score for Gregor_raping_turtle: 13.1
15:07:57 <elliott> don't be silly, Herobrine is obviously female
15:08:15 <oerjan> quintopia: THAT'S VERY INSENSITIVE TO HEROBRINE
15:08:25 <elliott> also Vorpal, even more obviously female!
15:08:29 -!- tswett has quit (Remote host closed the connection).
15:08:30 -!- Deewiant has quit (Remote host closed the connection).
15:08:36 <oerjan> ...i have _some_ doubts about that.
15:08:49 <elliott> Vorpal: is there something wrong with that? do you feel _accused_? are you SEXIST?
15:08:57 <elliott> oerjan: why? if I said e was male you wouldn't object!!
15:09:01 <Gregor> !bfjoust raping_turtle -(>+>-)*4>([(+)*112([+)*32(])*32+>]+>[(-)*112([-)*32(])*32->]->)*11
15:09:22 <oerjan> elliott: i have some conflicting information
15:09:30 <EgoBot> Score for Gregor_raping_turtle: 12.1
15:09:36 <Gregor> Yesssssssssssssssssssssssss
15:09:43 -!- Deewiant_ has changed nick to Deewiant.
15:10:21 <Gregor> !bfjoust raping_turtle -(>+>-)*4>([(+)*120([+)*16(])*16+>]+>[(+)*120([+)*16(])*16->]->)*11
15:10:38 <Vorpal> Gregor, is that the verb or the adjective in that program name?
15:10:46 <EgoBot> Score for Gregor_raping_turtle: 12.8
15:10:52 <Deewiant> Dude you're pushing me below defend13, don't do that
15:10:55 <elliott> Deewiant: That henk guy that isn't rcfunge or catseye or glfunge, where are the specs for those
15:11:00 <Gregor> Like {snapping,crapping,rapping}
15:11:36 <oerjan> Gregor: I SENSE A LACK OF SHORT VOWEL
15:12:03 <elliott> I'm just saying, how could it not be adjective
15:12:04 <ais523> a participle, to be precise, the adjective form of a verb
15:12:10 <Gregor> oerjan: Yeah, well raping_turtle is a fail regardless :P
15:12:12 <Vorpal> oh wait I misread that word as another one.
15:12:16 <ais523> alternatively, it's a noun
15:12:26 <elliott> How on earth can you misread "raping"
15:12:27 <ais523> because there's also a gerund spelt the same way, derived from the same verb
15:12:33 <oerjan> Gregor: it cannot get the speed up
15:12:46 <Gregor> I really don't understand why this does so much worse than rapping_turtle ....
15:12:47 <Vorpal> elliott, you talked about sexism. I misread it as "rapeing"
15:13:00 <elliott> Let alone an adjective or a verb.
15:13:09 -!- BeholdMyGlory has joined.
15:13:18 <elliott> But yes, "raping" means what you think "rapeing" means :P
15:13:51 <oerjan> I SENSE THE CURRENT BFJOUST NAMING CONVENTIONS DO NOT REFLECT WELL ON THIS COMMUNITY
15:13:57 <elliott> Deewiant: [[Rc/Funge-98 is the official implementation of these fingerprints. When a behavior is not specified in these specs, the way that Rc/Funge-98 operates is the correct behavior]]
15:14:04 <elliott> Deewiant: SPECIFIED SEGFAULTS
15:14:14 <Gregor> !bfjoust fapping_turtle -(>+>-)*4>([(+)*120(+.)*16(-.)*16>]+>[(+)*120(+.)*16(-.)*16>]->)*11
15:14:23 <Vorpal> elliott, right. But then follows that "to rape" gives that "raping"?
15:14:29 <EgoBot> Score for Gregor_fapping_turtle: 34.1
15:14:31 <Vorpal> or did that turn it into an adjective?
15:14:42 <elliott> I think you're very confused about how the English language works
15:14:50 <Deewiant> elliott: Not anywhere AFAICT: mirror http://tar.us.to:1234/
15:15:10 <Gregor> !bfjoust fapping_turtle -(>+>-)*4>([(+)*121(+.)*14(-.)*14>]+>[(+)*121(+.)*14(-.)*14>]->)*11
15:15:22 <Vorpal> elliott, isn't the -ing form of a verb still a verb?
15:15:25 <EgoBot> Score for Gregor_fapping_turtle: 34.1
15:15:45 <Gregor> !bfjoust fapping_turtle -(>+>-)*4>([(+)*124(+.)*8(-.)*4>]+>[(+)*124(+.)*8(-.)*4>]->)*11
15:15:52 <ais523> Vorpal: verbs generally have two -ing forms, one of which is an adjective (present participle), and the other of which is a noun (gerund)
15:15:57 <EgoBot> Score for Gregor_fapping_turtle: 35.3
15:16:05 <ais523> present participles basically always end -ing; gerunds sometimes end -ion instead
15:16:27 <ais523> (e.g. verb "subscribe" -> participle "subscribing", gerund "subscription")
15:16:56 <Vorpal> ais523, then "raping turtle" could mean either "the act of raping a turtle" or "a turtle that rapes <noun>"?
15:17:00 <oerjan> subscription is a gerund? i thought it was latin.
15:17:10 -!- Behold has quit (Ping timeout: 272 seconds).
15:17:13 <ais523> Vorpal: only the second
15:17:17 -!- elliott has quit (Quit: Leaving).
15:17:22 -!- elliott has joined.
15:17:24 <elliott> ARRY: "Addresses used by this extension are absolute, the storage offset does NOT apply to these functions."
15:17:25 <ais523> the first would have the words the other way round, "turtle raping"
15:17:31 <ais523> because English is often word-order-sensitive
15:17:54 <ais523> oerjan: gerunds come up more in Latin than English, for whatever reason
15:18:08 <Gregor> !bfjoust fapping_turtle -(>+>-)*4>([(-.)*8(+)*112(+.)*16>]+>[(-.)*8(+)*112(+.)*16>]->)*11
15:18:19 <EgoBot> Score for Gregor_fapping_turtle: 3.6
15:18:22 <elliott> Hey guys, nonsensual intercourse with testudines
15:18:24 <Vorpal> ais523, hm... I'm pretty sure that other order does occur. Mostly in titles. (Not that specific example of though)
15:18:44 <Vorpal> possibly they are not correct though
15:18:45 <oerjan> elliott: it's not particularly sensual either
15:18:55 <elliott> Deewiant: NCRS is the sane one and TERM the insane one right?
15:19:05 <Vorpal> elliott, neither is completely sane
15:19:30 <elliott> Doesn't CCBI do NCRS and not TERM or something
15:19:31 <Vorpal> elliott, I didn't know one was saner than the other either
15:20:07 <Vorpal> elliott, I believe that was the case for ccbi1. Or it did TERM only on windows or something like that
15:20:16 <Deewiant> CCBI1 did TERM only on Windows, yes
15:20:45 <Vorpal> Deewiant, ccbi2 does it on both?
15:21:14 <Vorpal> anyway TERM isn't insane. It is just cursor positioning mostly.
15:21:24 <Gregor> !bfjoust fapping_turtle -(>+>-)*4>([(-..)*8(+)*112(+..)*16+>]+>[(-..)*8(+)*112(+..)*16->]->)*11
15:21:26 <lambdabot> Foreign.C.String newCAString :: String -> IO CString
15:21:26 <lambdabot> Foreign.C.String newCString :: String -> IO CString
15:21:26 <lambdabot> Prelude read :: Read a => String -> a
15:21:35 <EgoBot> Score for Gregor_fapping_turtle: 3.6
15:23:06 <elliott> {-# LANGUAGE ForeignFunctionInterface #-}
15:23:07 <elliott> foreign import ccall "puts" c_puts :: CString -> IO ()
15:23:07 <elliott> main = c_puts =<< newCAString "Hello, world!"
15:23:19 <Gregor> !bfjoust fapping_turtle -(>+>-)*4>([(-.)*8(+)*128(+.)*16+>]+>[(-.)*8(+)*128(+.)*16->]->)*11
15:23:31 <EgoBot> Score for Gregor_fapping_turtle: 25.0
15:24:02 <Deewiant> Thanks, I'm above defend13 again
15:24:05 <Gregor> !bfjoust fapping_turtle -(>+>-)*4>([(+.)*256+>]+>[(+.)*120(+.)*16->]->)*11
15:24:16 <Gregor> I'm gonna kill fapping_turtle soon :P
15:24:21 <EgoBot> Score for Gregor_fapping_turtle: 16.0
15:24:31 <Gregor> !bfjoust fapping_turtle <
15:24:34 <Gregor> !bfjoust raping_turtle <
15:24:40 <EgoBot> Score for Gregor_fapping_turtle: 0.0
15:24:48 <EgoBot> Score for Gregor_raping_turtle: 0.0
15:26:57 <Gregor> I'm disappointed that I can't do better without actually looking into other code and targeting specific contenders :(
15:31:21 <elliott> Vorpal: Here's some fun for you:
15:31:23 <elliott> [[Some C functions are actually defined by a CPP header file to be a C macro. Suppose you foreign import such a "function", thus:
15:31:23 <elliott> foreign import foo :: Int -> IO Int
15:31:23 <elliott> Then you'll get the right thing if you compile using -fvia-C, provided you cause the right header files to be included. But the native code generator knows nothing of CPP mcros, so it will generate a call to a non-existent C function "foo". In effect, the FFI is defined to interface to the C ABI rather than the C API; it doesn't take account of CPP magic.]]
15:31:38 <elliott> i.e. I could do ncurses without a C wrapper, iff I use the right code generator :-P
15:32:30 <ais523> ncurses is full of macros
15:32:55 <Vorpal> elliott, how does ccbi manage it?
15:33:03 <elliott> With a C wrapper I believe
15:33:41 <elliott> Haskell: LANGUAGE OF SAFETY
15:34:48 -!- copumpkin has joined.
15:35:51 <fizzie> Prelude Unsafe.Coerce Data.ByteString> (unsafeCoerce 42 :: ByteString)
15:35:51 <fizzie> Loading package bytestring-0.9.1.5 ... linking ... done.
15:35:56 <fizzie> Language of safety, indeed!
15:36:17 <elliott> Woo, I now have env(1) written in hideously-unsafe Haskell.
15:36:44 <Deewiant> What, you don't have Unsafe.Coerce imported by your .ghci?
15:36:57 <elliott> It uses the environ variable, and C's puts.
15:37:08 <Deewiant> I thought I might've but evidently not
15:37:12 <elliott> So it's FAST (0.006 seconds, that's almost as fast as cfunge running Mycology)
15:37:18 <elliott> Deewiant: You actually use unsafeCoerce? :-P
15:37:18 <Deewiant> :m +Control.Applicative Control.Arrow Control.Monad Control.Monad.Loops Data.Char Data.Either Data.Function Data.Functor Data.List Data.List.Split Data.Maybe Data.Monoid Data.Ord Numeric Text.Printf
15:37:43 <Deewiant> There is no more hierarchical version of it
15:37:52 <lambdabot> Numeric showIntAtBase :: Integral a => a -> (Int -> Char) -> a -> ShowS
15:38:37 <oerjan> fizzie: we thus have proved that ByteStrings are not the Answer.
15:38:58 <Gregor> quintopia: What the hell does wireless_frownie DO?
15:39:38 <oerjan> elliott: Numeric and Foreign, iirc
15:41:10 <elliott> oerjan: well Foreign has a hierarchy underneath it
15:41:18 <elliott> Numeric should be Data.Numeric really
15:41:53 <elliott> I like how Foreign stole my peek and poke names :(
15:42:41 <oerjan> > showIntAtBase 13 intToDigit (6*9) ""
15:42:46 <elliott> http://sprunge.us/NjCI HOW TO PROGMA IN C
15:45:13 <elliott> MANDATORY_PATH=/usr/share/gconf/gnome.mandatory.path
15:45:14 <elliott> GNOME_DESKTOP_SESSION_ID=this-is-deprecated
15:45:14 <elliott> Interesting environment variables...
15:46:22 -!- sebbu has joined.
15:46:58 <elliott> Deewiant: Does Windows have putenv()?
15:47:20 <fizzie> "This POSIX function is deprecated beginning in Visual C++ 2005. Use the ISO C++ conformant _putenv or security-enhanced _putenv_s instead."
15:47:41 <elliott> It has the environ variable, right?
15:48:04 <elliott> OH WELL, I'll just make EVAR POSIX-only like it is now.
15:48:29 <ais523> fizzie: Microsoft have deprecated quite a lot of the C89 libraries
15:48:51 <ais523> replacing them with _s versions which take (buffer, buffersize) pairs rather than just buffers
15:49:04 <elliott> Deewiant: I don't suppose 0"oof"P can remove the environment variable "foo"? :-P
15:49:07 <ais523> this becomes a little ridiculous in the case of functions that /already/ took the buffer size as input
15:49:11 <elliott> It does say the argument is of the form foo=bar
15:49:42 <ais523> basically, it's a case of Microsoft missing the point of C
15:49:44 <fizzie> ais523: The C1x "bounds-checking interfaces" thing has _s functions that are quite similar.
15:50:29 <ais523> I seem to remember Microsoft suggested their _s functions to the C committee, and they rejected them in favour of something else
15:51:09 <elliott> @hoogle CString -> IO String
15:51:09 <lambdabot> Foreign.C.String peekCAString :: CString -> IO String
15:51:10 <lambdabot> Foreign.C.String peekCString :: CString -> IO String
15:51:10 <lambdabot> Prelude show :: Show a => a -> String
15:51:50 <elliott> C1x seems pretty crap so far :)
15:53:43 <Gregor> Somebody pastebin an explanation of the no-expansion algorithms for BFJoust.
15:54:00 <fizzie> ais523: I'm not sure they're exactly the same; but similar. And even those that already took a size (say memcpy) do extra checking (for NULLs and such) and fail in a bit more safe fashion than a segfault.
15:56:07 <elliott> Gregor: No, I'm implementing lance.
15:56:11 <elliott> Gregor: Stop ruining my fun >_<
15:56:24 <Gregor> elliott: What I'm trying to make is in no way competition for lance. It is strictly complementary.
15:56:33 <elliott> Gregor: But that's the only thing lance has :P
15:56:45 <Gregor> elliott: I am not making a replacement for egojoust.
15:56:48 <elliott> Ask oerjan I guess, he generalised it today/yesterday.
15:56:56 <elliott> Gregor: YOU ARE GRANTED PERMISSION THIS ONE TIME
15:57:33 -!- Minizours has joined.
15:57:37 <elliott> 13:54:34 <oerjan> elliott: basically ( pushes starting count on the stack, { iterates back to matching ( or pops, } pushes like (, and ) iterates or pops
15:57:37 <elliott> 13:55:13 <oerjan> and provided [] matches inside () and inside {} like the rule is supposedly already, it should all work
15:57:37 <elliott> 13:56:05 <oerjan> hm i guess } and ) need to count the reverse way of ( and {
15:57:48 -!- Minizours has left (?).
15:57:59 <elliott> I think that way, * is the same as % after a (), and {} just become freaky-deaky virtual 0-tick instructions
15:58:23 <ais523> elliott: not quite: { needs to look forwards to the % after the ) matching the containing (
15:58:27 <ais523> to know what the repeat count is
15:58:28 <Gregor> I'm not sure I'm convinced about [], in particular with respect to non-matching []s in ()s.
15:58:39 <elliott> non-matching []s in ()s is evil and should be banned.
15:58:45 <ais523> non-matching []s in ()s are disallowed by the spec as you're supposed to use ({}) instead
15:58:46 <elliott> ais523: why does defend13 have a *-160?
15:59:02 <elliott> ais523: oerjan said it did.
15:59:33 <ais523> I don't duplicate anything a negative number of times
15:59:46 <elliott> You've just forgotten where
16:00:08 <ais523> duplicating something a negative number of times would make no sense anyway
16:00:14 <elliott> SO I HEAR THIS MUBARAK PERSON STEPPED DOWN, just trying to keep #esoteric ON TOP OF CURRENT EVENTS, like we always are
16:00:18 <elliott> ais523: it's the same as *100000 in egojoust
16:00:41 <ais523> elliott: I just ran control-F over defend14's source
16:00:53 <elliott> 11.02.10:13:15:59 <oerjan> so why does ais523_defend9 contain *-160 twice...
16:00:54 <elliott> 11.02.10:13:22:34 <oerjan> elliott: and there are two *-160, one containing exactly one [ and one containing exactly one ], so the match even if it's interpreted as 10000 :D
16:01:10 <ais523> elliott: you didn't say defend9!
16:01:18 <elliott> <elliott> You've just forgotten where
16:01:22 <elliott> i.e. I don't remember which contestant it was :P
16:01:33 <ais523> also, that looks like a bug in defend9.pl
16:01:39 <elliott> because the cycle count is 100000
16:01:40 <ais523> (in case you didn't guess, defend9 is machine-generated)
16:02:35 <elliott> ais523: maybe if you fixed it it'd do well :D
16:02:45 <ais523> nah, the code that bit's in is unlikely to ever run
16:02:51 <ais523> especially with the current hill
16:02:56 <ais523> it detects a strategy nobody uses
16:03:10 <elliott> Gregor: What does EgoJoust do for a tie, not change the return value?
16:03:30 <Gregor> The return value is WINS - LOSSES. Is a tie a win or a loss? :P
16:03:39 <Gregor> (The answer is "no" :P )
16:04:17 <EgoBot> help: General commands: !help, !info, !bf_txtgen. See also !help languages, !help userinterps. You can get help on some commands by typing !help <command>.
16:04:22 <EgoBot> EgoBot is a bot for running programs in esoteric programming languages. If you'd like to add support for your language to EgoBot, check out the source via mercurial at https://codu.org/projects/egobot/hg/ . Cheers and patches (preferably hg bundles) can be sent to Richards@codu.org , PayPal donations can be sent to AKAQuinn@hotmail.com , complaints can be sent to /dev/null
16:04:40 <elliott> So Gregor, does that codu.org email forward to Hotmail :-p
16:05:34 <oerjan> ais523: did you notice my comment that (({{}})%)% also makes sense and is efficient?
16:05:52 <elliott> that's why LANCE, the enterprise BF Joust referee, will support it
16:06:02 <ais523> oerjan: no, but that's interesting
16:07:28 <oerjan> <elliott> oerjan: erm really? <-- really. if (times < 0 || times > 10000) times = 10000;
16:08:30 <oerjan> elliott: however it helps nothing with people doing (()*10000)*10000
16:09:29 -!- Wamanuz has joined.
16:09:35 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
16:09:49 <elliott> huh it's actually running semi-quickly
16:09:52 <EgoBot> Score for elliott_slug: 10.0
16:09:53 <elliott> it only expands if there's no [ in it
16:10:01 <elliott> !bfjoust slug (([)*-1)*-1((])*-1)*-1
16:10:11 <ais523> !bfjoust rule_of_nine >(>+[[<](>)*9((-)*64[-]>)*21])*30
16:10:16 -!- PH|lazytypist has joined.
16:10:18 -!- Wamanuz5 has quit (Read error: Connection reset by peer).
16:10:26 <elliott> finally, an ais523 program name that isn't [program style][number]
16:10:33 <ais523> elliott: many of mine aren't like that
16:10:34 <oerjan> <Gregor> (The answer is "no" :P ) <-- although "both" would be equivalent
16:10:36 <elliott> ais523: are you the 523rd ais program?
16:10:43 <ais523> besides, that is [program style][number] if you think about it
16:10:53 <ais523> could you kill slug so I actually get a result before the end of the universe?
16:10:53 <elliott> it's the ninth rule_of program? :-)
16:11:03 <elliott> ais523: erm they run simultaneously
16:11:05 <elliott> see http://codu.org/eso/bfjoust/breakdown.txt
16:11:25 <ais523> I don't expect it to do too well; the strategy is reasonable, but that implementation isn't advanced enough
16:11:28 -!- PH|lazytypist has quit (Client Quit).
16:11:29 <ais523> and actually, they run in alphabetical order
16:11:36 <ais523> so there'll be a few of mine, then a few of yours
16:11:47 <ais523> I won't be able to get all my runs in unless you kill yours
16:12:06 <elliott> i'll wait until it stops running yours
16:12:11 <elliott> just because i want to see what will happen >_>
16:12:25 * elliott decides that programs have no business being more than four megabytes, sets that as static limit
16:12:27 <pikhq> Yesterday: Mubarak refuses to step down. Today: Mubarak flees from Cairo and steps down.
16:12:48 <ais523> Deewiant_sloth.bfjoust vs ais523_rule_of_nine.bfjoust: <<<<<<>>>>>>>><<<<<<< <>>><<<<<<<>>>>>>>>>> <>>><<<<<<<>>>>>>>>>> <<<<<<>>>>>>>><<<<<<< Tie
16:13:05 <Deewiant> It's rare but not unheard of :-P
16:13:34 <elliott> rule_of_nine is not doing well :P
16:13:36 <Deewiant> Unless you meant something about the specific <> patterns
16:14:10 <ais523> it's not advanced enough
16:14:14 <oerjan> Gregor: btw that bug i mentioned could be fixed by changing prog.bufused = prog.bufused - llen - 2 + temp.bufused; into prog.bufused = prog.bufused - end + i - 1 + temp.bufused , i think
16:14:15 <ais523> and yes, slug does beat it
16:14:38 <Gregor> oerjan: TBH, I'm kinda hoping elliott replaces egojoust outright X-P
16:14:44 <ais523> I think what rule_of_nine needs is to waste time, preferably by setting large decoys
16:14:48 <elliott> Gregor: That's what I'm coding right now :P
16:15:29 <elliott> all my other operations fit into four chars nicely
16:16:25 <elliott> I'd prefer "ADVANCE" "RETREAT" modifications, because it's not really > all the time
16:16:30 <elliott> it can go left if you're the right player etc.
16:16:44 <ais523> yep, it's best described as "towards enemy flag", "towards own flag"
16:17:40 <quintopia> i assume you're asking about the mess o' [+?
16:17:54 <ais523> and using such a command while on your own or enemy's flag means that you collide with the flag and die from concussion
16:18:58 <quintopia> elliott: THE ENEMY'S GATE IS RIGHT
16:19:20 * quintopia wonders what this rule_of_nine thing is
16:20:00 <ais523> but the breakdown's indicating that it's at least a promising strategy
16:20:58 <oerjan> s/LOOP/LEAP/ , fits better with POOL >:)
16:21:01 <ais523> elliott: it looks like it just isn't executing slug at all
16:21:24 <elliott> ais523: probably didn't get the allocation it wanted
16:21:24 <oerjan> quintopia: i'd a thought 4 letters were mandatory here
16:21:28 <elliott> quintopia: that's not four characters!
16:21:37 <elliott> my program will CRASH if they aren't used
16:22:25 <elliott> hmm, what does unmatched [ do in egobot?
16:22:33 <elliott> or does it end the program if the value isn't 0?
16:22:41 <ais523> it should be parse error IMO
16:22:57 <quintopia> does it matter what egojoust does?
16:22:57 <elliott> ais523: yeah, agreed, I was trying to preserve the ] is nop behaviour but _meh_
16:23:07 <elliott> quintopia: well i don't want to break the current hill beyond program that do ([)*n
16:23:17 <elliott> I might make ([)*n...(])*n work with a preprocessor
16:23:21 <elliott> but impomatic's program is gonna have to go :P
16:23:56 <quintopia> it would be unfair to break programs that do ([)*n because egojoust can't do ({})%n properly
16:25:00 <quintopia> alright, lunch over. time to go engage in an act of ritual vampirism for the good of my fellow man!
16:25:22 <oerjan> <elliott> hmm, what does unmatched [ do in egobot? <-- none of the programs i checked yesterday had that after expansion, anyway
16:25:30 <fizzie> Is there some reason why you can't just do the (slower) text-expansion thing for those ()*n's you can't handle well?
16:26:04 <elliott> fizzie: Not "can't handle well".
16:26:07 <elliott> fizzie: According to the spec, they're invalid.
16:26:22 <elliott> People are abusing undefined behaviour to write invalid programs that can't be run efficiently, and that's not my problem :P
16:26:59 <elliott> ais523: can I have two simple ()-less BF Joust programs where you know one beats the other on a defined tape length and polarity?
16:27:07 <quintopia> elliott: you should make a converter, that, if it gets an invalid program, converts it into a valid one and resaves it. also you should possibly remove this feature once the current hill has been processed by it :P
16:27:37 <elliott> quintopia: (1) That would cause rapid expansion for certain types of program's (a single impomatic one); the simple cases I'm planning to preprocess if I can't convince Gregor just to ditch the fuckers. :p
16:28:02 <elliott> I'd like to add a tracing feature to lance, anyway, so you can debug your programs.
16:28:07 <elliott> Methinks some of us might find that useful :P
16:28:09 <oerjan> elliott: the impomatic one doesn't get _that_ large, i actually did that manually yesterday. oh i tried to match up parts though.
16:28:32 <elliott> oerjan: impomatic has way too many programs on the hill anyway :D
16:28:58 <oerjan> yeah there were only two that would affected if you do simple ()*n ... ()*n matching
16:29:16 <oerjan> (that would save 4 of them)
16:29:22 <ais523> elliott: [>[-]+] [>[-]-.-.-.-.-.-]; the first loses on normal polarity, the second loses on swapped polarity, the length of the tape doesn't matter
16:29:25 <oerjan> of course the hill may be different today
16:30:03 * elliott makes the makefile as insane as possible just for the hell of it
16:31:32 <elliott> lance: lance.c; $(shell grep '* compile:' $< | cut -d' ' -f4-)
16:31:51 <oerjan> <quintopia> alright, lunch over. time to go engage in an act of ritual vampirism for the good of my fellow man! <-- i'd a thought that would fit better _during_ lunch, m'self
16:31:55 <elliott> * compile: gcc -std=c99 -O2 -Wall lance.c -o lance
16:31:55 <elliott> * use: lance p1.bfjoust p2.bfjoust; $? = right wins - right losses
16:32:02 <elliott> /* lance -- duel bf joust warriors efficiently
16:32:02 <elliott> * compile: gcc -std=c99 -O2 -Wall lance.c -o lance
16:32:03 <elliott> * use: lance p1.bfjoust p2.bfjoust; $? = right wins - right losses
16:32:09 <elliott> ais523: see wut i did thar
16:32:44 <EgoBot> Score for elliott_slug: 2.4
16:32:45 <EgoBot> Score for ais523_rule_of_nine: 2.4
16:34:16 <elliott> ais523: the only kind of cycle timeout is a tie, right?
16:34:19 <Gregor> "{ iterates back to matching ( or pops" When would it ever pop?
16:34:35 <oerjan> elliott: that would probably use, say, at least 500 Mb of memory?
16:34:36 <Gregor> Ohduh, if the iteration count matches.
16:34:37 <Ilari> APNIC down 0.09 in last day, 0.35 in last 2 weeks.
16:34:38 <elliott> Gregor: If the count is 0, presumably.
16:34:43 <elliott> Gregor: What are you implementing?
16:34:53 <Gregor> elliott: You'll see :P
16:34:57 <Gregor> It does INVOLVE a BFJoust interpreter.
16:35:01 <ais523> Ilari: it's not going to last long, is it?
16:35:08 <elliott> <elliott> ais523: the only kind of cycle timeout is a tie, right?
16:35:08 <oerjan> assuming ints for *loops are 4 bytes, if they're 8, then 900 Mb
16:35:10 -!- Behold has joined.
16:35:22 <elliott> oerjan: ints are 32 bit in C
16:35:25 <Gregor> More helpful to other people than that.
16:35:36 <oerjan> <Gregor> IGNORE ME <-- O KAY
16:35:38 <elliott> Gregor: Because the debugger/tracer is part of lance :|
16:35:44 <elliott> <elliott> I'd like to add a tracing feature to lance, anyway, so you can debug your programs.
16:35:44 <elliott> <elliott> Methinks some of us might find that useful :P
16:35:49 <Gregor> elliott: Mine will be nicer :P
16:36:01 <Ilari> This allocation rate is actually bit slowish compared to one shown in first half of December and on January.
16:36:02 <elliott> Gregor: Mine was going to have an optional ncurses animation of the tape activity.
16:36:05 <elliott> Gregor: NICER THAN THAT, BITCH?
16:36:24 <Gregor> Mine is browser-based :P
16:36:24 <elliott> Mine was going to let you change programs as they run!
16:36:41 <elliott> Gregor: You have a really weird definition of "nicer" that involves using a browser.
16:36:47 <oerjan> <elliott> Gregor: If the count is 0, presumably. <-- depends which side he lets count up and which counts down (they need to be opposite)
16:36:58 <elliott> Gregor: Is it because of your JavaScript-induced brain damage? >:)
16:37:16 <Gregor> *sigh*, the poor unindoctrinated.
16:37:40 <elliott> You can either use a line-based BF Joust debugger with live tape display and program editing capabilities
16:37:44 <elliott> Or a browser-based debugger with none of that
16:37:55 <elliott> Also the former is far faster for obvious reasons (i.e. C vs. JS)
16:38:36 <oerjan> <Gregor> Mine is browser-based :P <-- i sense some escalation here
16:38:47 -!- BeholdMyGlory has quit (Ping timeout: 255 seconds).
16:38:47 <Ilari> 2.89 (primary blocks minus 1 reserved) + 1.58 (ERX) is 4.47 blocks. That would last about 24 weeks (about 5 and half months) at 0.35 blocks per 2 weeks.
16:40:20 <oerjan> Gregor: also if you want my proposed (({{}})%)% extension then ( and { as well as } and ) match in a somewhat parenthesis-like fashion
16:40:42 <elliott> $ ./lance '[>[-]+]' '[>[-]-.-.-.-.-.-]'; echo $?
16:42:59 <elliott> ais523: Any explanation? :-P
16:43:04 <oerjan> elliott: that was correct iirc
16:43:13 <elliott> ais523 said that the former loses
16:43:25 <oerjan> one loses all with one polarity, the other with the other polarity
16:43:38 <elliott> oerjan: no this does only one match
16:43:43 <elliott> return duel(program1, program2, SIEVE, 10);
16:45:08 <elliott> "Right warrior failed to parse, left warrior wins!"
16:45:11 <elliott> looks like sloth didn't parse :D
16:45:24 <elliott> but sloth would have been a better name
16:49:09 * oerjan notes )* is equivalent to {})%
16:51:21 -!- impomatic has joined.
16:52:05 <elliott> ais523: got another set of programs? :P
16:52:23 <ais523> there are plenty on the hill!
16:52:38 <quintopia> elliott: thumbs up on the trace. if it does not flood the screen because it uses curses even better
16:52:41 <elliott> $ ./lance '[>[-]+]' '.'; echo $?
16:52:42 <elliott> $ ./lance '.' '[>[-]+]'; echo $?
16:52:51 <elliott> quintopia: well your commands will flood the screen (it'll be part of the debugger)
16:53:01 <elliott> quintopia: but you could run it in "animation mode" so to speak
16:53:04 <elliott> where the tape would look like
16:53:32 <elliott> with the current cell of the warrior highlighted
16:53:39 <elliott> and if they entered the ... region it'd scroll that part
16:53:43 <elliott> this comes after it replaces egojoust ofc :P
16:56:44 <ais523> impomatic: no, they're planning a new interp
16:56:49 <ais523> that can handle ({}) efficiently
16:56:54 <ais523> but keeping the rules the same
16:57:30 <oerjan> impomatic: it is likely at least two of your warriors will need conversion and resubmission
16:58:00 <oerjan> because you use mismatching ()*n not in the ()*n...()*n format
16:58:44 <elliott> impomatic: what oerjan said
16:58:57 <elliott> also, ([)*nfoo(])*n is Officially Deprecated; I'll probably preprocess it to work, but you should use ({})% from now on
16:59:06 <elliott> but then, the spec has said this all along
16:59:15 <ais523> elliott: preprocess it into ([{foo}])%n
16:59:22 <elliott> ais523: yes, that's what i mean
17:00:02 <elliott> ais523: (A[)*NB(]C)*N -> (A[{B}]C)%n... as for (A[B)*NC(D]E)*N, not sure how to conevrt that
17:00:36 <oerjan> elliott: um the latter is completely similar
17:01:17 <elliott> (A[B)*nC(D]E)*n -> (A[B{C}D]E)%n
17:01:21 <elliott> beyond that i'm not going to bother converting
17:03:06 <elliott> but i want to fix this bug first :D
17:09:04 <impomatic> !bfjoust sexyghoul >(-)*9>(+)*9(>---)*6(>([+{[(-)*7([-{[(-)*122[-]]}])%5]}])%6)*21[-]
17:09:38 <elliott> impomatic: Write a preprocessor :-P
17:09:48 <EgoBot> Score for impomatic_sexyghoul: 32.9
17:09:53 <oerjan> impomatic: um you shouldn't resubmit _yet_, egojoust has big _trouble_ with ()%
17:10:00 <oerjan> oh it worked this time
17:10:35 <oerjan> quintopia: has been complaining about not being able to use %n for n >~ 20. well you didn't, actually.
17:10:47 <impomatic> Does Egojoust only have trouble with ()% if it expands too large?
17:11:08 <oerjan> impomatic: there's at least one definite bug in the code, it miscalculates the resulting program size
17:11:48 <oerjan> (see my lambdabot messages to Gregor earlier)
17:13:01 <oerjan> i think this may cause stray characters to be interpreted after the end of the program.
17:13:30 <oerjan> could be heisenbuggy :/
17:13:52 <oerjan> (note: this is all theoretical)
17:14:04 <oerjan> (except for the fact quintopia _had_ trouble)
17:19:36 <elliott> hm so it actually does timeout
17:19:58 <oerjan> elliott: what times out?
17:20:17 <elliott> $ ./lance '[>[-]+]' '.' | head -c 10; echo
17:20:29 <elliott> hmm so it's not parsing the programs
17:21:38 <elliott> fprintf(stderr, "Oi -- your program is too long.\n");
17:22:58 <elliott> $ ./lance '[>[-]+]' '.'; echo $?
17:22:58 <elliott> Oi -- your program has an unmatched [, and it's all your fault.
17:23:49 <oerjan> elliott: bug: switch (*p) after you already incremented p
17:24:05 <elliott> oerjan: bug was that while block had no {}s :D
17:24:35 <elliott> elliott@elliott-MacBookAir:~/Code/lance$ ./lance '[>[-]+]' '.'; echo $?
17:24:35 <elliott> elliott@elliott-MacBookAir:~/Code/lance$ ./lance '.' '[>[-]+]'; echo $?
17:24:36 -!- quintopia has quit (Ping timeout: 240 seconds).
17:25:23 -!- nescience has quit (Quit: -a-).
17:25:31 <elliott> what does egojoust return if right wins all
17:25:45 -!- BeholdMyGlory has joined.
17:26:38 <oerjan> elliott: return rwins - lwins;
17:26:49 <elliott> oerjan: so what if rwins=0a
17:26:55 <elliott> it'll return a large unsigned value
17:27:00 <elliott> yet, this bug doesn't manifest on the hill
17:27:49 <elliott> [["Kilroy Was Here" is a school play available from Pioneer Drama Services, written by Bill Francoeur and Tim Kelly. Kilroy is a comedy and the setting is a U.S.O. Club ("The Serviceman's 'Home Away From Home'") in Brooklyn in 1942. Ships leaving the nearby Navy yard are being sunk by enemy U-boats. Allied intelligence suspects the club is unknowingly harboring Axis spies. Enter Private Joe Kilroy, a young soldier who draws a curious cartoon face
17:27:49 <elliott> everywhere he goes (and is this causing trouble!). He's the only one who knows where the next Allied convoy will converge. The enemy agents are stopping at nothing to learn his secret. The action builds to an exciting finale during a wild radio broadcast. The score includes such hits as "Don't Say No To The U.S.O.," "Slap That Jukebox," "Jitterbug Saturday Night," and "Rat-a-tat-tat That Rivet," with classic Andrews Sisters style harmony.]] --Wi
17:28:00 <oerjan> elliott: report.c does st = WEXITSTATUS(st);
17:28:03 <elliott> I would remove it but I'm too busy WTFing.
17:28:11 -!- jix_ has joined.
17:28:26 <elliott> i don't see how that can work then
17:28:47 <elliott> oerjan: I have a feeling that it might be calculated such that you always end up with 0 if it loses more than it wins
17:29:37 <Deewiant> Is this one of those times where you've found it already, or not?
17:29:39 <oerjan> elliott: oh hm i vaguely recall that being said
17:29:40 -!- Behold has quit (Ping timeout: 255 seconds).
17:29:41 -!- SimonRC has quit (Ping timeout: 265 seconds).
17:29:41 <Deewiant> I guess you found it or you'd be staring at the channel waiting for an answer
17:29:41 -!- jix has quit (Ping timeout: 255 seconds).
17:29:42 -!- SimonRC has joined.
17:29:44 -!- BeholdMyGlory has quit (Changing host).
17:29:44 -!- BeholdMyGlory has joined.
17:29:54 <elliott> Deewiant: Wow, you're lagged.
17:29:55 -!- nescience has joined.
17:30:25 <Deewiant> I got what I suspect is 8 minutes' worth in the span of 6 seconds
17:30:55 <Deewiant> Guess the server hasn't completely recovered from its issues a few hours back
17:31:11 <elliott> Deewiant: Not 8 minutes I suspect
17:31:20 <elliott> Deewiant: Unless you got a LOT before that while
17:31:28 <Deewiant> Well, I got your "SPOTTE BUG" at 19:43
17:31:40 <Deewiant> And then I got your "$ ./lance" at 19:51
17:31:55 <Deewiant> Along with your "Wow, you're lagged"
17:32:43 -!- Behold has joined.
17:32:43 <elliott> oerjan: erm yes i saw that
17:32:49 <oerjan> 131 win = scores[p1*programCount + p2] * -1;
17:32:49 <oerjan> 133 win = scores[p2*programCount + p1];
17:33:23 <Deewiant> elliott: Anyway, while braces, *p++ and then *p, and using i instead of something like p - begin (if you have both a running index and a running pointer... dude.)
17:33:38 <elliott> Deewiant: ...yeah, why do I have i and p :-D
17:35:16 <oerjan> elliott: anyway is there anything wrong with passing an int through an exit code, as long as it's cast back at the end...
17:35:36 <elliott> Deewiant: *actually* I need i
17:35:39 <elliott> Deewiant: because of comments
17:35:42 <elliott> that get stripped from the result
17:35:45 <elliott> i refers to the position in the /result/
17:35:56 -!- BeholdMyGlory has quit (Ping timeout: 240 seconds).
17:36:05 <elliott> oerjan: well signals do (255 - something)...
17:36:11 <elliott> just sits wrongly with me :D
17:36:47 <oerjan> i guess a signed char would have been less disturbing
17:37:06 -!- Wamanuz2 has joined.
17:38:38 -!- Deewiant has quit (Ping timeout: 240 seconds).
17:41:14 -!- Wamanuz has quit (Ping timeout: 276 seconds).
17:41:47 <oerjan> elliott: hm posix man page for exit shows that only last 8 bits are supposed to be transferred
17:42:06 * elliott just prints out the return for now :P
17:42:37 <elliott> elliott@elliott-MacBookAir:~/Code/lance$ ./lance '.' '[>[-]+]'
17:42:37 <elliott> ..........................................42
17:42:37 <elliott> elliott@elliott-MacBookAir:~/Code/lance$ ./lance '[>[-]+]' '.'
17:42:37 <elliott> ..........................................42
17:45:50 -!- quintopia has joined.
17:45:50 -!- quintopia has quit (Changing host).
17:45:50 -!- quintopia has joined.
17:49:31 <elliott> !c printf("%d\n", -1000 >> 8);
17:49:35 <elliott> also this isn't haskell, - is parsed correctly
17:50:01 <oerjan> i was just looking at #define __WEXITSTATUS(status) (((status) & 0xff00) >> 8)
17:50:36 <oerjan> so if status is signed and 32 bits, this should all give a signed result right
17:51:04 * oerjan doesn't really have a clue here
17:51:33 <oerjan> !c printf("%d\n", -1000 & 0xff00) >> 8)
17:51:38 <oerjan> !c printf("%d\n", -1000 & 0xff00) >> 8);
17:51:51 <oerjan> !c printf("%d\n", (-1000 & 0xff00) >> 8));
17:52:19 <oerjan> !c printf("%d\n", ((-1000) & 0xff00) >> 8));
17:52:36 <oerjan> !c printf("%d\n", ((-1000) & 0xff00) >> 8);
17:53:10 <oerjan> !c printf("%d\n", ((int)(-1000) & 0xff00) >> 8);
17:54:22 <oerjan> the result is put into char later
17:55:31 <oerjan> so as long as char is signed, report.c works.
17:55:54 * oerjan recalls this is not guaranteed
17:56:39 <elliott> hey Gregor can i rewrite half of report.c, sounds like it sucks :D
17:57:11 <Gregor> I thought I checked signdedness somewhere ...
17:57:16 <elliott> oerjan: when you do "return -1;" that gets turned into 255
17:57:28 <elliott> oerjan: before any other process gets it
17:57:32 <elliott> oerjan: what does that do to your logic? :D
17:57:37 <elliott> oerjan: note that st doesn't contain the status
17:57:45 <elliott> it contains the status somewhere, but its format is essentially ill-defined
17:57:53 -!- Deewiant has joined.
17:57:53 <elliott> tl;dr report.c works out of utter chance.
17:58:06 <elliott> I'm not convinced it _does_ work :P
17:58:18 <oerjan> elliott: um it does after the st = WEXITSTATUS(st); surely?
17:58:40 <Deewiant> Lesson learned: if your Internet connection dies, the solution is not to SSH into your firewall and ifdown its LAN interface
17:58:45 <elliott> but it probably just ends up as 255. but then if you put it into signed char, right, it will work
17:58:56 <elliott> Deewiant: You've totally ruined my image of you as infallible, dude.
17:59:14 <elliott> apparently the programs . and [-] draw, whodathunkit?
17:59:51 <Deewiant> The reasoning was that I wanted access to my cable modem, but I didn't quite realize that I was killing my SSH connection in the process
18:00:50 <oerjan> Gregor: just put signed in front of char *scores; i think.
18:01:24 <elliott> I'd just let me rewrite report.c personally :-P
18:03:34 <oerjan> elliott: hm it's not an automatic loss for a program to end, is it? at least . drawing would seem to imply that
18:03:48 <elliott> oerjan: well it should not be. but it may be.
18:04:21 <oerjan> [-] on your own flag loses, right?
18:04:47 <oerjan> elliott: OK I DON'T BELIEVE YOU
18:04:59 <elliott> -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16 -17 -18 -19 -20 -21 -22 -23 -24 -25 -26 -27 -28 -29 -30 -31 -32 -33 -34 -35 -36 -37 -38 -39 -40 -41 -42
18:06:01 <oerjan> um are those the starting positions
18:06:12 <oerjan> and you put the warriors in the same spot?
18:06:23 <elliott> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
18:06:24 <elliott> -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16 -17 -18 -19 -20 -21 -22 -23 -24 -25 -26 -27 -28 -29 -30 -31 -32 -33 -34 -35 -36 -37 -38 -39 -40 -41 -42
18:06:29 <elliott> but [-] doesn't seem to suicide :D
18:06:56 <elliott> if (tape[i?tapesz-1:0] == 0) deathcount[i]++;
18:06:56 <elliott> if (deathcount[0] >= 2 && deathcount[1] >= 2) return 0;
18:06:56 <elliott> else if (deathcount[0] >= 2) return 1;
18:06:56 <elliott> else if (deathcount[1] >= 2) return -1;
18:08:16 <elliott> oerjan: HEY COME BACK HERE
18:14:45 <oerjan> all this gives me the idea of "mexican BFJoust"
18:15:20 <elliott> ais523: http://gcc.gnu.org/onlinedocs/gcc-3.4.1/gcc/Lvalues.html#Lvalues
18:15:52 <oerjan> three warriors, on a circular tape, equidistant, all with > clockwise, say
18:16:44 <elliott> oerjan: wait but a circular tape is just a wrapping tape
18:16:48 <elliott> so the second warrior would be in the middle, say
18:17:32 <oerjan> if the tape has 3n cells, then it wraps, with warriors at positions 0, n, 2n say
18:18:08 <ais523> !bfjoust rule_of_nine (>)*15(+<)*14(>)*14(-[(>)*8((-)*64(-.)*128>)*21]+<)*14(>)*20([(-)*2[+]]>)*8(+.++.)*10000
18:18:46 <ais523> umm, why did I make that leave a trail? obviously that I wasn't thinking
18:21:03 <EgoBot> Score for ais523_rule_of_nine: 0.8
18:22:35 <ais523> !bfjoust rule_of_nine (+>)*9[(-[(>)*8((-)*64(-.)*128>)*21]<)*19(>)*9](+>)*9[(-[(>)*8((-)*64(-.)*128>)*21]<)*19(>)*9](>)*8[--[+]]>[--[.+]](+.++.)*10000
18:22:50 <oerjan> elliott: i see nothing wrong with your above paste
18:23:08 <EgoBot> Score for ais523_rule_of_nine: 0.0
18:33:45 -!- Wamanuz2 has quit (Remote host closed the connection).
18:35:34 -!- Wamanuz has joined.
18:35:45 <ais523> I'm testing rule_of_nine locally now, it's getting better...
18:38:19 <ais523> !bfjoust rule_of_nine (>+)*9(-[(>)*9((-)*64(-.)*128>)*21]+<)*9(>)*9(>+)*9([(-[(>)*9((-)*64(-.)*128>)*21]+<)*18(>)*18)*1000([+.++][+.++]>)*10(+.++.)*100000
18:38:30 <ais523> that still isn't very good, but it should do a lot better than 0
18:38:57 <oerjan> ais523: *100000 is changed to *10000
18:39:06 <EgoBot> Score for ais523_rule_of_nine: 5.0
18:39:32 <ais523> oh, I just meant "until the end of the program"
18:39:32 <oerjan> not that it's likely to matter...
18:41:55 <ais523> !bfjoust speedy1 >>>>>>>>(>-[+[+[---]]])*21
18:42:11 <ais523> umm, there's an obvious fix to /that/ one
18:42:55 <EgoBot> Score for ais523_speedy1: 28.1
18:42:57 -!- asiekierka_ has quit (Ping timeout: 276 seconds).
18:43:32 <ais523> !bfjoust speedy1 >>>>>>>>(>[-[++[---]]])*21
18:43:55 <EgoBot> Score for ais523_speedy1: 31.0
18:44:18 <ais523> let's add a few decoys and see what happens
18:44:32 <ais523> !bfjoust speedy1 >++>-->++>-->>>>(+>[-[++[---]]])*21
18:44:45 <EgoBot> Score for ais523_speedy1: 29.2
18:44:46 <ais523> really, I should change the number now
18:45:10 <ais523> !bfjoust speedy2 >>>>>>>>(>[-[++[---]]])*21
18:45:14 <EgoBot> Score for ais523_speedy1: 0.0
18:45:33 <EgoBot> Score for ais523_speedy2: 31.1
18:45:43 <Gregor> Hmmm, my quick (not yet complete) debugger is working, but it's quite slow :P
18:45:49 <Gregor> Even for "I hacked this up quickly in JavaScript"
18:45:54 <ais523> haha at it being higher up than defend7
18:46:07 <ais523> how the mighty have fallen
18:46:42 <Gregor> Well, actually it's only slow when it has to run all 100K iterations.
18:46:52 <Gregor> Which usually only happens with defend v defend.
18:46:56 -!- MigoMipo has quit (Remote host closed the connection).
18:47:31 -!- MigoMipo has joined.
18:51:07 -!- Tritonio has joined.
18:54:30 -!- hagb4rd has quit (Ping timeout: 240 seconds).
18:55:19 <Gregor> ais523, elliott (haha you don't care), whoever: http://codu.org/eso/bfjoust/egojsout/egojsout.html // Stick a program in each box, click "Run", then click on the result of a particular run to see the step-by-step breakdown. If it takes all 100K iterations, you'll be waiting a while :P
18:55:44 <ais523> Gregor: I've been doing that locally already, but it might be useful for if I'm not at my computer
18:55:53 <Gregor> ais523: This is prettier :P
18:57:32 <ais523> it seems to draw one element beyond the flags on each side, is that deliberate?
18:58:28 <elliott> Gregor: It sucks because it's browser-based any questions!
18:58:39 <ais523> !bfjoust vibration2 >>+<-<(-)*128(+-)*10000(+-)*10000(+-)*10000(+-)*10000(+-)*10000
18:59:36 <EgoBot> Score for ais523_vibration2: 14.4
18:59:45 -!- elliott has quit (Remote host closed the connection).
19:01:39 -!- elliott has joined.
19:02:09 <elliott> Gregor: Mind if I call my rewritten report.c lancealot?
19:02:14 <elliott> Because, you see, it runs lance a lot.
19:02:33 <Gregor> I don't care what you call your report.c since I'll be using my own.
19:02:53 <ais523> !bfjoust vibration2 >>+++<---<(-)*128(+-)*10000(+-)*10000(+-)*10000(+-)*10000(+-)*9939(-)*100
19:03:50 <EgoBot> Score for ais523_vibration2: 12.0
19:04:02 <Gregor> Watching defend14 is a thing of beauty X-D
19:04:03 <elliott> Gregor: But its return code mechanism is insane.
19:04:15 <ais523> Gregor: what should I watch it against?
19:04:23 <ais523> elliott: note that -1 isn't a valid UNIX return code
19:04:34 <elliott> ais523: Yay, so report.c is even more broken.
19:04:35 <Gregor> ais523: Idonno, I was watching it against wireless_frowny
19:05:00 <elliott> Gregor: Srsly, I'm not going to make lance to blatantly invalid things just because report.c does crazy stuff. What's wrong with changing it
19:05:02 <Gregor> Oh, I'm sorry that it doesn't run on the purely-hypothetical OS that doesn't exist and it isn't running on.
19:05:28 <elliott> I don't see why you're so adamant to keep using the exact same code
19:05:41 <Gregor> I'm adamant about bothering you.
19:06:12 <elliott> Enjoy laggy EgoJoust then :-P
19:06:27 <elliott> s/laggy/laggy and broken on %
19:06:41 <Gregor> Yeah, fixing report is TOTALLY going to make it faster X-P
19:07:04 <elliott> Gregor: No, but I'm not going to mess with lance to make it do invalid things and multiply by two arbitrarily just so that report.c doesn't have to change :P
19:07:13 <Gregor> I don't care if you rewrite report, but I'd like to see SOMETHING actually come out of this and if you go "this all sucks because it's not PERFECTION ON A SANDWICH so I'm rewriting it" then instead I'll get nothing.
19:07:42 <elliott> By rewrite I probably just mean tweak
19:08:18 <elliott> Gregor: And hey, it'll stop the reports clashing with each other, so quit yer yappin' :P
19:08:46 <Gregor> MAN, all this debugger is accomplishing is making me realize how wildly outclassed I am >_<
19:09:44 <elliott> Oh yeah? Well LANCE'S debugger uses STRONG AI to make COMMENTARY on the match and SUGGESTS improvements to your program!
19:09:49 <quintopia> does the debugger have drop down menus to select programs from the hill?
19:10:33 <Gregor> elliott: Yeah, I got that :P
19:11:00 <elliott> You could do a dropdown client-side by AJAXXXXXXXin' to in_egobot/ :-P
19:12:13 <elliott> Dammit Emacs, why you forget my font settings
19:12:23 <Gregor> elliott: That's what I'm doing :P
19:12:43 <elliott> Gregor: This is like the one situation where PHP would be appropriate :P
19:12:53 <Gregor> I am using PHP on the server :P
19:12:56 <Gregor> Hence the "more or less" part.
19:13:12 <elliott> Gregor: Why not just send all programs down in a JS object at page load then
19:13:18 <elliott> Unless you thought I meant JS by AJAX.
19:13:27 <elliott> I'm not a horrible excuse for a human being so I don't say AJAX to mean JS.
19:13:32 <Gregor> PHP is generating the original use.
19:13:35 <quintopia> Gregor: i only ask because copypasta is difficult on my phone :P
19:13:46 <Gregor> quintopia: Yeahyeah, I'm doin' it :P
19:14:25 <elliott> Gah, Emacs, give me the right font size
19:14:41 <elliott> I want to size it in PIXELS because you're DUMB
19:15:16 <elliott> (set-default-font "Monospace-10.5")
19:16:53 <elliott> lance: lance.c; $(shell grep '* compile:' $< | cut -d' ' -f4-)
19:16:53 <elliott> I still think this is the best Makefile rule ever written.
19:17:50 <elliott> Sweet, programs still aren't being stored ... somehow ...
19:18:47 <elliott> Looks like my programs are... circular...
19:18:57 <elliott> ...which is cool mind, but not what I was going for.
19:20:55 -!- Tritonio_GR has joined.
19:20:59 -!- Tritonio has quit (Ping timeout: 240 seconds).
19:24:13 <elliott> ..........................................
19:24:59 <elliott> Gregor: How long does it take egojoust to pit [] against [] with all polarities/tape sizes? Not bragging, just really want a point of comparison :-P
19:25:28 <Gregor> I have no friggin' clue, don't care to check, and would be running it on a VM making the comparison meaningless.
19:25:45 <elliott> I'll just assume lance is better then :-P
19:25:54 <elliott> Hmm, it does think that [] beats [>[-]+] though.
19:26:01 <elliott> That doesn't seem...quite...right.
19:26:55 <elliott> And polarity isn't working quite right.
19:26:59 <Sgeo_> Have the Borg met the Changelings?
19:27:39 <elliott> ais523: the polarities are ++ and +- right?
19:27:53 <elliott> ais523: so this is entirely understandable,
19:27:59 <elliott> elliott@elliott-MacBookAir:~/Code/lance$ ./lance '[>[-]+]' '[>[-]+]'
19:27:59 <elliott> ..........................................
19:27:59 <elliott> elliott@elliott-MacBookAir:~/Code/lance$ ./lance '[>[+]-]' '[>[-]+]'
19:27:59 <elliott> ..........................................
19:28:07 <Gregor> There, egojsout now gets the hill from the server.
19:28:07 <elliott> the first isn't understandable
19:28:08 -!- Tritonio_GR has quit (Read error: Connection reset by peer).
19:28:09 <elliott> because it should be a draw
19:28:11 <elliott> but the latter has got me confused :P
19:28:23 <elliott> why is it getting wins wrong...
19:28:28 <ais523> they should both be draws
19:28:41 -!- Tritonio_GR has joined.
19:29:28 <elliott> $ ./lance '[>[-]+]' '[>[-]+]'
19:29:29 <elliott> >>>>>>>>>>>>>>>>>>>>>>X>X>X>X>X>X>X>X>X>X>
19:30:48 <elliott> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
19:32:08 <quintopia> gregor: is bfjsout supposed to do anything but display the breakdowns?
19:32:27 <quintopia> i'm not seeing it step through in realtime >_>
19:32:36 <Gregor> quintopia: Click on an element of the breakdown.
19:33:04 <Gregor> You can't step through real-time for 42 runs (well, I could, but it'd be dumb)
19:33:18 <elliott> XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
19:34:28 <elliott> Gregor: Heh, I like the hex tape display, might steal that >_>
19:35:18 <elliott> Gregor: May I humbly suggest replacing the X with an =, so that it's clearly distinct from the number
19:35:24 <elliott> That vaguely makes sense in context of the comparison operators :P
19:35:28 <elliott> And because the cell is "tied"
19:35:44 <Gregor> elliott: I wasn't thinking comparison operators, I was thinking arrows :P
19:35:48 <Gregor> But I suppose that would be more distinct.
19:35:55 <elliott> It's a pun, it doesn't have to make sense :P
19:36:07 -!- nescience has quit (Read error: Connection reset by peer).
19:38:23 <elliott> My bug was fixed by... recompiling?
19:38:34 <elliott> $ ./lance '[>[-]+]' '[>[+]-]'
19:38:34 <elliott> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
19:39:45 <Gregor> You're always checking the prevalue, right?
19:39:53 <Gregor> Not letting one commit then checking the other?
19:40:20 <elliott> for (int cycles=0; cycles<MAXCYCLES; cycles++) {
19:40:20 <elliott> /* in case the first warrior changes the cell */
19:40:20 <elliott> int saves[2] = {tape[ptrs[0]], tape[ptrs[1]]};
19:40:23 <elliott> And I condition on saves[prog].
19:40:26 <Gregor> Tasted like that family of bug, in this case Idonno :P
19:40:45 <elliott> I think it's a polarity issue or SUMMAT
19:41:20 <elliott> ais523: It's not sufficient when battling {p1,p2} to just do {+p1,+p2}, {+p1,-p2} is it?
19:41:28 <elliott> I think you might have to do {-p1,+p2} as well
19:44:52 <elliott> ais523: No, that's not right...
19:46:30 -!- tswett_ has quit (Remote host closed the connection).
19:47:05 -!- yiyus has quit (Read error: Operation timed out).
19:47:38 <elliott> Gregor: The egojsout trace of [>[+]-] vs. [>[-]+] makes no sense to me (first breakdown).
19:47:49 <quintopia> elliott: +- is identical to -+. check any breakdown.txt
19:47:49 <elliott> They stop in the middle and start doing freaky shit for no apparent reason after spending two cycles doing nothing.
19:48:14 <elliott> They cross over or something.
19:48:19 <elliott> Nope, still makes no sense.
19:49:45 <elliott> Gregor: Does the bottom program appear on the left? x_x
19:50:03 <elliott> BTW, the trace is totally fucked-up for a program like < :P
19:51:10 <quintopia> [[[[ does not actually work as a reverse tripwire avoider in all cases, but it does improve my score O_O
19:51:17 <quintopia> i have no idea what it is doing for me
19:53:51 <ais523> elliott: you only need two, {+p1,+p2} and {+p1,-p2}
19:54:04 <elliott> my trace is totally effed up right now, trying to figure out the problem
19:54:04 <ais523> quintopia: I'm surprised it works at all, although it does
19:54:15 <ais523> it basically has to hit the first tripwire while it's 0, then it works
19:55:54 <quintopia> so it works just often enough to help?
19:56:12 <quintopia> i pretty much kill defend13 and defend14 on every game even without it though
19:56:19 <ais523> no, because you generally beat defend13/defend14 even if you trip the tripwire
19:56:20 <quintopia> so i think it's helping somewhere else
19:56:43 <ais523> I think it might help vs. defend13/14 not by doding the tripwire, but by causing it to misdetect your strategy
19:57:45 <quintopia> i don't think so. i think the [.+] wins regardless of what they think my strategy is
19:58:32 <ais523> incorrect, as seen by the fact that defend14 beats wireless_frownie on a max-length tape
19:59:00 <quintopia> not since i removed that special case :P
19:59:12 <ais523> it actually has a counter-three-cycle-clear in there somewhere, but doesn't trigger it very often
19:59:26 <ais523> basically, three cycle clear can be countered, but only if you know the opponent's using it
19:59:33 <quintopia> the special case did a 2-cycle clear, which is why defend won in that case
19:59:55 <ais523> I should try to find a defend7/10 variant that also deals with three-cycle clears via pure maths
20:00:02 <ais523> but it's kind-of tricky as 3 doesn't divide into 256
20:00:16 <ais523> (defend10 can deal with /four/-cycle clears without issues)
20:00:20 <quintopia> basically, you just have to simulate the thing on all polarities simultaneously
20:00:34 <quintopia> and adjust every place it COULD go to zero by as much as possible
20:00:54 <quintopia> the resulting code would be ugly as shit tho
20:01:00 <ais523> that wouldn't work, due to not knowing the size of the enemy's offset clear
20:01:05 <quintopia> but, imo, all defend code is already :P
20:01:51 <ais523> if you knew the first time the enemy would set your flag to 0 outside an offset, it would be easy
20:01:53 <quintopia> there's gotta be some kind of alternating bump that works for both 2 and 3 cycles though
20:01:57 <ais523> but I can't think of any way to detect that at all
20:02:13 <ais523> note that defend7/10 don't work via bumping at all
20:02:30 <ais523> it's more reliable to drive the opposing program backwards, so that the flag doesn't hit 0 at all
20:02:39 <ais523> that way, they can't detect the 0 and change tactics
20:02:46 <ais523> 7 and 10 both do that on one polarity
20:03:08 <ais523> but it's over a wide range of cycles
20:03:16 <ais523> the timings are chosen so that they accelerate a push in the other direction
20:03:28 <ais523> thus causing the opponent to go over the same sequence each time
20:03:44 <elliott> quintopia: plz stop submitting programs in /msg
20:03:48 <ais523> that does go past 0, potentially, but not for more than a frame
20:03:49 <elliott> it just means we have to look at in_egobot all the time
20:03:54 <elliott> and also, don't see when our programs get knocked off etc.
20:03:55 <ais523> <elliott> please spam the channel
20:04:06 <elliott> it's not like we talk much anyway :P
20:04:15 <ais523> I was just thinking it was opposite to your normal point of view
20:04:25 <elliott> ais523: but yes, it is nice to watch people improve their bots. and also useful for the _rest_ of us players.
20:04:40 <quintopia> elliott: i'll copy the versions i end up leaving to here if that makes you happy
20:04:55 <ais523> elliott: well, I test mine locally, often, before posting them in-channel
20:05:00 <elliott> quintopia: I'd rather just see them all, after all, failed strategies often get copied by others and improved upon
20:05:03 <quintopia> but i'm not going to spam with all the little tests and tweaks
20:05:52 <elliott> so it's not as if you're creating spam out of nowhere
20:05:53 <quintopia> besides, you don't have any competitors on the hill...why are you the advocate?
20:06:39 <ais523> quintopia: elliott isn't on the hill because he isn't very good at BF Joust, rather than because he hasn't tried
20:06:47 <elliott> ais523: hey, I had some programs that were pretty high up first time around
20:06:53 <quintopia> ais523: how reliably can you detect polarity of consistent programs?
20:06:53 -!- yiyus has joined.
20:07:08 <elliott> ais523: I firmly believe I could do well at the current hill, if I spent time studying the existing programs; I just haven't yet
20:07:10 <ais523> quintopia: not completely reliably; I'd say around 50%
20:07:24 <ais523> well, better than that
20:07:26 <elliott> I'm very tempted to write exact_opposite_of_defend13 that specifically counters everything it does
20:07:29 <ais523> I mean 50% better than guessing
20:09:38 <ais523> part of the issue is that detectors can be tricked quite easily
20:09:51 <ais523> sometimes into going into an infinite loop rather than detecting either way
20:09:53 <quintopia> i'm pretty sure there is no way to prevent both 2 and 3 cycle decrementers from hitting zero at *some* point, but i suspect you could create a sequence that bumps both of them indefinitely (with the caveat that one of them could detect it)
20:10:45 <quintopia> namely, you'd let the 2-cycle one be able to detect it
20:10:52 <elliott> AFAICT movement is broken...
20:10:56 <ais523> that seems a little dangerous
20:11:16 <quintopia> the opposite is even more dangerous
20:11:40 <ais523> you can't avoid 0 indefinitely without either a) getting lucky with exact timings (i.e. making both programs do + to go from -1 to +1), or b) knowing both the cycle sequence and polarity of the opponent
20:11:57 <elliott> L80 00 00 00 00 00 00 00 00 R80
20:11:58 <elliott> L80 00 00 00 00 00 00 00 00 R80
20:11:58 <elliott> L7F 00 00 00 00 00 00 00 00 R7F
20:11:58 <elliott> L7F 00 00 00 00 00 00 00 00 R7F
20:11:58 <elliott> L7E 00 00 00 00 00 00 00 00 R80
20:11:58 <elliott> L7E 00 00 00 00 00 00 00 00 R80
20:12:00 <elliott> 7E L00 00 00 00 00 00 00 00 R7F
20:12:02 <elliott> 7E LFF 00 00 00 00 00 00 00 R7F
20:12:06 <elliott> 7E LFF 00 00 00 00 00 00 00 R80
20:12:08 <elliott> 7E LFE 00 00 00 00 00 00 00 R80
20:12:10 <elliott> yeah, that right program is _not_ [>[+]-]
20:12:24 -!- zzo38 has joined.
20:12:41 <quintopia> seems like it is heavily dependent on offset sizes
20:13:20 <ais523> the thing it depends on is impossible to detect
20:13:56 <ais523> pretty much the only thing you could do would be to set up three or four decoys at 128 and count the number of cycles between them being zeroed
20:14:15 <ais523> and then assume the opponent will be consistent in the timing to the next one
20:14:17 <ais523> but there isn't time to do that
20:14:41 <elliott> [>[+]-] spends five ticks on a normal zeroed cell, right?
20:14:50 <quintopia> well, there could be... you'd just have to make time to build a *lot* of decoys
20:15:01 -!- hagb4rd has joined.
20:15:14 <elliott> i mean with normal polarity
20:15:34 <elliott> ais523: I really think that -p1,+p2 might differ from +p1,-p2, because p1 might time out with the other polarity
20:15:38 <elliott> because of a [+] or [-] loop
20:15:45 <elliott> quintopia: hmm, a bug then
20:16:20 <ais523> please understand the concept of symmetry
20:16:36 <elliott> ais523: that only applies when the programs are the same! the point is that with a timeout it's not equivalent
20:16:37 <ais523> -p1, +p2 is always the same as +p1, -p2 because the two runs will be identical, except for each tape element being - that tape element
20:16:44 <elliott> <elliott> ais523: that only applies when the programs are the same! the point is that with a timeout it's not equivalent
20:16:52 <ais523> that makes no difference either
20:17:00 <elliott> you're neglecting that +p1 might have a [-] loop that runs in N ticks
20:17:02 <ais523> after, say, 50 cycles, even if the two programs are different, the two tapes will be the same
20:17:11 <ais523> except for the values in one being minus the values in the other
20:17:33 <elliott> ais523: wouldn't that only apply if the starting tape differed?
20:17:34 <ais523> if +p1 has a [-] loop, -p1 has a [+] loop in the same place, running on a value which is minus the value that +p1 started on
20:17:41 <ais523> the starting tape is minus itself
20:17:43 <quintopia> elliott: yes against a different opponent the breakdowns for the two polarities will be switched when you switch the polarity :P
20:17:45 <ais523> otherwise the symmetry wouldn't work
20:18:48 <elliott> gah, my loop code is broken
20:20:25 -!- zzo38 has quit (Remote host closed the connection).
20:40:52 <Gregor> Added more SWEET debugging to egojsout :)
20:40:59 <Gregor> Click on a particular state for deliciousness :)
20:47:52 <quintopia> Gregor: k, but did you fix the thing where (<(-)*127<(+)*127)*2 doesn't get expanded right? cuz, you know, that's p annoying
20:48:16 <elliott> I like how quintopia wants Gregor to fix bugs without reporting them
20:48:33 <quintopia> elliott: you fix bugs before people find them all the time!
20:49:05 <Gregor> Certainly looks right to me ...
20:49:32 <Gregor> Yup, that's expanded right.
20:50:31 <quintopia> lemme refresh and make sure i'm testing on the latest version
20:52:11 <quintopia> Gregor: yup. it's not doing it right. fight monorail against wireless. you'll see wireless only builds two of the largest decoys before attacking and leaves the two cells nearest its flag zeroed
20:52:24 <quintopia> (put wireless on the right in case it's asymmetric)
20:52:42 <Gregor> >>>>>(<(-)*127<(+)*127)*2>>>>>(>[-])*100 has the correct behavior, btw.
20:52:56 <quintopia> okay, sure, but replicate my test case
20:54:26 <elliott> Gregor: I think it's bugged in that [>[-]+] vs [>[+]-] produces weeeeeeird output.
20:54:33 <elliott> They sort of stop at the middle for some reason.
20:55:44 <quintopia> i bet he typed that with a perfectly straight face too
20:55:49 <Gregor> quintopia: E_CANNOTREPRO
20:55:55 -!- elliott has left (?).
20:55:58 -!- elliott has joined.
20:56:10 <elliott> <quintopia> i bet he typed that with a perfectly straight face too
20:56:28 <elliott> I generally don't expect loops to start when the tape pointer is on a zero.
20:57:26 <elliott> Maybe it's a BROWSER INCOMPATIBILITY.
20:58:00 <Gregor> It's not, it's a quintopia-is-doing-something-wrong-incompatibility :P
20:59:10 <quintopia> Gregor: i'm getting you a screencap of what is happening
20:59:27 -!- R0b0t1 has joined.
21:00:31 <ais523> elliott: the + in the first program cancels out the - in the second program, then they both escape from their main loops
21:00:35 <quintopia> gregor: http://imgur.com/qchSQ do you not see this in your trace?
21:00:39 <ais523> and NOP forever due to hitting the end of the program
21:00:47 <Gregor> R0b0t1: Yup, that's pretty lame :P
21:00:48 <elliott> ais523: that's not what i got in egobfjsout
21:00:53 <ais523> I doubt that program will do particularly well
21:01:00 <EgoBot> Score for R0b0t1_lame: 10.8
21:01:13 <Gregor> quintopia: No. Browser/platform?
21:01:20 <ais523> heh, it isn't even last
21:01:30 <Gregor> quintopia: And this was wireless, right? Not wireless_whateverthatotheroneis?
21:01:45 <quintopia> wireless currently has the code i mention above in it
21:04:02 <elliott> Gregor: BROWSER INCOMPATIBILITY
21:04:10 <Gregor> elliott: Not as far as I can tell.
21:04:22 <elliott> Because that would be SO 90s.
21:04:26 <EgoBot> Score for R0b0t1_lame2: 14.9
21:04:41 <elliott> R0b0t1: hi, how did you find out about this place? the wiki? I suspect so since bf joust isn't exactly well known
21:04:46 <quintopia> but one that sucks more because it actually loops and therefore suicides
21:06:16 <ais523> elliott: it was posted on reddit once
21:06:16 <quintopia> Gregor: it only happens in that particular trace for some reason
21:06:26 <elliott> ais523: that would be a pretty delayed reaction
21:06:28 <ais523> I can't remember if anyone turned up here and stayed as a result
21:06:45 <Gregor> quintopia: There is a race condition, did you wait for it to finish running all traces before drilling down one?
21:06:45 <ais523> and ofc, #irp exists merely as a honeypot for Redditors
21:06:49 <quintopia> Gregor: also, you need to make it so when you click on a different trace it stops ... yeah
21:07:09 <Gregor> quintopia: That race condition is actually REALLY FREAKING DIFFICULT to fix, so I didn't bother with it :P
21:07:27 <quintopia> Gregor: well, that's not what caused this. that was the first trace i clicked on after loading and running
21:08:05 <ais523> Gregor: have a global variable that specifies the stats of the trace that's running, stop looping if it's set different to the trace that you're generating
21:08:12 <ais523> that's not so REALLY FREAKING DIFFICULT, is it?
21:08:24 <Gregor> ais523: Feh, I could do that :P
21:08:31 <elliott> ais523: be kind, Gregor is a javascript programmer, he doesn't understand such complex things!
21:08:32 <Gregor> ais523: But I can also fix it a little bit better, which I will in ~2hr
21:08:35 <elliott> maybe you want to use lance instead
21:08:38 <elliott> (countdown to "fuck you"...)
21:09:47 <ais523> how often do we have warring interps for any particular esolang?
21:10:02 <ais523> cfunge vs. CCBI (not really vs. Shiro, as it came at a different time)
21:10:02 <Gregor> quintopia: Idonno what to tell you, it works perfectly.
21:10:09 <ais523> esotope vs. in-between
21:10:39 <quintopia> Gregor: yeah, i can't repro it now either. i repro'd it twice perfectly and now nothing! heisenbug?
21:10:45 <elliott> also, esotope vs. inbetween wasn't much of a war
21:10:53 <ais523> yep, because Vorpal got bored
21:10:54 <coppro> fun fact: windows has three file path separators. quiz: what are they?
21:10:54 <elliott> that was just me mocking V*rpal for copy-paste code, which i also did when he was doing cfunge :P
21:11:29 <quintopia> coppro: \ is the main accepted one
21:13:37 <ais523> coppro: \ for legacy purposes, / for modern use, : as the drive separator
21:16:49 <elliott> someone take the credit for that; coppro won't see it
21:17:00 -!- pumpkin has joined.
21:17:33 <elliott> ais523: interestingly in cmd.exe, / = .\
21:17:41 <R0b0t1> It works on every version, I think, it's just rather hard to type the ¥ symbol on some computers.
21:17:54 <coppro> I just tried it. It does not work on 7.
21:20:37 -!- copumpkin has quit (Ping timeout: 260 seconds).
21:20:50 <elliott> hmm, are you sure? I think it's a locale-specific thing, originally just because the \ octet showed as the yen sign in shift-jis, then retained for idiot-compatibility
21:20:59 <impomatic> I'm just reading "The Tao of Programming" again :-)
21:21:04 <elliott> I would expect that it just special-cases the japanese locale but I may be wrong, perhaps for software compatibility
21:21:11 <R0b0t1> Well, on XP I remember seeing it on some autoconfigure scripts.
21:21:20 <R0b0t1> Not sure about 7. Still haven't used it :)
21:21:51 <ais523> it's strange how programs can drop down the leaderboard merely due to a change in the composition of the hill, not because they're being outcompeted
21:22:09 <coppro> (the actual truth is that it's locale-dependent)
21:22:12 <ais523> e.g. a program can drop below another one that stays in much the same place
21:22:14 <Deewiant> maglev at some point beat everything that was above it
21:22:25 <ais523> that doesn't surprise me at all
21:22:32 <coppro> the yen and won symbols are path separators in Japanese and Korean locales, respectively
21:23:58 <elliott> ais523: that's just because of the scoring system
21:24:17 <elliott> if it suddenly turns out that your big win against a major player was actually not as impressive, you should drop down
21:24:18 <ais523> not even because of the scoring system, it would happen with a naive scoring system too
21:24:28 <ais523> as the programs that you're measured against change
21:24:39 <ais523> if, say, lots of defence programs end up on the hill
21:24:44 <ais523> then programs that do well vs. defence will do well
21:24:50 <ais523> and as a result, all defence programs will start dropping down
21:24:55 <quintopia> ais523: i see now what you mean about defend9 guessing timings. it does an admirable job with wireless (probably due to the small offset size it uses)
21:25:05 <ais523> because counter-defence stays on the hill longer
21:25:26 <ais523> and more counter-defence will get up there and push away programs that might be more vulnerable to it
21:25:46 <elliott> now why is lance so broken
21:25:57 <elliott> you know what's the worst? off-by0one errors
21:26:02 <elliott> they're so sneaky and tricksy and heisenbuggy
21:26:33 <elliott> I would like to amend the famous quote:
21:26:33 * quintopia hits elliott with a fencepost ===========>
21:26:43 <elliott> There are only two hard things in Computer Science: cache invalidation, naming things, and off-by-one errors
21:26:49 <Gregor> There, fixed the race condition X-P
21:28:57 <coppro> now I want to intentionally throw a technical interview by answering "what is a race condition" by answering "when a bunch of programs line up in the same place and, at a signal, each start moving as fast as they can to get to the destination. Like in Tron, or Reboot."
21:29:04 <elliott> There are only two hard things in Computer Science: cache invalidation and naming things.
21:29:48 <Gregor> "Like in Tron, or Reboot" X-D
21:29:49 <quintopia> There are only two hard things in Computer Science: interfacing with Facebook and my sexy body.
21:30:13 <Gregor> elliott: What, do you have pooppy on ignore now?
21:30:45 <elliott> Gregor: Yes, ever since the entire list of topics he talked about became "mentioning that I'm on ignore and how much better the channel is when it's nearly silent^W^Wlacking me, and complaining about Minecraft talk".
21:38:23 <ais523> elliott: that computer science joke seems to have its own local version of Muphry's Law, at least on the Internet
21:38:28 <ais523> in that people nearly always seem to mess them up, or at least you do
21:38:46 <elliott> ais523: I copy+pasted it, and added "off-by-one errors"
21:38:54 <elliott> If you mean that I said "two" instead of "three" hard things... that's the joke.
21:39:49 <ais523> elliott: I mean the correction to add the full stop
21:39:59 <ais523> you've made a typo every single time you've done that joke
21:40:10 <elliott> ais523: how often have I done it?
21:40:33 <elliott> 20:24:51 <variable> The REAL two hardest problems in CS: Cache Invalidation, Naming Things, and Off by One Errors.
21:40:34 <elliott> 20:25:33 <coppro> when did #esoteric become #uncyclopedia
21:40:36 <elliott> 20:25:55 <pikhq> Presumably variable is writing an Oscar Wilde language.
21:40:38 <elliott> 20:26:15 <oerjan> but was that off by one error caused by a cache invalidation?
21:40:40 <elliott> doesn't appear to have context
21:40:44 <ais523> elliott: twice, or maybe three times
21:42:32 <elliott> "int foo[N];" is guaranteed to be zero-filled, right?
21:43:24 <elliott> I know that "int foo;" is 0.
21:43:56 <variable> <elliott> 20:25:33 <coppro> when did #esoteric become #uncyclopedia --> explain ?
21:44:18 <elliott> wasn't that _months_ ago that i quoted that
21:44:27 <ais523> elliott: it was also earlier today
21:44:50 <ais523> I mean, it was elliott who quoted that
21:44:55 <elliott> variable: someone did a fake abraham lincoln quote before
21:45:03 <elliott> or was it oscar wilde... think it was abraham lincoln
21:45:23 <elliott> 20:23:44 <variable> â<80><9c>The problem with Internet quotations is that many are not genuine.â<80><9d> - Abraham Lincoln
21:45:23 <elliott> 20:24:32 <oerjan> "Abraham Lincoln never said that." - Oscar Wilde
21:45:23 <elliott> 20:24:51 <variable> The REAL two hardest problems in CS: Cache Invalidation, Naming Things, and Off by One Errors.
21:45:23 <variable> elliott: but you didn't say the joke properly
21:45:24 <elliott> 20:25:33 <coppro> when did #esoteric become #uncyclopedia
21:46:14 <elliott> I thought I invented adding off by one errors to it, probably subconciouscly stole it from you
21:46:48 <variable> <elliott> There are only two hard things in Computer Science: cache invalidation and naming things. -> no off-by-one errors part
21:47:03 <elliott> variable: um that's what the _actual_ quote is
21:47:19 <elliott> <elliott> I would like to amend the famous quote:
21:47:21 <elliott> <elliott> There are only two hard things in Computer Science: cache invalidation, naming things, and off-by-one errors
21:47:26 <elliott> <quintopia> what was the original quote
21:47:26 <elliott> <elliott> There are only two hard things in Computer Science: cache invalidation and naming things.
21:47:34 <variable> elliott: ah ok - I didn't read that far up
21:47:59 <elliott> `addquote <variable> stealing things from me is ok <variable> sometimes <variable> like quotes
21:48:49 <HackEgo> 303) <variable> stealing things from me is ok <variable> sometimes <variable> like quotes
21:54:50 -!- Mathnerd314 has joined.
21:58:19 <elliott> ais523: E17 reached 1.0 last month
21:58:32 <elliott> ais523: now /that's/ more surprising than Duke Nukem Forever
21:58:48 <ais523> I didn't realise it was so delayed
21:59:13 <elliott> ais523: it's been in pretty much constant 0.0.0.0.0.000000000000000.1 release stage
21:59:29 <elliott> (that doesn't stop anyone using it, though, it just had a drawn-out release cycle)
22:00:13 -!- augur has changed nick to TheDoctor.
22:00:19 -!- TheDoctor has changed nick to augur.
22:10:11 -!- Tritonio_GR has quit (Quit: Leaving).
22:10:42 -!- nescience has joined.
22:10:55 <Gregor> !bfjoust mapping_turtle -(>(+)*9>(-)*9)*4>([(+)*120(+.)*16.+>]+>[(+)*120(+.)*16.->]->)*11
22:11:19 <EgoBot> Score for Gregor_mapping_turtle: 51.3
22:11:54 <Deewiant> Oh well, maglev and monorail beat it no problem
22:12:48 <Gregor> Yeah, I'm just in the right sideo of the triangle-o-wins :P
22:12:59 <Gregor> !bfjoust mapping_turtle -(>(+)*10>(-)*10)*4>([(+)*120(+.)*16.+>]+>[(+)*120(+.)*16.->]->)*11
22:13:42 <EgoBot> Score for Gregor_mapping_turtle: 55.2
22:13:53 <Deewiant> !bfjoust -(>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(+)*9[-]])*20>(.+)*10000
22:13:54 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
22:13:58 <Deewiant> !bfjoust maglev -(>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(+)*9[-]])*20>(.+)*10000
22:14:15 <elliott> Gregor: I was expecting "arson murder shit-eating turtle wanker" after your progression
22:14:21 <Gregor> Oh I momentarily hit number one LA LA LA LA NUMBER ONE ONE ONE
22:14:27 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
22:14:38 <EgoBot> Score for Deewiant_maglev: 47.7
22:14:46 <elliott> Gregor: See with lance, nothing at fucking all would change, carry on.
22:14:49 <Deewiant> !bfjoust maglev -(>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(+)*9[-]])*21
22:14:58 <Gregor> I could do better if I killed rapping_turtle, but I'm not quite that dishonest :P
22:15:00 <elliott> ais523: GREGOR IS AT #1, PANIC PANIC PANIC
22:15:11 <EgoBot> Score for Deewiant_maglev: 47.5
22:15:12 <elliott> ais523: -(>(+)*10>(-)*10)*4>([(+)*120(+.)*16.+>]+>[(+)*120(+.)*16.->]->)*11
22:15:16 <ais523> umm, that shows how badly I can typo while not concentrating
22:15:22 <Deewiant> !bfjoust maglev -(>)*8<+<-<(+)*10<(-)*10<(-)*30<<(+)*42(>)*7(>[(+)*9[-]])*20>(.+)*10000
22:15:24 <elliott> Which one of your wives wrote that program Gregor
22:15:29 <ais523> oh, it's just a blatant 128-detector
22:15:36 <Gregor> ais523: All the turtles are.
22:15:48 <EgoBot> Score for Deewiant_maglev: 47.7
22:15:52 <ais523> the fact that those are doing so well means that we need more fast attack programs, and that adjusting your own flag may soon be a good strategy
22:15:53 <Gregor> Will you all go "HEY DISHONEST" if I kill crapping_turtle?
22:16:01 <ais523> I don't think it's dishonest
22:16:10 <Gregor> !bfjoust crapping_turtle <
22:16:15 <ais523> but it's one that does far too well in the current hill
22:16:17 <Gregor> It's not a strategy, I just don't like having old things floating around.
22:16:23 <elliott> !bfjoust (>)*9([(-)*128[-]]>)*20
22:16:23 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
22:16:26 <EgoBot> Score for Gregor_crapping_turtle: 0.0
22:16:36 <elliott> !bfjoust shitting_tortoise (>)*9([(-)*128[-]]>)*20
22:16:41 <elliott> I'm carrying Gregor's naming convention on.
22:16:41 <Gregor> HOW IS DIRK STILL ALIVE
22:16:55 <Gregor> elliott: So long as you keep "tortoise" only :P
22:17:00 <EgoBot> Score for elliott_shitting_tortoise: 13.8
22:17:06 <elliott> Gregor: Have you copyrighted "turtle"?
22:17:19 <Gregor> elliott: No, but within the scope of BF Joust programs it's my trademark.
22:17:29 <elliott> !bfjoust shitting_tortoise >-(>+>-)*4([(-)*128[-]]>)*20
22:18:17 <EgoBot> Score for elliott_shitting_tortoise: 10.2
22:18:43 <elliott> !bfjoust shifting_tortoise (-)*127>+(>->+)*4([(-)*128[-]]>)*20
22:18:51 <elliott> !bfjoust shitting_tortoise <
22:19:07 <Gregor> How can dirk STILL BE THERE
22:19:11 <Gregor> How is it even possible.
22:19:13 <Gregor> Somebody knock it off.
22:19:24 <Gregor> It's like it only wins against programs which are overall better than it.
22:19:29 <Gregor> (And not already on the hill)
22:19:35 <EgoBot> Score for elliott_shifting_tortoise: 20.8
22:19:36 <EgoBot> Score for elliott_shitting_tortoise: 0.0
22:20:04 <elliott> Gregor: Dude, dirk is too close to shitting tortoise :P
22:20:17 <Gregor> elliott: dirk is shortsword with trivial modification.
22:20:20 <elliott> !bfjoust shifting_tortoise (-)*127>+>-(>)*8([(-)*128[-]]>)*20
22:20:39 <EgoBot> Score for elliott_shifting_tortoise: 22.4
22:24:18 <elliott> !bfjoust shifting_tortoise (-)*127>+>-(>)*8([(-)*64[+]]>)*10([(-)*128[-]]>)*10
22:25:29 * Gregor is shocked beyond belief to still be #1 :P
22:25:41 <EgoBot> Use: !bfjoust <program name> <program> . Scoreboard, programs, and a description of score calculation are at http://codu.org/eso/bfjoust/
22:26:40 <EgoBot> Score for elliott_shifting_tortoise: 22.2
22:27:04 <Deewiant> !bfjoust overshot (>)*15(>[(-)*127[+]])*15
22:27:12 <elliott> $ ./lance '[>[-]+]' '[>[+]-]'
22:27:12 <elliott> ==========================================
22:27:49 <EgoBot> Score for Deewiant_overshot: 1.6
22:29:22 <Gregor> Deewiant: (-)*127[+] is ... an odd choice.
22:29:34 <Gregor> Since if you leave the flag as is, that'll take for friggin' ever to zero it.
22:29:40 <ais523> how not to do an offset clear!
22:29:40 <Deewiant> I was aiming for mapping_turtle
22:30:08 <Deewiant> And am unsure why it only wins in one tape size
22:30:18 <Deewiant> Well sure, it'll only win in one polarity
22:30:20 <elliott> Looks like lance does basic programs perfectly, now to ping oerjan so I can get him to briefly walk me through the efficient {}% stuff
22:30:37 <Gregor> elliott: His explanation that you pasted at me was perfec.t
22:30:56 <elliott> Gregor: It's a bit vague and unassured-sounding for my tastes, but okay.
22:31:27 -!- nescience has quit (Ping timeout: 240 seconds).
22:33:12 <Deewiant> !bfjoust misoffset (>)*8(>[(-)*127[+]])*21
22:34:44 <elliott> !bfjoust be_well_to_strangers -------------------------------------------------------------------------------------------------------------------------------[----++++]
22:35:33 <elliott> 16:19:28 <elliott> 13:54:34 <oerjan> elliott: basically ( pushes starting count on the stack, { iterates back to matching ( or pops, } pushes like (, and ) iterates or pops
22:35:33 <elliott> 16:19:28 <elliott> 13:55:13 <oerjan> and provided [] matches inside () and inside {} like the rule is supposedly already, it should all work
22:35:33 <elliott> 16:19:28 <elliott> 13:56:05 <oerjan> hm i guess } and ) need to count the reverse way of ( and {
22:35:54 <elliott> hmm Gregor do you make sure to take into account that (){} all take 0 ticks
22:36:12 <elliott> I can easily do that with... A GOTO
22:36:22 <Gregor> Or ... a while loop :P
22:36:44 <elliott> 16:19:28 <elliott> 13:56:05 <oerjan> hm i guess } and ) need to count the reverse way of ( and {
22:36:46 <elliott> What's that supposed to mean
22:37:20 <EgoBot> Score for elliott_be_well_to_strangers: 14.7
22:37:21 <EgoBot> Score for Deewiant_misoffset: 12.9
22:37:22 <Gregor> I'm not sure, I thought it was in reference to the fact that ({ are a matching pair and }) are a matching pair.
22:37:57 <Gregor> In his head probably he was counting up for one, then doing the middle, then counting down, but of course you don't NEED to do it that way.
22:38:28 <elliott> You can just reset the count
22:38:35 <Deewiant> !bfjoust hayaku (>)*8(>[[+]])*21
22:38:35 <elliott> To be what it is in the program
22:39:02 <elliott> The instructions in lance:
22:39:11 <elliott> ENDP, DINK, DONK, ONWD, RTRT, WAIT, LOOP, POOL, PARE, ERAP, ONCE, ECNO
22:39:15 <EgoBot> Score for Deewiant_hayaku: 6.6
22:39:28 * Gregor huggles mapping_turtle
22:39:47 <Deewiant> !bfjoust hayaku (>)*8(>[(-)*11[+]])*21
22:40:29 <EgoBot> Score for Deewiant_hayaku: 12.4
22:40:45 <Deewiant> !bfjoust ac (>)*8(>[(-)*11[+]]>[(+)*11[-]])*10>(-)*127[+]
22:41:58 <EgoBot> Score for Deewiant_ac: 12.1
22:42:44 <Deewiant> !bfjoust ac +(>->+)*4(>[(-)*11[+]]>[(+)*11[-]])*10>(-)*127[+]
22:43:29 -!- nescience has joined.
22:43:29 <EgoBot> Score for Deewiant_ac: 23.9
22:43:45 <Deewiant> Darn, mapping_turtle is still 0.02 score higher than the second
22:43:56 <nescience> I was expecting it to show up in the wifi list like my (windows 7) laptop
22:44:01 <Gregor> Only .02, 'snot enough
22:44:01 <Deewiant> !bfjoust ac +(>->+)*4(>[(-)*11[+]]>[(+)*11[-]])*10
22:44:14 <Gregor> Deewiant: WHY YA GOTTA BRING ME DOWN
22:44:33 <Deewiant> I don't like jousters at the top that all my programs beat :-D
22:44:53 <EgoBot> Score for Deewiant_ac: 22.1
22:45:44 <elliott> Man, I should probably use a less hacky parser than I'm using now, it's insane.
22:48:12 <elliott> Gregor: Am I right in thinking that * and % are treated identically with these semantics?
22:48:42 <Gregor> elliott: I ignore which is used in egojsout :P
22:49:03 <Gregor> Since your use of {} or not implies % or *
22:49:06 <elliott> Gregor: Propose, perhaps, that we deprecate % in favour of * then?
22:49:14 <elliott> % is quite an ugly character.
22:49:41 <ais523> I was just trying to make the difference clearer
22:49:53 <ais523> and I think they might be different with oerjan's idea of (( {{}})%n)%n
22:50:02 <ais523> why don't you just parse them as identical?
22:50:17 <Gregor> ais523: That's what I do, and wtf does (({{}})) do
22:50:18 <elliott> ais523: they're not different with his idea
22:50:30 <elliott> Gregor: You handle that with the algo oerjan gave you
22:50:35 <elliott> it's what he invented it for
22:50:45 <elliott> ais523: Parsing them as identical, suuure, but redundant syntax is irksome. Especially in BF.
22:51:03 <ais523> context-sensitive commands is irksome too
22:51:10 <ais523> but I don't really care
22:51:14 <elliott> { and } aren't context-sensitive the way oerjan does it.
22:51:20 <elliott> { is a right bracket to ('s left.
22:51:28 <elliott> It's just that } looks at the ( before it.
22:51:45 <ais523> yep, and then for the % after the matching )
22:51:58 <elliott> that's not how it works in oerjan's semantics
22:52:00 <elliott> you store the count in the (
22:52:01 <ais523> otherwise, how does it know how many times to repeat?
22:52:08 <elliott> you could store it in the ) too, but it'd be redundant.
22:52:21 <ais523> ah, so the ( copies the count from the )% on parse?
22:52:31 <elliott> ais523: <oerjan> elliott: basically ( pushes starting count on the stack, { iterates back to matching ( or pops, } pushes like (, and ) iterates or pops
22:52:35 <ais523> in that case % does need to be different from *, as the ( wouldn't copy the count from a )*
22:52:43 <elliott> <oerjan> elliott: basically ( pushes starting count on the stack, { iterates back to matching ( or pops, } pushes like (, and ) iterates or pops
22:53:14 <elliott> egojsout does it this way :P
22:53:41 <elliott> Also: Do we forbid *0? I kind of like it because you can use it for comments.
22:53:55 <ais523> ooh, I like *0 for comments too
22:54:08 <ais523> as [...][comment] isn't a comment in BF Joust
22:54:18 <elliott> You could even strip it (but I won't bother to start with since it'll be skipped over immediately).
22:54:20 * Gregor fixes that in egojsout :P
22:54:35 <elliott> Woo, so I have to use strtol because atoi uses 0 to signal errors :P
22:55:17 <ais523> that's quite some error recovery
22:55:53 <oerjan> <Gregor> In his head probably he was counting up for one, then doing the middle, then counting down, but of course you don't NEED to do it that way. <-- um yes you do. that's the way you ensure that jumping directly between [] in there doesn't require changing the counter stack
22:55:58 <ais523> using a legit return as an error return
22:56:15 <elliott> Bleh, strtol allows whitespace before the number. I'll just parse it manually.
22:56:19 <elliott> Base 10, how hard can it be.
22:56:23 <nescience> oh, are you writing the new interpreter?
22:56:34 <elliott> nescience: With efficient () parsing.
22:56:41 <elliott> nescience: Note that (a{b}c)%n is now (a{b}c)*n.
22:56:57 <elliott> Because % turned out to be redundant.
22:57:11 <quintopia> !bfjoust superfast_jellyfish +>(+)*128>>>>>>>>([-[++[(+)*15[(.-)*3]]]]>)*21
22:57:16 <elliott> nescience: Additionally, (A[B)*nC(D]E)*n is Highly Deprecated, but will be supported with a preprocessor.
22:57:22 <elliott> nescience: Please use {} in future programs.
22:57:35 <elliott> nescience: Such repeats _without_ trivially-matching []s are *banned*.
22:57:35 <nescience> I only used the other because the % loop failed
22:57:56 <nescience> like, I wrote it and it didn't work
22:57:58 <elliott> Banned as in the program will literally reject them because interpreting them efficiently is ~impossible.
22:58:01 <elliott> nescience: Yeah, blame egojoust :P
22:58:24 <oerjan> <ais523> and I think they might be different with oerjan's idea of (({{}})%n)%n <-- not that i know of
22:58:48 <ais523> oerjan: ((({{}})%n)*n)%n, insert commands between the parens as appropriate
22:58:49 <nescience> how fast does it do Defend now? :)
22:59:05 <ais523> the {s couldn't tell which *s they matched if % and * were the same character
22:59:31 <nescience> just don't allow traversal of } and )?
22:59:50 <nescience> if everything is balanced it should be able to tell
23:00:43 <ais523> elliott: ((({{}})*)%)% has different semantics from ((({{}})%)%)*
23:00:47 <elliott> fprintf(stderr, "%d : Oi -- you have a * not followed by a digit. Did your parents drop you on your head as a kid?\n", n);
23:00:48 <lambdabot> Source not found. I can't hear you -- I'm using the scrambler.
23:00:50 <lambdabot> Source not found. You speak an infinite deal of nothing
23:00:52 <ais523> (assuming there are actual commands and numbers there)
23:00:53 <lambdabot> Source not found. My pet ferret can type better than you!
23:00:54 <lambdabot> Source not found. My pet ferret can type better than you!
23:00:55 <lambdabot> Source not found. Sorry about this, I know it's a bit silly.
23:00:59 <lambdabot> Source not found. You speak an infinite deal of nothing
23:01:04 <elliott> Argh, where's the insulting ones :P
23:01:05 <oerjan> <elliott> { and } aren't context-sensitive the way oerjan does it. <-- actually it is slightly context-sensitive, you actually need to do that ({ and }) matching separately from the rest, so it's the _intersection_ of two context-free languages (i just thought this up while away)
23:01:12 <lambdabot> Source not found. Do you think like you type?
23:01:18 <elliott> oerjan: i wasn't talking language-wise :D
23:01:18 <ais523> that seems rather un-Haskellish
23:01:21 <lambdabot> Source not found. That's something I cannot allow to happen.
23:01:25 <lambdabot> Source not found. Wrong! You cheating scum!
23:01:38 <ais523> also, what's with the spaces in that last message?
23:01:51 <elliott> ais523: presumably the insults are in a separate list
23:01:57 <elliott> to the "Source not found." message
23:01:58 <lambdabot> Source not found. You speak an infinite deal of nothing
23:02:13 <oerjan> <ais523> in that case % does need to be different from *, as the ( wouldn't copy the count from a )* <-- ( doesn't _have_ to be different, although either ( or ) must be slightly different i think
23:02:13 <lambdabot> Source not found. Just what do you think you're doing Dave?
23:02:14 <quintopia> can we not disallow (({{}}))? it seems more complicated than it's worth
23:02:15 <ais523> so, it still needs to be declared somewhere
23:02:33 <elliott> oerjan: hmm, so we still need %?
23:02:36 <ais523> oerjan: the thing is about knowing which */% matches which ( when parsing
23:02:38 <elliott> he doesn't distinguish between them
23:02:51 <ais523> you can use the same representation at runtime I think
23:02:59 <ais523> but you need to initialise the counts differently at parsetime
23:03:05 <nescience> obviously it belongs to the one at the proper level
23:03:32 <nescience> I must be missing something here because it seems obvious
23:04:16 <elliott> oerjan: can you test your example with Gregor's efobfjsoust?
23:04:20 <Gregor> Oooh, look who's still #1 on the hill.
23:04:25 <elliott> it doesn't distinguish * and % and implements your trick
23:04:29 <ais523> oerjan: what are the semantics of (({})*)% meant to be anyway?
23:05:13 -!- FireFly has quit (Quit: swatted to death).
23:05:26 <ais523> I don't see how it makes any sense at all
23:05:33 -!- hagb4rd has quit (Quit: hagb4rd).
23:05:37 <ais523> e.g. what does (a(b{c}d)*2)%2 expand to?
23:05:41 <Gregor> I can't think of anything that is both sensible and not super-confusing.
23:06:13 <EgoBot> Score for quintopia_superfast_jellyfish: 33.6
23:06:56 <nescience> that looks an awful lot like careless, what differentiates it? it seems to attack every other cell?
23:07:02 <elliott> No speed complaints until lance is deployed :P
23:07:12 <quintopia> GUESS WHICH GUISE! shudderalikes are about to fall off the scoreboard...
23:07:47 <elliott> lance.c:182: error: a label can only be part of a statement and a declaration is not a statement
23:08:00 <elliott> quintopia: Because you've been doing things in /msg and hiding things from us? :|
23:08:12 <elliott> Deewiant: "int repeat = 0;"
23:08:17 <elliott> nescience: join my anti-/msg-submitters brigade!
23:08:20 <Deewiant> elliott: Run clang over it :-P
23:08:23 <quintopia> nescience: the innovation i was hoping would accomplish something was the [(.+)*3] thing
23:08:30 <oerjan> <ais523> oerjan: ((({{}})%n)*n)%n, insert commands between the parens as appropriate <-- i consider that illegal with my implementation idea, since it would require keeping track of _which_ iteration of *n you are recursing, each time. there should intuitively be only _one_ {} for each () after expansion
23:08:31 <quintopia> elliott: not since you complained this morning
23:08:46 <elliott> quintopia: oh, so you're just going to like
23:08:58 <ais523> oerjan: indeed, I mentioned a little later that it didn't make any sense
23:09:00 <nescience> looks similar to careless.. just attacks +-16 and moves on
23:09:10 <elliott> quintopia: <quintopia> GUESS WHICH GUISE! shudderalikes are about to fall off the scoreboard...
23:09:10 <ais523> so we're banning {} if there's a * inside the matching %?
23:09:28 <elliott> ais523: Rather, it'll just take on whatever interpretation it takes on, since again * = % for all legal programs.
23:09:28 <ais523> are shudderalikes popular because they're easy to write?
23:09:28 <quintopia> elliott: well, yeah. i mean. as soon as some more good programs get submitted :P
23:09:37 <elliott> And since illegal programs are... illegal, we can again unify * and % :P
23:10:08 <nescience> but with the work I did the other day they should be easier to trivially beat
23:10:09 <elliott> Their easy-to-writeness is nice, though
23:10:13 <elliott> Anyone can write a shudder :P
23:10:35 <ais523> <da Doctah> My college required two years of a foreign language as an entrance requirement; I managed to get them to accept Fortran.
23:10:51 <elliott> Deewiant: lance.c:182:9: error: expected expression
23:10:54 <quintopia> 44 26 20.53 -20.79 impomatic_self_aware_brainfuck.bfjoust
23:11:00 <nescience> but I don't like them because they kind of can't be successful by definition
23:11:07 <ais523> elliott: is that a clang message?
23:11:13 <Deewiant> elliott: You can't put a declaration there
23:11:20 <ais523> elliott: ah, you can't label a declaration, only a statement
23:11:26 <elliott> I want to put declarations EVERYWHERE
23:11:35 <elliott> Dammit C, I hate your guts.
23:11:37 <ais523> case '*': ; int repeat = 0;
23:11:38 <Deewiant> elliott: switch (*p++) { int repeat; case '*': repeat = 0;
23:11:40 <Gregor> nescience: http://codu.org/eso/bfjoust/egojsout/
23:11:54 <ais523> it's rare you find a legit use for the null statement
23:11:55 <oerjan> <elliott> oerjan: hmm, so we still need %? <-- no, you can consider just whether there is matching {} inside (see previous comments)
23:12:05 <elliott> lance.c:181: warning: ‘repeat’ may be used uninitialized in this function
23:12:18 <elliott> oerjan: you don't even have to, do you?
23:12:23 <elliott> you can just do the same thing for ( and ) always
23:12:50 <elliott> 1 : Oi -- you have a * not followed by a digit. Did your parents drop you on your head as a kid?
23:12:50 <elliott> I don't like my program's error messages when they're wrong
23:13:05 <Gregor> nescience: Click a particular run in the breakdown (if you didn't already)
23:13:21 <nescience> I thought I was supposed to enter code :)
23:13:41 <Gregor> After you do a run, it shows the breakdown. Click on an element of the breakdown
23:13:51 <oerjan> <quintopia> can we not disallow (({{}}))? it seems more complicated than it's worth <-- it's not _that_ complicated :(
23:13:55 <elliott> Gregor: Would be nice if EgoJSout printed the final result of a battle.
23:14:18 <oerjan> you have to do most of the algorithm just for a single level anyway
23:14:35 <elliott> "(128(128+)128(128-)128)128" I like your debug output, Gregor, I like it a lot :P
23:14:36 <quintopia> elliott: it prints everything you need to know!
23:14:48 <elliott> Hmm, putting the repeat in the ) too is probably a good idea.
23:15:02 <nescience> but as the author I was just asking what you did to improve on the idea in careless that was so effective
23:15:12 <Gregor> elliott: I can't decide how sarcastic you're being :P
23:15:31 <elliott> Gregor: Well it, er, could have less 128s in there.
23:15:38 <oerjan> <ais523> but you need to initialise the counts differently at parsetime <-- um the counts are initialized at runtime, not parsetime
23:15:46 <elliott> Also for compulsive clickers like me, it's annoying clicking to the right of the playfield and having shit appear :P
23:15:48 <nescience> I just don't have the flexibility to really take it on on my phone :P not trying to be lazy
23:15:55 <ais523> err, you need to initialise the value the count initialises to at parsetime
23:16:41 <ais523> nescience: decoytuner improves on careful by detecting opponents who use small decoys and using a standard offset clear in such cases
23:17:20 <ais523> yep, I'm not sure why that one works so well at all
23:17:30 <nescience> first glance seems very similar to careless but maybe it skips every other cell or something
23:17:55 <elliott> It's independent work, I think.
23:18:08 <ais523> 128 detection is a time-honoured strategy, but it never used to work well
23:18:15 <oerjan> <ais523> e.g. what does (a(b{c}d)*2)%2 expand to? <-- _if_ it's allowed, it would be -> (ab{c}db{c}d)%2 -> ababcdbcddbabcdbcdd
23:18:18 <ais523> then a few people decided to try it again and it worked quite well
23:18:32 <nescience> just that I think they work pretty similar so what makes the difference in the results
23:18:39 <oerjan> (assuming we distinguish * and %)
23:19:09 <ais523> we should go all the way, and allow BF Joust programs to be generated from 1cnis progams
23:19:13 <nescience> I think nesting () inside {} should be illegal if it crosses the braces
23:19:26 <nescience> if it includes either of them really
23:19:32 <ais523> yep, we came to that consensus, I think
23:19:53 <elliott> <oerjan> (assuming we distinguish * and %)
23:19:58 <ais523> and I don't see what sane meaning can be given to, say, (a{b)*2c}d)%2
23:20:08 <nescience> ais, I don't remember any programs much like careless.. I just noticed all the attackers were loop based and wanted to write one that wasn't
23:20:17 <elliott> To be honest, (a(b{c}d)*2)%2 seems so ridiculously useless :P
23:20:26 <nescience> it had a wider attack range at first but I wound up narrowing it way down
23:20:27 <elliott> Unifying * and % is worth it
23:20:38 <ais523> nescience: impomatic_Nyarlathotep has no control flow, IIRC
23:20:40 -!- hagb4rd has joined.
23:20:51 <ais523> it's a tripewireless defence program
23:20:54 <nescience> yeah but it is basically a defender
23:21:30 <nescience> but regardless, the question is why mapping turtle scores so much better ;)
23:21:48 <nescience> oh I get my phone back,gonna update the rom
23:21:58 <oerjan> <ais523> so we're banning {} if there's a * inside the matching %? <-- if we ignore the difference of * and %, then each ( must match a ) or { and each } must match a ) in that second context-free language (the first being ordinary matching of all types of brackets)
23:22:09 <oerjan> is what i figured recently
23:22:54 <quintopia> !bfjoust zip >>>>+<(+)*64)<(-)*64<(+)*128(>)*8([(.-)*15(.+)256[.-]])*21
23:24:11 -!- ais523 has quit (Remote host closed the connection).
23:24:36 <quintopia> mapping turtle scores so well not because it beats a lot of programs, but because it beats the *right* programs
23:25:03 <EgoBot> Score for quintopia_zip: 0.0
23:25:18 <oerjan> <elliott> you can just do the same thing for ( and ) always <-- no. in * assuming the ( does not set the counter to max (i.e. it starts zero instead), then ) must increment it, while for % ) must decrement it. vice versa if ( _does_ set the counter to max
23:25:28 <Deewiant> quintopia: You don't > in the *21
23:25:45 <quintopia> !bfjoust zip >>>>+<(+)*64)<(-)*64<(+)*128(>)*8([(.-)*15(.+)256[.-]]>)*21
23:25:57 <EgoBot> Score for quintopia_zip: 0.0
23:26:03 <elliott> <oerjan> <elliott> you can just do the same thing for ( and ) always <-- no. in * assuming the ( does not set the counter to max (i.e. it starts zero instead), then ) must increment it, while for % ) must decrement it. vice versa if ( _does_ set the counter to max
23:26:06 <elliott> Gregor: How do you handle this
23:26:18 <Deewiant> quintopia: You close two ] in the ()
23:26:48 <Deewiant> quintopia: (.+)256 instead of (.+)*256
23:26:59 <quintopia> !bfjoust zip >>>>+<(+)*64)<(-)*64<(+)*128(>)*8([(.-)*15(.+)*256[.-]]>)*21
23:27:00 <Gregor> elliott: I'm thinking about it, I'm not sure whether that makes sense to me ...
23:27:07 -!- nescience has quit (Ping timeout: 272 seconds).
23:27:14 <EgoBot> Score for quintopia_zip: 1.0
23:28:23 <quintopia> !bfjoust zip >>>>+<(+)*64)<(-)*64<(+)*128(>)*8([(.-)*15(.+)*135[.-]]>)*21
23:28:34 <EgoBot> Score for quintopia_zip: 1.0
23:29:05 <quintopia> !bfjoust zip >>>>+<(+)*64)<(-)*64<(+)*128(>)*8([(.-)*15(.+)*150[.-]]>)*21
23:29:48 <EgoBot> Score for quintopia_zip: 1.0
23:31:19 <quintopia> well, first i want to see how the thing with the thing does...
23:31:19 <oerjan> <ais523> and I don't see what sane meaning can be given to, say, (a{b)*2c}d)%2 <-- indeed as i said i consider all brackets needing matching in the ordinary sense. only [] could even _consider_ an exception, the way egojoust applies it
23:31:20 <Deewiant> !bfjoust zap >>>>+<(+)*64)<(-)*64<(+)*128(>)*8([(.-)*15(.+)*25[.-]]>)*21
23:31:35 <EgoBot> Score for Deewiant_zap: 1.0
23:32:27 <Deewiant> Gregor: No, I wanted an edit distance of 1 from zip
23:32:37 <oerjan> <elliott> To be honest, (a(b{c}d)*2)%2 seems so ridiculously useless :P <-- well with a higher %n it can give exponentially sized programs
23:33:07 <elliott> oerjan: But can it give _reasonable_ exponentially-sized programs?
23:33:15 <elliott> I can't think of any way to use it without my brain stack overflowing.
23:33:23 -!- pumpkin has changed nick to djtiesto.
23:33:24 <Gregor> oerjan: HOWWWWWWWWWwwwwwwtf does that even mean?
23:34:05 <elliott> See, it even breaks Gregor.
23:34:20 <elliott> I can see competition getting so fierce that exponentially sized programs are worthwhile.
23:34:32 -!- djtiesto has changed nick to copumpkin.
23:34:33 <Gregor> Exponential programs = nonsense.
23:34:34 <elliott> oerjan: but note that because of the stack limit, after a certain point, large programs stop making sense
23:34:40 <elliott> Gregor: Consider lots and lots of control flow.
23:34:55 <elliott> You might have a problem that consists of essentially five thousand special cases.
23:35:02 <Gregor> Can you do that with (({})*)%?
23:35:05 <elliott> An exponential repeating mechanism might come in useful.
23:35:32 <Gregor> oerjan: Tell us what (a(b{c}d)*2e)%2 expands to
23:35:47 <oerjan> <Gregor> elliott: I'm thinking about it, I'm not sure whether that makes sense to me ... <-- once again, the left side of ({})% needs to increment the counter if the right side decrements it, so that matching nesting levels have the _same_ counter value, allowing jumping between [ and ] in there with no further adjustment of the counter stack
23:36:22 <Gregor> OHHHHHHHHHH I seeeeeeeeeeeeehmmmmmmmmmm do I handle that some other way? X-P
23:36:53 <quintopia> !bfjoust zup (>+)*3(>)*5((+)*128<)*4(>)*5([(-.)*135(+.)*135>)*21(])*21
23:37:10 -!- nescience has joined.
23:37:16 <oerjan> note: (a)*n can be considered an abbreviation for (a{})%n or ({}a)%n. each of those give different implementations of ()*n given the one for ({})%n
23:37:18 <Deewiant> I thought that was disallowed?
23:37:27 <elliott> Or (half of a{}half of a)%n
23:37:29 <EgoBot> Score for quintopia_zup: 2.1
23:37:31 <elliott> Deewiant: It's not in egojoust.
23:37:46 <Deewiant> Oh, I thought we switched already, for some reason
23:38:38 <elliott> Deewiant: But it looks like that one fits the form (A[B)*nC(D]E)*n, which is easily convertible to (A[B{C}D]E)*n.
23:38:45 <elliott> Which I'll write a preprocessor to lance to do.
23:38:52 <elliott> And then summarily remove when said programs get replaced.
23:38:53 <Sgeo_> Would you rather I deadblog?
23:39:39 <Sgeo_> This episode seems to relate to the Dominion War
23:39:45 <quintopia> !bfjoust zup (>+)*3(>)*5((+)*128<)*5(>)*6([(-.)*135(+.)*135>)*21(]>)*21
23:40:20 <EgoBot> Score for quintopia_zup: 2.2
23:40:38 <oerjan> <Gregor> oerjan: HOWWWWWWWWWwwwwwwtf does that even mean? <-- note that a program of _depth_ 100000 can still have size > 2^100000 after expansion, and (a(b{c}d)*2)%100000 would be an example
23:41:23 <Gregor> oerjan: I honestly have no idea what that would even expand to, I can't argue about whether the expansion makes sense when there's no obvious expansion.
23:41:52 <Sgeo_> I remember something the wiki said about these two episodes.....
23:41:59 -!- impomatic has quit (Quit: ChatZilla 0.9.86 [Firefox 3.5.16/20101130074636]).
23:42:21 <oerjan> <Gregor> Can you do that with (({})*)%? <-- don't know, but (...{}...{}...)% looks more plausible...
23:42:40 <Gregor> oerjan: JUST SHOW ME THE DAMNED EXPANSION >_<
23:42:45 <elliott> oerjan: that could actually work
23:42:49 -!- MigoMipo has quit (Read error: Connection reset by peer).
23:42:51 <elliott> oerjan: if { scans backwards to the last ( in-code
23:43:21 <Gregor> Won't work in ego*, matching is static.
23:43:34 <Gregor> And all stored in the (
23:43:40 <coppro> what do curlies do again?
23:43:51 <Gregor> pooppy: (a{b}c)*2 = aabcc
23:44:35 <elliott> Someone forward that to crapppy.
23:44:55 <oerjan> <Gregor> oerjan: Tell us what (a(b{c}d)*2e)%2 expands to <-- ababcdbcdedbabcdbcdede, i think
23:45:26 <Gregor> oerjan: What - the - fuck
23:45:31 <elliott> Gregor: Tell him about the ENTERPRISE LANGUAGE CHANGES, we can't have people lagging behind.
23:45:42 <elliott> `addquote <oerjan> <Gregor> oerjan: Tell us what (a(b{c}d)*2e)%2 expands to <-- ababcdbcdedbabcdbcdede, i think <Gregor> oerjan: What - the - fuck
23:46:00 <elliott> Gregor: It's not _that_ difficult to understand; first expand the inner:
23:46:20 <Gregor> Ohohohohoh, it's just like the hypothetical multi-{}
23:46:23 <elliott> Just type everything not in {}s twice.
23:46:26 <oerjan> <Deewiant> I thought that was disallowed? <-- i don't see why empty parts of ({})% should be disallowed, it's just that it simplifies to ()*
23:46:32 <elliott> Gregor: Yes, except that you can cause exponential blowup with oerjan's syntax.
23:46:37 <elliott> Which is arguably a good thing.
23:46:45 <Deewiant> oerjan: I was talking about zup, not your line
23:47:25 <HackEgo> ) <oerjan> <Gregor> oerjan: Tell us what (a(b{c}d)*2e)%2 expands to <-- ababcdbcdedbabcdbcdede, i think <Gregor> oerjan: What - the - fuck
23:47:31 <oerjan> <Deewiant> I thought that was disallowed? <-- oh wait misread who you were referring to
23:47:43 <HackEgo> <olsner> actually, I think vorpal is the "retarded team member" to the left \ <elliott> Deewiant: ha, you were wrong, I have stacks, fungespace and MULTIPLE functions! <elliott> and a monad! <elliott> nothing can stop me now! \ <Vorpal> !bfjoust test (-)*10000 <EgoBot> Score for Vorpal_test: 12.9 <Vorpal> yay \ <Vorpal>
23:47:48 <elliott> those aren't quotes about tails!
23:47:54 <HackEgo> 300) <elliott_> The context is Gracenotes releasing an illegal copy of a film about monster cock dildos.
23:47:54 <HackEgo> <xplat> so you have legacy software in befunge that needs supported?
23:48:08 <HackEgo> 302) <xplat> so you have legacy software in befunge that needs supported?
23:48:18 <elliott> `addquote <oerjan> <Gregor> oerjan: Tell us what (a(b{c}d)*2e)%2 expands to <-- ababcdbcdedbabcdbcdede, i think <Gregor> oerjan: What - the - fuck
23:48:20 <HackEgo> 303) <oerjan> <Gregor> oerjan: Tell us what (a(b{c}d)*2e)%2 expands to <-- ababcdbcdedbabcdbcdede, i think <Gregor> oerjan: What - the - fuck
23:49:42 <oerjan> <elliott> oerjan: if { scans backwards to the last ( in-code <-- parsing-wise i'm thinking of this as allowing matching { and } in my second CF part, and then looking at chain matchings ( 2 { 1 } 2 { 1 } 2)
23:50:25 <elliott> Deewiant: Does it mean $(which addquote)?
23:51:03 <elliott> zsh builds like 50000 programs into the shell :P
23:51:33 <coppro> oerjan: I would have to say I expect (a(b{c}d)*2e)%2 to be a parse error
23:51:47 <quintopia> !bfjoust zip (>+)*3(>)*5((+)*128<)*5(>)*6(([(-.)*135(+.)*135>)*21(])*21>)*21
23:51:50 <coppro> I would do innermost first
23:51:57 <quintopia> this one beats defend14. i checked that at least :P
23:52:02 <oerjan> <elliott> ababcdbdbcdede <-- um no, you missed the part for db{c}d
23:52:02 <EgoBot> Score for quintopia_zip: 9.4
23:52:05 <coppro> so to (ab{c}db{c}de)%2 which is worng
23:52:44 <elliott> Gregor: Dude... you stole lance's format...
23:52:54 <elliott> Add a space after wins and that's exactly what lance's output ends with right now :P
23:52:55 <Gregor> elliott: It says "tie" when nobody wins :P
23:53:02 <elliott> Gregor: OH, that's not COPYRIGHT INFRINGEMENT then.
23:53:06 -!- elliott has changed nick to Gergor.
23:53:13 <Gergor> And I'M not POSING as GREGOR.
23:53:13 <Gregor> elliott: And thank you for pointing out I missed the space.
23:53:17 <coppro> if you do outside first, then yes, it works out to ababcdbcdedbabcdbcded
23:53:37 <Gergor> defend13 sure is hilarious in the trace screen
23:54:37 <Gregor> elliott: Besides, you requested the feature.
23:54:47 <oerjan> <coppro> oerjan: I would have to say I expect (a(b{c}d)*2e)%2 to be a parse error <-- currently we seem to be settling on unifying * and %, which means it's just interpreted as old (a(b{c}d)%2e)*2 by the matching rules
23:55:11 <Gergor> So how does Greggsy Gregor handle {} vs normal
23:55:18 <Gergor> Like he seemed to imply he didn't
23:55:38 <Gregor> Counting up in the left part, then down in the right part.
23:55:46 <quintopia> !bfjoust superfast_jellyfish +>>>>(+)*33<(-)*66<(+)*99<(-)*128>>>>>>>>([-[++[(+)*15[(.-)*3]]]]>)*21
23:56:02 <Gergor> Gregor: So still no marking of whether a repeater is a {} or () style?
23:56:06 <Gergor> oerjan's belief system is CRUSHED ONCE MORE.
23:56:11 <EgoBot> Score for quintopia_superfast_jellyfish: 36.8
23:56:26 <Gregor> Gregor: I had to mark that in the first place.
23:56:36 <Gregor> Gregor: I just don't distinguish * from % because I already know by then.
23:56:52 <oerjan> coppro: the other legal option would require allowing multiple {} (iteration counts as multiplying there) corresponding to each (), which needs a different algorithm to handle the data for exponential blowup
23:57:05 <Gregor> Hey, what should (a{b}c)*0 do
23:57:12 <Gergor> Gregor: Expand to the null string.
23:57:28 <Gergor> I'd prefer it be the null string
23:57:30 <Gregor> I mean it's obviously stupid :P
23:57:30 <Gergor> For commenting purposes.
23:57:36 <coppro> we are not trying to make obfuscated bf code
23:57:43 <Gergor> It would be nice to be able to say {} in comments :P
23:58:24 <oerjan> coppro: b is the _logical_ result. (a{b}c)*<n+1> = a(a{b}c)*n c fits with that
23:58:24 <coppro> !bfjoust mostly_ripped_off_of_quintopia +>>>>(+)*33<(-)*66<(+)*99<(-)*128>>>>>>>>([-[++[(+)*15[(..-)*3]]]]>)*21
23:58:35 <Gergor> <oerjan> [expecting logic from coppro]
23:58:40 <EgoBot> Score for coppro_mostly_ripped_off_of_quintopia: 23.7
23:58:42 <coppro> oerjan: except n should be a positive integer
23:59:24 <Gergor> Gregor: Err, do you stop the battle at the end of program execution?