00:03:15 <elliott> oerjan: hmm there is no way to define an unboxed type in haskell, right?
00:03:44 <elliott> copumpkin: in the sense of being literally unboxed. (I'm creating typeclass dictionaries at runtime.)
00:03:59 <elliott> my current implementation is a bit brittle so I want to do some unsafeCoercing to pass the dictionary more explicitly
00:04:00 <copumpkin> I mean, what kind of an unboxed type would you want?
00:04:07 <elliott> copumpkin: typeclass dictionary
00:04:33 <copumpkin> well, an unlifted tuple of the members of the dictionary
00:04:51 <elliott> copumpkin: oh, that would work. how many unlifted tuple types are defined?
00:05:34 <elliott> copumpkin: do you know anything about functions in typeclasses internally?
00:05:44 <elliott> when I coerce functions into a dictionary, I get the PAP object entered error
00:05:58 -!- Phantom_Hoover has quit (Quit: Leaving).
00:06:02 <elliott> so it sounds like functions in dictionaries are different to functions elsewhere
00:06:15 <copumpkin> but a dictionary is probably its own closure type or something
00:06:21 <copumpkin> so it's not even an unlifted tuple
00:06:28 <copumpkin> also, you can't pass unlifted tuples
00:06:43 <elliott> OK, well I need to pass them. Is that a restriction on what you can define or will even coercing to that not work?
00:06:54 <elliott> copumpkin: And, well, I've successfully coerced non-function classes in.
00:06:57 <copumpkin> there's not an established way to pass them in
00:07:01 <elliott> (specifically class Ooh a where ooh :: a)
00:07:13 <oerjan> elliott: since it _does_ work for data types, the surrounding dictionary structure seems unlikely to be the real culprit, no?
00:07:49 <elliott> oerjan: yep, but copumpkin is saying that it is. (if you mean my questions about unboxed tuples, I'm trying to make withInstance reliable, you know, because of the horrible bug that breaks referential transparency :))
00:08:00 <copumpkin> you probably don't want unboxed tuples
00:08:34 <elliott> copumpkin: seems not. But I need to do it _somehow_
00:08:41 <elliott> and there's no core parser, and I don't think writing this as Cmm would be practical.
00:09:04 <elliott> oerjan: ah, "OohD a -> (forall b. (Ooh b) => r) -> r" is not even valid
00:09:07 <elliott> At least one of the forall'd type variables mentioned by the constraint
00:09:07 <elliott> must be reachable from the type after the '=>'
00:09:24 * elliott tries Data.Tagged out of curiosity
00:09:50 <copumpkin> is this just wankery out of curiosity or are you trying to do something real with this?
00:10:13 <elliott> copumpkin: it started out as the former, but I believe if I can get it to work, you can reimplement the reflection package more efficiently like this.
00:10:25 <elliott> and it would be a neat Hackage package, too :)
00:10:34 <copumpkin> reflection is already pretty awesomely efficient
00:10:54 <elliott> oerjan says it goes through the FFI, which would be totally unnecessary with this
00:11:05 <elliott> {-# OPTIONS_GHC -fno-cse -fno-full-laziness -fno-float-in #-}
00:11:05 <elliott> those last two flags are scary.
00:11:39 <elliott> oh, they're just turning off things -O implies
00:12:46 <elliott> copumpkin: anyway, I will definitely put this on Hackage if I can get it working, so I'd call it something real
00:13:10 <oerjan> turning pointers into strings, then into lists of integers, then into a type to get an instance is efficient?
00:13:39 <oerjan> (and the integer -> type step is binary, i think
00:14:04 -!- zzo38 has quit (Remote host closed the connection).
00:14:19 <oerjan> ok it may be word8 lists
00:14:24 <elliott> well that's not really better
00:14:58 <elliott> bytes = unsafePerformIO $ with a (peekArray (sizeOf a) . castPtr)
00:15:20 <elliott> oerjan: it might be inlined into reifyIntegrals as a loop
00:15:24 <elliott> but there's no way the type part isn't horrible
00:15:40 <elliott> newtype Zero = Zero Zero deriving (Show)
00:15:40 <elliott> newtype Twice s = Twice (Twice s) deriving (Show)
00:15:40 <elliott> newtype Succ s = Succ (Succ s) deriving (Show)
00:15:40 <elliott> newtype Pred s = Pred (Pred s) deriving (Show)
00:15:55 <copumpkin> and says it's almost negligible performance-wise
00:16:02 <copumpkin> which is why he's building the mpfr binding on top of it
00:16:06 <elliott> meh, my hack is cool for other reasons too
00:16:38 <elliott> I wish there was an unsafeCoerce that shut GHC up about lack of instances
00:17:11 <elliott> withInstance :: forall a r. OohD a -> ((Ooh a) => r) -> r
00:17:12 <elliott> withInstance d k = (unsafeCoerce k :: OohD a -> r) d
00:17:16 <elliott> /home/elliott/Code/reify-class/reify.hs:25:34:
00:17:45 <elliott> copumpkin: btw, mine already works enough that you can make (print "hello") print without the quotes in some contexts
00:17:53 <copumpkin> elliott: I have a better trick for that
00:18:01 <elliott> you could even ask the user whether you wanted it to print quotes or not and then do so at runtime
00:18:05 <elliott> (you can specify full instances at runtime)
00:18:07 <elliott> copumpkin: what's the trick>
00:18:17 <elliott> mine is a pretty great trick :P
00:19:16 <elliott> *Main> withInstance explicitTestD (ooh :: Int)
00:19:16 <elliott> Loading package array-0.3.0.2 ... linking ... done.
00:19:16 <elliott> Loading package containers-0.4.0.0 ... linking ... done.
00:19:16 <elliott> Loading package deepseq-1.1.0.2 ... linking ... done.
00:19:16 <elliott> Loading package parallel-3.1.0.1 ... linking ... done.
00:19:19 <elliott> *Main> withInstance explicitTestD (ooh :: Int)
00:19:25 <elliott> copumpkin: It does and it doesn't
00:19:37 <elliott> b = withInstance explicitLitD $ print "Hello, world!"
00:19:41 <elliott> main = do { print blah; withInstance ... }
00:19:49 <oerjan> <elliott> it's wtf-ary :P <-- wtf are they nested in themselves for...
00:20:00 <elliott> copumpkin: But yeah, apart from that rather major bug, it works, and I think if I can coerce GHC into generating the right Core, it'll work perfectly
00:20:10 <copumpkin> oerjan: to only have one inhabitant
00:20:14 <elliott> oerjan: that's how you define a 0-element type in standard haskell pre-last year's report
00:20:44 <elliott> I don't consider _|_ a value so much as a disease
00:21:12 <elliott> I don't consider Agda a language so much as INFERIOR TO COQ IN EVERY WAY
00:21:17 <oerjan> i think elliott has other reasons to dislike agda :P
00:21:31 <oerjan> basically, elliott has other reasons to dislike X forall X
00:21:39 <monqy> I'll learn coq first then
00:21:47 <elliott> I don't have other reasons to dislike oerjan other than that he's oerjan
00:21:58 <oerjan> but still somehow manages to order things
00:22:10 -!- kmc_ has changed nick to kmc.
00:22:59 <elliott> oerjan: oh dear, my code does not work as well as I thought
00:23:04 <elliott> adding "aah :: (a,a)" breaks things.
00:23:16 <elliott> so, is it multiple elements or the different type?
00:23:17 <Sgelo> Is _|_ like null but all.... mathematical? And untestable-for, of course
00:23:39 <elliott> oerjan: nope, aah :: a breaks too
00:23:48 -!- Vorpal has quit (Ping timeout: 264 seconds).
00:23:51 <oerjan> elliott: is it the explicit type declaration then
00:23:52 <Sgelo> (Barring certain cases of it which can be detected in IO or some BS like that)
00:23:59 <elliott> oerjan: no, it's having more than one member :)
00:24:17 <elliott> oerjan: I suspect GHC rudely turned my data into a newtype?
00:24:45 <oerjan> can it _do_ that? i suppose if the members are strict...
00:25:39 <oerjan> this might depend too much on ghc's exact memory layouts
00:25:55 <elliott> oerjan: um that's exactly what I want to depend on
00:26:02 -!- Vorpal has joined.
00:26:11 <oerjan> yes, but if those are varying for subtle reasons...
00:26:39 <Lymee> !haskell import Unsafe.Coerce;map id unsafeCoerce 0 :: [Int]
00:26:46 <elliott> oerjan: well the Core doesn't lie.
00:26:55 <oerjan> Lymee: import means module, which requires a main
00:26:56 <elliott> oerjan: it would have to make the same decisions to the data type, too :)
00:27:11 <CakeProphet> my windows key has been transformed into an UBUNTU KEY
00:27:21 <Lymee> !haskell import Unsafe.Coerce;main = putStrLn $ show $ map id $ unsafeCoerce 0 :: [Int]
00:27:28 <oerjan> Lymee: you can use !map id Unsafe.Coerce.unsafeCoerce 0 :: [Int] though
00:27:59 <Lymee> !haskell import Unsafe.Coerce;main = print $ map id $ unsafeCoerce 0 :: [Int]
00:28:18 <Lymee> !haskell import Unsafe.Coerce;main = print $ map id (unsafeCoerce 0 :: [Int])
00:28:23 <oerjan> Lymee: oh and you need... right
00:28:46 <elliott> copumpkin has given up on me at least :-P
00:28:54 <elliott> now to ask oerjan a technical question he can't answer
00:28:57 <elliott> and finally I shall be alone in the world
00:29:30 <Lymee> !haskell import Unsafe.Coerce;main = print $ map id (unsafeCoerce 100 :: [Int])
00:29:37 <Lymee> !haskell import Unsafe.Coerce;main = print $ map id (unsafeCoerce (Just 100) :: [Int])
00:30:04 <elliott> oerjan: ok i can prove that the elements can't be unpacked
00:30:22 <elliott> oerjan: typeclasses are polymorphic by definition, types have varying sizes, Q.E.D.
00:30:28 <elliott> strictness doesn't solve the segfault
00:30:36 <elliott> maybe I really _do_ have one too many levels of unboxing
00:30:39 <Lymee> !haskell import Unsafe.Coerce;main = print $ map id (unsafeCoerce (Just (Just 100)) :: [Int])
00:30:41 <Sgelo> "Fidelity National Information Services Inc. (FIS) lost $13M to an ATM theft earlier this year:"
00:30:44 <EgoBot> [-1657324113164070127]
00:30:52 <Sgelo> I swear, this has nothing to do with my BancSTAR inquiries!
00:31:04 <Lymee> !haskell import Unsafe.Coerce;main = print $ map id (unsafeCoerce [Just 100,Just 10,Just 5] :: [Int])
00:31:08 <elliott> Lymee: EgoBot responds to /msg.
00:31:09 <EgoBot> [1801440399305314945,6341068823694774913,2449958745646666370]
00:31:57 <elliott> oerjan: hmm, this is really baffling; one-element classes work, three-element classes of functions work as long as you don't actually _call_ them
00:32:06 <Sgelo> > import System.IO.Unsane; unsafePerformIO $ putStrLn "Hello world"
00:32:07 <lambdabot> <no location info>: parse error on input `import'
00:32:18 <Sgelo> !haskell import System.IO.Unsane; unsafePerformIO $ putStrLn "Hello world"
00:32:42 <Sgelo> !haskell import System.IO.Unsafe; unsafePerformIO $ putStrLn "Hello world"
00:32:57 <elliott> "for the congnoscenti, data values can be entered but function closures cannot"
00:33:04 <Sgelo> <EgoBot> /tmp/input.19017.hs:1:7:
00:33:05 <Sgelo> <EgoBot> Could not find module `System.IO.Unsane':
00:33:05 <Sgelo> <EgoBot> Use -v to see a list of the files searched for.
00:33:05 <Sgelo> <EgoBot> /tmp/input.19389.hs:2:0:
00:33:05 <Sgelo> <EgoBot> parse error (possibly incorrect indentation)
00:33:06 <oerjan> Sgelo: i am not going to repeat everything i said to Lymee
00:33:07 <elliott> oerjan: hm. so it was treating the function in the Show class as a data value.
00:33:19 <elliott> oerjan: I'm starting to suspect copumpkin is right about mumble mumble infotable :-)
00:33:53 <Sgelo> oerjan, when did you say it? Today?
00:33:54 <elliott> which would be rather difficult to resolve from within Haskell.
00:34:07 <oerjan> Sgelo: like above when Lymee did essentially the same thing
00:34:42 <Lymee> !haskell import Unsafe.Coerce;main = print $ map id (unsafeCoerce ([Just 100,Just 10,Just 5] :: [Any]) :: [Int])
00:35:18 <Sgelo> Is there any point to using unsafePerformIO when I have access to full IO anyway?
00:36:02 <oerjan> Sgelo: er, no. and Lymee is testing unsafeCoerce not unsafePerformIO.
00:36:23 <Sgelo> I was testing unsafePerformIO for no good reason I guess
00:37:02 <elliott> oerjan: it's so CLOSE to working :D
00:37:10 <elliott> LOOK AT THE COOOOOOOOOOORE
00:37:38 <elliott> wtf, why isn't it showing the D:blah crap
00:37:51 <elliott> M.$fOohInt [InlPrag=[ALWAYS] CONLIKE] :: M.Ooh Int
00:37:51 <elliott> M.$fOohInt = M.D:Ooh @ Int $cooh_rmM $caah_rmK
00:38:12 <elliott> oerjan: I was about to say it might be the type parameter but duh that's erased at runtime
00:39:12 <elliott> \ (@ a_apr) ($dOoh_aps :: M.Ooh a_apr) ->
00:39:12 <elliott> (M.ooh @ a_apr $dOoh_aps, M.aah @ a_apr $dOoh_aps)
00:39:16 <elliott> I was looking for some "case", ghc-core :P
00:39:20 <elliott> but OK I'LL LOOK AT THE ACCESSORS
00:39:42 <elliott> \ (@ a_ac6) (tpl_B1 [Occ=Once!] :: M.Ooh a_ac6) ->
00:39:42 <elliott> case tpl_B1 of _ { M.D:Ooh tpl_B2 [Occ=Once] _ -> tpl_B2 }
00:39:43 <elliott> \ (@ a_ac6) (tpl_B1 [Occ=Once!] :: M.Ooh a_ac6) ->
00:39:43 <elliott> case tpl_B1 of _ { M.D:Ooh _ tpl_B3 [Occ=Once] -> tpl_B3 }
00:39:55 <elliott> looks right to me. although wtf is [Occ=Once] about anyway?
00:40:15 <CakeProphet> what was once a window-stickered Dell Inspiron has now been transformed into an Ubuntu-and-Windows-stickered COMPUTING MACHINE
00:40:29 <oerjan> CakeProphet: how inspiring
00:41:21 -!- sllide has quit (Ping timeout: 245 seconds).
00:41:52 <oerjan> elliott: maybe it means simply that it only occurs once in its scope
00:42:22 <oerjan> and the appended ! might mean it's strict
00:43:16 <monqy> CakeProphet: miserable
00:43:40 <CakeProphet> look I'm sorry but I can't control pseudo-randomness
00:43:49 <oerjan> highly fonetic morphology-missing totally yarbled acronym case
00:44:18 <monqy> CakeProphet: can't you markov it up or something
00:44:41 <elliott> oerjan: hm what is that a_ac6
00:45:10 <elliott> oerjan: I wish I could get GHC to figure out how I'm using unsafeCoerce so I can see what the unpacking and repacking looks like :-)
00:46:11 <elliott> Main.explicit_ooh :: forall a_axd. Main.ExplicitOoh a_axd -> a_axd
00:46:11 <elliott> [GblId[[RecSel]], Arity=1, Caf=NoCafRefs]
00:46:11 <elliott> \ (@ a_axv) (ds_dyA :: Main.ExplicitOoh a_axv) ->
00:46:11 <elliott> case ds_dyA of _ { Main.ExplicitOoh ds1_dyB ds2_dyC ->
00:46:12 <elliott> case {tick (main:Main, 12)}_dyy
00:46:14 <elliott> @ (a_axv -> GHC.Prim.State# GHC.Prim.RealWorld) ds1_dyB
00:46:24 <elliott> Main.explicit_aah :: forall a_axd. Main.ExplicitOoh a_axd -> a_axd
00:46:26 <elliott> [GblId[[RecSel]], Arity=1, Caf=NoCafRefs]
00:46:30 <elliott> \ (@ a_axx) (ds_dyG :: Main.ExplicitOoh a_axx) ->
00:46:34 <elliott> case ds_dyG of _ { Main.ExplicitOoh ds1_dyH ds2_dyI ->
00:46:36 <elliott> case {tick (main:Main, 13)}_dyE
00:46:38 <elliott> @ (a_axx -> GHC.Prim.State# GHC.Prim.RealWorld) ds2_dyI
00:46:48 <elliott> (the ticks are irrelevant, ghc-core just elides these accessors so I need to get the more raw version)
00:46:50 <elliott> oerjan: ok distinct lack of [Occ=Once]...
00:47:59 <elliott> I was going to wonder what $ signifies but it'll just mean generated code
00:48:05 <elliott> and also not exported stuff
00:48:12 <elliott> not exported = no module prefix
00:48:33 <elliott> kmc: HOW MUCH DO YOU KNOW ABOUT GHC'S REPRESENTATION OF TYPECLASS DICTIONARIES
00:48:38 <kmc> not much :/
00:48:55 <kmc> i don't see a $
00:48:57 <elliott> Tell me EVERYTHING YOU KNOW.
00:49:07 <elliott> The $s were elsewhere in the Core.
00:52:38 <oerjan> that [GblId[[RecSel]], Arity=1, Caf=NoCafRefs] might contain the kind of information which causes ghc to treat it differently
00:53:48 <elliott> *Main> explicit_ooh (implicit (defaultD :: OohD Int))
00:53:48 <elliott> Loading package array-0.3.0.2 ... linking ... done.
00:53:49 <elliott> Loading package containers-0.4.0.0 ... linking ... done.
00:53:49 <elliott> Loading package deepseq-1.1.0.2 ... linking ... done.
00:53:49 <elliott> Loading package parallel-3.1.0.1 ... linking ... done.
00:53:50 <oerjan> especially the first one looks suspicious to me, Rec might mean record
00:53:51 <elliott> *Main> explicit_ooh (implicit (defaultD :: OohD Int))
00:53:55 <elliott> *Main> explicit_aah (implicit (defaultD :: OohD Int))
00:53:59 <elliott> *Main> [a few seconds passed]
00:54:03 <elliott> ghc: internal error: evacuate: strange closure type 524
00:54:05 <elliott> (GHC version 7.0.4 for x86_64_unknown_linux)
00:54:07 <elliott> Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug
00:54:11 <elliott> (I guess that was during GC)
00:54:13 <elliott> ok so there is _something_ wrong with my representation somehow
00:54:27 <elliott> oerjan: that's just record selector
00:54:29 <elliott> these _are_ record selectors
00:54:36 <elliott> I'm interested in how the record is destructed
00:54:39 <elliott> which is the only reason I looked at them
00:56:00 <elliott> (the previous try before I restarted without noisy core output segfaulted as soon as I did the explicit_aah)
00:58:20 <oerjan> ...and the new square root of minus garfield meme really gets going.
00:59:59 <elliott> kmc won't talk. they know what we're doing. they fear us.
01:00:14 <elliott> oerjan: what's the meme this time?
01:00:28 <kmc> i don't actually know anything about ghc's representation of typeclass dictionaries
01:00:28 <oerjan> elliott: see the linked original
01:00:41 <kmc> i just prefer to answer questions with vague relative terms rather than absolutes
01:00:56 <elliott> oerjan: so it's s/blender/X~blender/?
01:01:03 <oerjan> kmc: hm, might you be interested in an #esoteric op position?
01:01:16 <elliott> kmc: can I pay you to go and force copumpkin to stop making food and start answering my pressing questions instead?
01:01:44 <oerjan> elliott: well this is the first one that actually sounds like bender, really.
01:01:57 <copumpkin> I finished my dinner but I really feel like some cereal now
01:02:07 <elliott> copumpkin: STOP AVOIDING YOUR DUTIES
01:02:19 <copumpkin> it was only moderately pissed off though
01:02:22 * elliott punches copumpkin, shoves in back of truck, drives to the Haskell lab
01:02:40 <elliott> clearly i did not punch enough.
01:02:43 <oerjan> copumpkin: it was just copypasta
01:03:05 <copumpkin> I wouldn't mind copypasta that pasta
01:03:58 <oerjan> the pasta is in the past
01:04:16 <elliott> oerjan: hey, ban copumpkin until he learns to forego food. thanks
01:04:21 <elliott> (my techniques are _beautiful_.)
01:04:40 <oerjan> but i _like_ food. it keeps the horrible pain away.
01:04:52 <elliott> oerjan: um what we are doing right now is the horrible pain.
01:04:55 <olsner> oerjan: me too want food
01:05:42 <olsner> the pain of non-food seems to have temporarily subsided though
01:06:24 <elliott> what do you know about GHC's representation of typeclass dictionaries
01:06:38 <oerjan> he knows nothing, he is swedish
01:06:45 <elliott> olsner: good. tell the three.
01:06:51 <elliott> oerjan: now now, we only have a sample size of one for that.
01:07:08 <olsner> elliott: can't explain. 3.
01:07:28 <oerjan> elliott: he seems to be stuck at the wrong type for the answer.
01:07:35 <oerjan> you might have to unsafeCoerce him.
01:07:56 <elliott> :: InformationAboutTypeClasses
01:08:02 <olsner> unsafeCoerse to the right type lol
01:08:38 <elliott> ok now he definitely can't help us.
01:08:44 <oerjan> elliott seems a bit upset.
01:08:55 <elliott> oerjan: hey wait i just had an idea.
01:09:01 <elliott> oerjan: I could use the FFI in a maybe less horrific manner.
01:09:12 <elliott> oerjan: specifically: just assemble the structure of the instance in-memory
01:09:16 <elliott> that would just be a few simple pokes
01:09:31 <elliott> then an unsafeCoerce and peek
01:09:35 <olsner> anyway, what you actually have at your disposal is burger dressing, some kebab meat and some fries... and maybe me... in that order
01:09:40 <elliott> it might be hard to get GHC to turn a pointer into a value with the same representation :)
01:09:53 <elliott> probably not that hard I guess
01:09:57 <olsner> in other words, good luck with that dressing
01:10:23 <olsner> afaik it doesn't do haskell nearly as well as me
01:10:37 <olsner> however good *that* is
01:10:49 <oerjan> elliott is going to do this so weirdly that it will only work in precisely _one_ ghc version.
01:10:54 <olsner> I don't ray on the drugs no
01:11:18 <elliott> oerjan: well I think GHC's runtime representation is pretty stable...
01:11:38 <oerjan> elliott: they did add those tag bits at one point...
01:11:41 <elliott> castStablePtrToPtr :: StablePtr a -> Ptr ()Source
01:11:41 <elliott> Coerce a stable pointer to an address. No guarantees are made about the resulting value, except that the original stable pointer can be recovered by castPtrToStablePtr. In particular, the address may not refer to an accessible memory location and any attempt to pass it to the member functions of the class Foreign.Storable.Storable leads to undefined behaviour.
01:11:49 <elliott> that's not very helpful, Foreign.StablePtr.
01:11:52 <elliott> castPtrToStablePtr :: Ptr () -> StablePtr aSource
01:11:52 <elliott> The inverse of castStablePtrToPtr, i.e., we have the identity
01:12:11 * olsner moves more shredded something into an eating position
01:12:16 <elliott> i'll wait for copumpkin to prove that we can't possibly do that and then try that :P
01:13:01 <olsner> can't do what and then try what?
01:13:36 <olsner> hredded hred hrerring?
01:13:51 <olsner> icelandishers are weirder
01:13:57 <elliott> olsner: can't do it with unsafeCoerce; and write the FFI code
01:14:29 <olsner> and not in the "cocktail with cinnamon" sense...
01:14:52 <olsner> hurr durr elliott är nykter
01:15:15 <elliott> IM GOING TO RIP OUT YOUR GUTS
01:15:16 <elliott> AND REPLAC ETHEM WITH DEATH
01:15:28 <oerjan> baknykter, what a horrible state to be in
01:15:30 <olsner> death will do that too
01:15:52 <oerjan> i think that may be what english calls "knurd"
01:16:13 <olsner> only after you start calling it knurd
01:16:26 * oerjan ponders getting some klatchian ice coffee
01:16:52 <elliott> knurd is a discworld thing??//
01:16:56 <oerjan> elliott: help, this swede is deficient, he doesn't get my discworld references
01:17:34 <elliott> withInstance :: OohD a -> (forall t. (Ooh t) => Tagged t r) -> Tagged t r
01:17:39 <elliott> oerjan: can you _believe_ ghc is too stupid to type this
01:17:45 <olsner> you know, norway used to be ours entirely
01:17:48 <elliott> it might be the return type that's broken
01:17:53 <oerjan> elliott: we cannot do that, they have infiltrated us too much
01:18:02 <elliott> olsner: yes and then it became decent
01:18:25 <oerjan> <elliott> oerjan: can you _believe_ ghc is too stupid to type this <-- huh
01:18:26 <olsner> elliott: you say that as if it were a good thing
01:18:53 <Sgelo> TV Tropes no longer does Troper Tales
01:19:15 <CakeProphet> this reminds me somewhat of import antigravity
01:19:31 <oerjan> <olsner> OURS <-- IT WAS A UNION OF EQUALS.
01:19:38 <olsner> tvtropes was alive and kicking last time I checked anyway
01:20:08 <elliott> withInstance :: OohD a -> (forall t r. Tagged t r -> x) -> (forall t. (Ooh t) => Tagged t r) -> x
01:20:08 <elliott> withInstance OohD ugh k = ugh k
01:20:44 <oerjan> <elliott> also all swedes <-- erm i was contrasting him with Vorpal.
01:20:53 <CakeProphet> yes it could be cave man grunts or a Haskell program
01:20:58 -!- Patashu has quit (Ping timeout: 246 seconds).
01:22:26 <copumpkin> http://nextround.net/wp-content/uploads/2009/03/luther_burger.jpg
01:24:09 <elliott> hey copumpkin HOW DO DICTIONARIES WORK
01:24:09 <Sgelo> http://tvtropes.org/pmwiki/pmwiki.php/TroperTales/Akinator
01:24:43 <elliott> oerjan: i think copumpkin needs some convincing :P
01:24:54 <olsner> copumpkin: u r lazy, stop figuring-out-later
01:25:20 <oerjan> olsner: you cannot use lazy as an insult on a haskeller
01:26:28 <elliott> http://www.reddit.com/r/fifthworldproblems/ good redesign
01:27:04 <oerjan> iirc fifthworldproblems is not a very typical reddit.
01:27:19 <olsner> if it wasn't completely horrible it wouldn't appear here
01:27:32 <elliott> oerjan: you could click the link :P
01:27:44 <Sgelo> " Earlier this year hackers raided the computer networks of RSA (EMC), a marquee security firm that protects other companies computers. They stole some of the most valuable computer code in the world, the algorithms behind RSAs SecureID tokens, a product used by U.S. government agencies, defense contractors, and major banks to prevent hacking. It was like breaking into a heavily guarded locksmith and stealing the master combination tha
01:27:44 <Sgelo> t opened every vault in every casino on the Las Vegas Strip."
01:27:46 <elliott> (you may not quite understand without seeing http://www.reddit.com/r/circlejerk's new design)
01:27:48 <Sgelo> http://www.businessweek.com/printer/magazine/cyber-weapons-the-new-arms-race-07212011.html
01:28:01 <oerjan> ok if it is that obvious that i haven't clicked the link, it might be worth doing so
01:28:07 <Sgelo> Um, something is really really wrong if the _algorithms_ are the crucial part
01:28:19 <elliott> oerjan: click the circlejerk one first
01:28:27 <elliott> or it'll make even less sense than fifthworldproblems does
01:28:34 <olsner> ehm, Shelo seems to be up to something irrelevant
01:29:09 -!- Sgelo has changed nick to Sgeo.
01:29:15 <Sgeo> I am not Shazam. Or Shelo.
01:29:38 <olsner> that would... explain it
01:29:52 <kmc> oerjan, you can tell because they're speaking icelandic
01:30:30 <olsner> kmc: hurr durr linkur durr gurr
01:30:45 <kmc> SA did the ironic Ron Paul fanclub already
01:31:04 <elliott> kmc: so did everyone, last election
01:31:22 <elliott> circlejerk does not aim for unique humour :P
01:31:33 <kmc> nobody knows how to learn erlang
01:31:44 <elliott> ok so kmc and olsner make sense to each other
01:31:49 <elliott> oerjan and olsner sometimes do but only sometimes
01:31:50 <kmc> i watched Erlang: The Movie three times
01:31:53 <elliott> and kmc makes no sense to oerjan
01:33:10 <kmc> i gather Erlang is the best language to use if you want to talk to a Swedish person from 1987 on the telephone
01:34:11 <olsner> I think Swedish would be way better
01:34:49 <olsner> and I also think I will momentarily be way non-caring
01:42:42 <elliott> does anyone know where the details of ghc's datatype memory representation are on the trac
01:43:55 <oerjan> i think i looked at it once...
01:45:19 <kmc> what ever came of the tweetable interpreter in C idea
01:45:52 <elliott> Gregor is presumably still working on it
01:47:35 <kmc> i was wondering if you could do a string rewriting system of some kind
01:48:19 <oerjan> elliott: http://hackage.haskell.org/trac/ghc/wiki/Commentary/Rts/Storage/HeapObjects#DataConstructors
01:48:35 <Gregor> kmc: I thought of that too, but couldn't figure out a way to make it short enough.
01:48:50 <elliott> oerjan: that could be more helpful...
01:48:56 <elliott> kmc: == strings in C == long
01:49:04 <Gregor> kmc: My current one is 116 characters and has 32 bit addressing.
01:49:40 <kmc> size-constrained programming is fun
01:49:48 <kmc> i enjoyed http://io.smashthestack.org:84/intro/
01:49:53 <oerjan> elliott: it's also out of date, vectored returns have been abolished (as i discovered last i was browsing around these pages)
01:51:23 <elliott> kmc: http://golf.shinh.org/ ftw (ok the latest challenges have sucked a bit)
01:51:37 <elliott> also, I still have the code for that boot sector Forth...
01:51:44 <elliott> IIRC I fixed the stupid bug I have
01:51:45 <oerjan> elliott: there does not seem to be a specific case for instance dictionaries, though
01:52:03 <elliott> oerjan: well it's just a data type. it's a matter of getting the right info table things
01:52:12 <Gregor> kmc: int*a,b[9<<20];main(){a=b;while(scanf("%d",a++)>0);a=b;while(*a)a+=(a[*a]-=a[a[1]])?3:a[2];while(a>b)putchar(*--a);}
01:52:15 <Gregor> kmc: Thoughts appreciated :P
01:53:15 <elliott> kmc: do you know anything about the representation of regular data types, then? :-P
01:53:37 <kmc> yeah, a data value is a (possibly tagged) pointer to a StgClosure or whatever
01:53:48 <kmc> which has an info pointer and field values
01:53:49 <oerjan> elliott: oh hm the end of this page which i went through might be relevant then http://hackage.haskell.org/trac/ghc/wiki/Commentary/Compiler/DataTypes
01:54:17 <CakeProphet> Gregor: why do you reset a to b after the first while loop?
01:54:19 <oerjan> ok it doesn't say much
01:54:24 <elliott> kmc: what do the info pointers look like :P
01:54:32 <kmc> some C struct
01:55:05 <kmc> grab a ghc tarball and look in include/ and rts/
01:55:14 <CakeProphet> Gregor: also I'm guessing the semicolon at the end of the last line of main is required?
01:55:51 <Gregor> CakeProphet: I reset a to b because otherwise *a is false.
01:56:00 <Gregor> CakeProphet: Yes, of course the semicolon is required ...
01:56:27 <CakeProphet> I ask because this is not required in Perl and I believe a few other languages.
01:56:50 <Gregor> Depends on whether it's a separator or terminator.
01:56:53 <Gregor> In C it's a terminator.
01:57:19 <elliott> I wonder what PAP actually stands for
01:58:32 <CakeProphet> Gregor: I'm trying to think of a macro that would reduce the size, but #define is quite a bit of character cost
01:58:35 <kmc> elliott, partial application
01:58:54 <Gregor> CakeProphet: Newline is terrible for twitter
01:59:34 <kmc> http://hackage.haskell.org/trac/ghc/wiki/Commentary/Rts/Storage/HeapObjects
02:00:25 <elliott> yes, oerjan linked that :P
02:00:30 <elliott> apparently it's outdated though
02:00:34 <elliott> oh yay it has stuff about info table
02:00:44 <CakeProphet> Gregor: well twitter is terrible for programs so who's at fault here?
02:00:45 <elliott> maybe it'll tell me what typeclasses' look like
02:00:48 <kmc> dunno how outdated but it does describe what a PAP is
02:00:53 <Gregor> CakeProphet: ... is it you?
02:03:32 <CakeProphet> I'm guessing using for instead of while is equally costly because you can't omit the ;;
02:03:59 <Gregor> int*a,b[9<<20];main(){a=b;while(scanf("%d",a++)>0);while(*--a)a+=(a[*a]-=a[a[1]])?4:a[2];while(a>b)putchar(*--a);} // just saved two characters :)
02:04:11 <Gregor> Or wait, did I ... maybe it's unusable now :P
02:05:24 <elliott> Gregor: show original code again?
02:05:31 <Gregor> int*a,b[9<<20];main(){a=b;while(scanf("%d",a++)>0);a=b;while(*a)a+=(a[*a]-=a[a[1]])?3:a[2];while(a>b)putchar(*--a);}
02:05:33 * elliott is sceptical that 9<<20 will work
02:05:56 <Gregor> It's a compile-time constant *shrugs*
02:06:02 <elliott> b[9<<20];main(a,z){while(scanf("%d",a++)>0);a=b;while(*a)a+=(a[*a]-=a[a[1]])?3:a[2];while(a>b)putchar(*--a);}
02:06:16 <Gregor> a is an int, not a pointer.
02:06:53 <Gregor> That is, in your code, a is an int. It should be a pointer.
02:07:25 <Gregor> *a;b[9<<20];main(){a=b;while(scanf("%d",a++)>0);a=b;while(*a)a+=(a[*a]-=a[a[1]])?3:a[2];while(a>b)putchar(*--a);} // apparently this works though lol
02:07:36 <elliott> Gregor: Yeah, but you can use pointers as int a lot of the time.
02:07:42 <elliott> Try it gcc set to K and R?
02:07:51 <elliott> If it can even do K and R code.
02:07:56 <elliott> Gregor: int is implicit obviously
02:08:19 <elliott> int has always been implicit, so yeah
02:08:25 <Gregor> elliott: But your code is wrong, because a is an int, not an int* in yours.
02:08:36 <elliott> Gregor: And yes but you can dereference an int if your compiler is lax enough
02:09:01 <Gregor> elliott: Apparently *a=b worked, at least GCC-wise :P
02:09:05 <Gregor> I'll try this in OpenWatcom some time :P
02:09:09 <elliott> Gregor: It's obviously valid
02:09:22 <elliott> "a=b;while(scanf("%d",a++)>0);a=b"
02:09:25 <Gregor> elliott: Yeah, it is, but it's all wtf.
02:09:32 <elliott> "while(scanf("%d",b++)>0);"
02:09:36 <elliott> Can you increment an array :P
02:09:40 <Gregor> b[9<<20];*a=b;main(){while(scanf("%d",a++)>0);a=b;while(*a)a+=(a[*a]-=a[a[1]])?3:a[2];while(a>b)putchar(*--a);}
02:10:05 <elliott> Gregor: a+=(a[*a]-=a[a[1]])
02:10:09 <elliott> I refuse to believe that's well-defined.
02:10:13 <Gregor> I knew that int was the default type for everything, what I /didn't/ know is that you can still make pointers and arrays without saying "int"
02:10:18 <elliott> There is _definitely_ sequencing point junk going on there.
02:10:42 <CakeProphet> > (length "#define W(x) while(x)\n") - (length "while" * 3 + 3)
02:11:02 <Gregor> elliott: Uhh, no? a doesn't change on the RHS, so there's only one order that can be implemented in. Now, that may very well still be undefined by spec, even though it's only implementable one way ...
02:11:27 <elliott> Gregor: Hmmmmmmmmmmmmmmmmmmmmmm
02:11:32 <CakeProphet> > (length "#define W while\n") - (length "while" * 3 + 3)
02:11:34 <elliott> fizzie: Deewiant: Language lawyer ping
02:11:55 <CakeProphet> yeah I'm juts golfing. twitter is lame. :P
02:11:59 <elliott> Gregor: Oh hmm, the ?: might count as a sequencing point
02:12:10 <Gregor> elliott: That'd be convenient, but I doubt it :P
02:12:19 <elliott> Gregor: OK so scanf is lame, surely you can input it in a nicer way.
02:12:36 <Gregor> elliott: using e.g. getchar is one character more.
02:13:16 <elliott> Hope that the pointers to the arguments work out right :P
02:13:24 <elliott> Hmm, I wonder if POSIX lets you send arbitrary pointers over exec
02:13:26 <CakeProphet> > (length "#define W while\n") - (length "while" * 3 - 3)
02:13:31 <elliott> Arbitrary integers as pointers
02:13:53 <CakeProphet> I think that is the correct calculation. you are only losing 12 characters from shortening the whiles.
02:13:59 <Gregor> Uhh, no? That ... makes no sense. Your memory layout is unrelated on the other side.
02:14:25 <CakeProphet> > (length "#define W while(\n") - (length "while(" * 3 - 3)
02:14:33 <elliott> Gregor: Why can't I just execv(...,(ptr)99,(ptr)909090) X-D
02:15:03 <Gregor> elliott: Idonno about POSIX, but the ELF ABI definitely don't work that way :P
02:15:14 <Gregor> It copies the args into the top of the stack when you call.
02:15:19 <Gregor> So they have to be ... y'know ... strings.
02:16:31 <elliott> Just null-terminate your output
02:16:32 <CakeProphet> > (length "#define W ;while(\n") - (length ";while(" * 3 - 4)
02:16:52 <Gregor> elliott: b is an int *
02:16:59 <Gregor> elliott: So that's platform-specific behavior.
02:17:17 <elliott> You might need to cast via void-pointer to be pedantically correct
02:17:33 <elliott> but so what, just mangle it afterwards
02:17:38 <Gregor> As it stands, this is platform-neutral.
02:17:46 <elliott> Your mom is platform neutral
02:17:52 <elliott> Anyway no it isn't because int is platform-specific
02:18:39 <Gregor> Mmmmmmmm ... you can write code that supports ints of any size >= something. So, although it exposes platform differences, you don't need to adapt to them to write code.
02:19:02 <Gregor> (Because people will totally write code in this :P )
02:19:27 <CakeProphet> if the first while had a ; in front of it then my macro would be exactly equivalent to the current code in byte length. :P
02:19:33 <elliott> b[9<<20],*a=b;main(){while(scanf("%d",a++)>0);a=b;while(*a)a+=(a[*a]-=a[a[1]])?3:a[2];for(;a>b;putchar(*--a));}
02:20:59 <elliott> Gregor: Your current output is limited in length
02:21:08 <elliott> Which is also limited but oh well
02:21:39 <Gregor> I know I didn't set strict requirements, but I also don't want to make it so you can't write 99 bottles of beer :P
02:22:36 <elliott> I don't like your practice-oriented thinking
02:22:46 <Gregor> I'm walkin' a line here X-P
02:22:54 <elliott> Gregor: b[9<<20],*a=b;main(){while(scanf("%d",a++)>0);for(a=b;*a;)a+=(a[*a]-=a[a[1]])?3:a[2];while(a>b)putchar(*--a);}
02:23:19 <elliott> Gregor: b[9<<20],*a=b;main(){for(scanf("%d",a++)>0,a=b;*a;)a+=(a[*a]-=a[a[1]])?3:a[2];while(a>b)putchar(*--a);}
02:23:38 <elliott> One hundred and three bytes :)
02:23:58 <Gregor> Whoah, wtf just happened though.
02:24:03 <Gregor> I have to re-understand this code X-D
02:24:21 <Gregor> elliott: Wait ... I'm not confident that your resultant code ... does anything vaguely sensible.
02:25:04 <oerjan> it seems to me like it reads only one int
02:25:06 <elliott> for(a;b;c)d; is like a;while(b){d;c;}
02:25:21 <Gregor> Yeah, with scanf as an initializer this is nonsense.
02:25:24 <elliott> Gregor: So my transformation is perfectly valid.
02:25:31 <Gregor> Because it was in a loop ...
02:25:46 <Gregor> Your program can be no more than one int :P
02:25:59 -!- sebbu2 has joined.
02:26:23 <elliott> Gregor: Well, as long as int is big enough
02:26:29 <Gregor> elliott: It ... is not :P
02:26:47 <Gregor> elliott: Every program will immediately terminate.
02:27:09 <elliott> That's such goal-oriented thinking.
02:27:17 <elliott> Mine is size-oriented, which is your original goal.
02:27:34 <Gregor> Size is just the packaging of those goals :P
02:28:01 <Gregor> CakeProphet: #define iz sukk
02:28:11 <elliott> Gregor: So are we golfing the Kolgomorov complexity of an FSM
02:28:14 <Gregor> But #esoteric ... #esoteric is awesome 8-D
02:28:24 <elliott> Can we do it in a language that isn't C so that we can actually acheive TCness :P
02:28:45 <Gregor> elliott: Suggestion? sed maybe?
02:28:45 <CakeProphet> > (length "#define W(x);for(;x;);\n") - (length ";while();" * 3 - 4)
02:28:50 -!- zzo38 has joined.
02:28:52 -!- sebbu has quit (Ping timeout: 245 seconds).
02:28:52 <Gregor> It has to be terrible :P
02:29:04 <elliott> Gregor: HaskellHaskellHaskellHaskellHaskellHaskellHaskellHaskellHaskellHaskellHaskellHaskellHaskellHaskellHaskellHaskellHaskell
02:29:15 <elliott> J has a really tiny Factran interpreter
02:29:22 <Gregor> elliott: Can you write one-line Haskell programs DURPADURP LOLOLOL I DONT GET SYNTAXES
02:30:14 <elliott> Please tell me you know of J :P
02:30:31 <elliott> Gregor: It's the really concise ASCII APL derivative? Array language?
02:30:35 <elliott> Come on, it's been talked about tons in here.
02:30:45 <kmc> a FRACTRAN interpreter in Haskell could be pretty short
02:30:51 <CakeProphet> Gregor: while elliott seems to be a Haskell fanboy, he actually secretly worships J.
02:30:58 <CakeProphet> and only talks about it occasionally to keep it a secret.
02:31:05 <elliott> J is pretty close to a perfect language, apart from its IO facilities which suck and its lack of bignums
02:31:13 <elliott> But it's pretty much perfect in its niche
02:32:49 <elliott> oerjan: ooh, someoen wrote a fractran self-interp
02:33:02 <elliott> http://www.math.uiuc.edu/~beder/interpreter.fr
02:33:13 <elliott> details at http://stackoverflow.com/questions/1749905/code-golf-fractran/1773868#1773868
02:33:30 <elliott> http://www.math.uiuc.edu/~beder/interpreter.frp
02:34:58 <elliott> oerjan: oh wow, someone made a tiny one
02:35:02 <elliott> http://stackoverflow.com/questions/1749905/code-golf-fractran/1802570#1802570
02:37:10 <CakeProphet> Gregor: with Perl your golfs will be butiful and eliphant
02:37:27 <Gregor> And your not-C languages.
02:38:12 <CakeProphet> though J looks like an excellent choice from what I can tell.
02:38:30 <elliott> So does anyone know OpenCL
02:38:50 <elliott> nm: /usr/lib/nvidia-current/libOpenCL.so: no symbols
02:39:13 <CakeProphet> elliott: I know I click a little black box with a > and _ in it on my top panel to open command line
02:39:37 <elliott> why did you type that and hit enter
02:39:46 <elliott> NO I DONT WANT TO WATCH A VIDEO TUTORIAL YOU SHITFACKS
02:40:26 <elliott> http://developer.amd.com/sdks/AMDAPPSDK/assets/AMD_APP_SDK_Getting_Started_Guide_v2.4.pdf
02:40:52 <elliott> OK MAYBE THER EIS A CUDA TUTORIAL MAYBE I WONT KILL EVERYONE
02:42:58 <kmc> http://www.malevole.com/mv/misc/killerquiz/ ?
02:43:45 <CakeProphet> I should make a language that consists entirely of Unicode character commands and nothing else
02:43:59 <elliott> CakeProphet: way ahead of you, years ago
02:44:58 <oerjan> > let f l=unfoldr(fmap(join(,)).find((<2).denominator).map(*)l)in f[3%2]72
02:44:59 <lambdabot> Couldn't match expected type `GHC.Real.Ratio a
02:45:15 <elliott> http://www.codeproject.com/KB/GPU-Programming/IntroToOpenCL.aspx ;; so I finally find a non-video tutorial about OpenCL and it's using fucking C++ bindings.
02:45:48 <elliott> "See the OpenCL™ 1.0 specification for the corresponding C API."
02:45:54 <elliott> god i hope itsfreely available
02:46:07 <elliott> http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/
02:47:04 <oerjan> > let f l=unfoldr(fmap(join(,)).find((<2).denominator).mapM(*)l)in f[3%2]72
02:47:22 -!- GreaseMonkey has joined.
02:47:22 -!- GreaseMonkey has quit (Changing host).
02:47:22 -!- GreaseMonkey has joined.
02:49:07 <elliott> http://www.khronos.org/registry/cl/specs/opencl-1.1.pdf
02:49:19 <elliott> I'm pretty sure that's one of the Word defaults
02:49:59 * Sgeo ponders the Reia language
02:52:13 <CakeProphet> #esoteric-minecraft IS A POLICE STATE BAAAAAWWW
02:53:14 <elliott> I'll unban me if you find a decent chunk of public domain OpenCL sample code because this reference is terrible
02:54:02 <monqy> Hi, I'm Kafka the Cat, and I'm here to take you on a quick tour of the Reia programming language.
02:54:05 <monqy> http://reia-lang.org/images/kafka.jpg
02:54:19 <monqy> its staring into my soul
02:54:47 <elliott> I think that's what Kafka's meant to do
02:58:29 <monqy> so I'm trying to find what's interesting about reia
02:59:10 <CakeProphet> elliott: http://www.google.com/search?sourceid=chrome&ie=UTF-8&q=opencl+sample
02:59:34 <elliott> I guess some of those might work, I'll look at them in a minute
03:00:31 <monqy> reia commit message: Get rid of the weird ass "Main" module which made no sense, factoring it into
03:00:32 <elliott> It's not my fault you googled with samples and me with examples
03:00:34 <monqy> the System module. Oh, and "string".puts() is now officially the way you should be printing strings in Reia. If someone asks you for a Reia hello world and you tell them System.puts("Hello, World!") you're DOING IT WRONG
03:00:56 <CakeProphet> elliott: lulz I'm just mad at google knowledge dawg
03:01:05 <CakeProphet> bitches be all like "yo how u get so god?"
03:05:03 <elliott> Hight Dynamic Range Rendering with God Rays Effect Sample
03:05:11 <oerjan> and google is mad at understanding CakeProphet spelling
03:06:06 <monqy> none of the reia examples on the reia github are interesting they're all boring
03:06:50 <oerjan> googling "lol y cats land on feet yo" gives some good hits
03:06:56 <Sgeo> monqy, a not terrible language on the Erlang VM?
03:07:10 <monqy> how is it not terrible
03:07:18 <monqy> and how are other languages on the erlang vm not not terrible
03:07:33 <Sgeo> monqy, is Erlang considered a decent language?
03:07:43 <Sgeo> Or are there other languages on the Erlang VM that I don't know about?
03:07:48 <kmc> "the amazing power of blocks"
03:07:53 <monqy> I forget nearly everything I ever knew about Erlang
03:08:22 <monqy> learned the basics one day, never bothered to use it, forgot it
03:08:49 <elliott> the story of monqy and erlang
03:09:07 <CakeProphet> it has a very dependable standalone platform, good concurrency support, and allows hot swapping of code. The language itself is somewhat mediocre I guess but the platform is pretty solid.
03:09:11 <oerjan> evil scientist project #663: breed cats to land on head
03:09:21 <elliott> what does very dependable standalone platform even mean
03:09:26 <elliott> "the interpreter doesn't segfault much"?
03:09:44 <monqy> well I certainly want a segfaulty interpreter
03:09:54 <monqy> but I guess saying I want it works too
03:10:28 <monqy> though if I was constructing it in that manner I would have started with "yes" and left out the "certainly"
03:10:48 <kmc> are there people who actually understand Haskell's type system, but still prefer dynamic types in general?
03:10:56 <kmc> i don't know many such people, but i spend all day talking to fellow Haskell zealots
03:11:18 <elliott> kmc: the only examples I know involve people whose self-asserted understanding of types I doubt
03:11:19 <CakeProphet> kmc: I have a good grasp of Haskell's type system but also find dynamic typing to be a good approach as well.
03:11:19 <monqy> I remember disliking erlang's syntax and type system
03:11:22 <Sgeo> What would Bracha count as?
03:11:23 <kmc> most of the arguments against i hear are "Java is so verbose!" and "dynamic types give me a single ad-hoc variant type!"
03:11:38 <elliott> CakeProphet: tell me about how much you love PHP then?
03:11:51 <CakeProphet> PHP is like perl if perl were not a good language.
03:11:54 <Sgeo> elliott, one of my classes will involve PHP
03:11:57 <kmc> i use dynamic types in Haskell sometimes
03:12:05 <monqy> lets laugh at sgeos class
03:12:07 <elliott> Sgeo: i don't care, we've told you to transfer about nine billion times
03:12:15 <elliott> you've got one person to blame (the person is you)
03:12:20 <kmc> it seems clear that checking should be the default, and checks disabled when necessary, rather than the opposite
03:12:29 <CakeProphet> elliott: come on can't I be neutral and also have strong opinions of bad languages, as long as my preferred languages go across the spectrum?
03:12:41 <CakeProphet> it still makes me neutral about categories of languages.
03:12:47 <elliott> kmc: haskell programs still do dynmic type checking, mind you. like input validation.
03:12:51 <monqy> categories of languages?
03:13:13 <CakeProphet> dynamic typing, static typing, lazy, strict, functional, OO, procedural, etc
03:13:41 <kmc> mostly the categories are bullshit
03:13:52 <monqy> which is why I asked
03:13:52 <kmc> at least if you want them to form some kind of taxonomy
03:14:00 <kmc> there's a many-dimensional space of language attributes
03:14:10 <kmc> which combine and co-exist and interact in all kinds of interesting ways
03:14:19 <CakeProphet> I want them to form words that can describe what I am talking about. is that like a taxonomy?
03:14:52 <kmc> i feel the main reason to rigidly divide the world into functional and OOP languages is to justify ignoring "functional languages", or to justify hating on OOP languages without understanding them
03:14:52 <CakeProphet> no I don't think that they're discrete categories.
03:16:04 * oerjan considers static type checking of input by quantum suicide
03:16:04 <CakeProphet> honestly what's wrong with having a word to describe an observed characteristic shared by multiple languages?
03:16:45 <oerjan> every universe in which someone tries sql injection to your service is destroyed.
03:17:41 <CakeProphet> oerjan: sounds like a risky security mechanism.
03:17:52 <CakeProphet> unless we're the alpha timeline of course.
03:18:35 <elliott> if there's quantum immortality, we're fine.
03:19:26 <elliott> I should write a Haskell DSL that compiles to it and then never use it again
03:19:27 <zzo38> elliott: Well, sort of. Quantum immortality, means, even if you are dead, you are still live in other timeline, therefore you can still observation and doing everything like before.
03:19:31 <zzo38> Just not in the other timeline.
03:20:11 <zzo38> I think Haskell's type system is mathematically good type system. You can use classes in some cases too.
03:20:17 <elliott> HOLY SHIT THESE EXAMPLES ARE TERRIBLY-WRITTEN >_<
03:20:20 <elliott> ciErrNum = clEnqueueWriteBuffer(cqCommandQueue, cmDevSrcA, CL_FALSE, 0, sizeof(cl_float) * szGlobalWorkSize * 4, srcA, 0, NULL, NULL);
03:20:21 <elliott> ciErrNum |= clEnqueueWriteBuffer(cqCommandQueue, cmDevSrcB, CL_FALSE, 0, sizeof(cl_float) * szGlobalWorkSize * 4, srcB, 0, NULL, NULL);
03:20:23 <elliott> Or rather the API is terrible
03:21:43 <elliott> "oclCheckErrorEX" I see Microsoft had their way with this API >_<
03:23:02 <monqy> what of the alternatives to opencl, assuming they're good and exist??
03:24:39 <CakeProphet> as duration of computer use t increases, number of idling terminals n increases
03:28:34 <elliott> monqy: CUDA, nvidia-only and basically deprecated and probably no nicer
03:28:48 <elliott> ok I don't have OpenCL.h. I guess I need to download the "SDK"
03:29:03 <elliott> so much for an open fucking standard, the .hs are available online but I doubt that'll do me much good
03:29:33 <elliott> On the same day Khronos Group announced the new OpenCL v1.1 specification update (June 14th, 2010), NVIDIA released OpenCL v1.1 pre-release drivers and SDK code samples to all GPU Computing registered developers. Log in or apply for an account to download latest NVIDIA Drivers and Toolkits.
03:29:39 <elliott> I'm going to eat your brains.
03:29:51 <elliott> I am not telling you where I fucking live you pieces of crap aaargh give me the fucking header files
03:33:10 <monqy> http://www.khronos.org/registry/cl/ ?????
03:33:17 <monqy> http://www.khronos.org/registry/cl/api/1.1/opencl.h ?????
03:33:28 <monqy> or is that not the right file
03:34:06 <elliott> CakeProphet: The links you found didn't really help me, but fine
03:34:10 <elliott> No more insulting greatness, though
03:35:16 <elliott> oerjan: excuse me, I banned him for insulting the greatest musical work of our century.
03:35:23 <elliott> It would be crime to let him stay.
03:35:39 -!- mauke has quit (Disconnected by services).
03:35:42 -!- mauke_ has joined.
03:35:43 <elliott> oerjan: yes (Insane Clown Posse collaborating with Jack White to cover Mozart's Lich Mich im Arsch, obviously)
03:37:15 -!- MDude has changed nick to MSleep.
03:37:17 * CakeProphet is by defintion, unbannable for any legitimate reasons
03:38:10 -!- mauke_ has changed nick to mauke.
03:39:32 <elliott> CakeProphet: Hey, I'm going to reban you again, because the nvidia code you linked me to uses fucktons of helpers that I can't find the definitions of
03:53:15 <elliott> OpenCL error on line 37: CL_OUT_OF_HOST_MEMORY
03:55:57 <elliott> monqy: i am just going to write this one program and then write a haskell library that symbolically compiles code to OpenCL so that I never have to do this again......
04:02:24 -!- ive has joined.
04:04:21 <kmc> aren't there a couple of those already?
04:04:54 <elliott> kmc: Are you thinking of GPipe?
04:05:08 <elliott> OpenCLRaw library: The OpenCL Standard for heterogenous data-parallel computing
04:05:11 <elliott> is the only grep on hackage for opencl
04:05:30 <elliott> There's a CUDA binding too but it's low-level.
04:05:37 <elliott> I imagine you _are_ thinking of GPipe since it was publicised a while back.
04:05:37 <kmc> there's Nikola
04:05:40 <kmc> which might be CUDA too
04:05:58 <elliott> Hmm, no Nikola on Hackage but I think I've heard of it before.
04:06:12 <elliott> Still, it will inevitably be inferior to what I write.
04:06:28 <elliott> "We describe Nikola, a first-order language of array computations embedded in Haskell that compiles to GPUs via CUDA"
04:07:03 <kmc> there's also vague mutterings about a GPU backend to Double Penetration Haskell
04:07:11 <kmc> sorry Data Parallel Haskell
04:07:30 <elliott> That requires, like, hacking GHC and stuff.
04:07:51 <kmc> weren't you begging me for details of the StgClosure struct layout earlier?
04:08:18 <elliott> kmc: Yeah, but I was doing it all from within the cosy confines of a Haskell file.
04:11:34 <elliott> kmc: Oh, I forgot that's why I disliked DPH
04:17:07 <elliott> kmc: Thanks for the pointer to Nikola, I think I can steal a lot of things from this paper
04:25:30 <elliott> copumpkin: You not asleep yet?
04:25:34 <elliott> And furthermore: What _is_ sleep?
04:26:05 -!- derrik has joined.
04:28:38 -!- augur has joined.
04:35:01 <elliott> HOW CAN YOU BE OUT OF HOST MEMORY
04:35:32 <oerjan> it was leaked for the use of skynet
04:42:52 <elliott> YOU GET TO HELP ME WITH MY OPENCL COED
04:52:25 <elliott> hey oerjan how does opencl........
04:54:09 <shachaf> oerjan: Are you going to HacBeans?
04:54:15 <shachaf> elliott: Are you going to HacBeans?
04:54:37 <elliott> shachaf: Maybe if you can tell me what typeclass dictionaries look like in memory I will :-P
04:54:57 <shachaf> elliott: Just like any other kind of dictionary?
04:55:01 <oerjan> elliott: also, i know almost nothing about opencl.
04:58:27 <elliott> How can you run out of memory good GOD
04:58:53 <monqy> how are you running out of memory
04:58:57 <monqy> how does that happen
05:00:12 <copumpkin> elliott: just out of curiosity, why are you doing all that unsafe stuff to pass custom dictionaries, rather than just constructing a custom instance?
05:00:38 <elliott> copumpkin: You can't do that at runtime
05:00:57 <copumpkin> data OrdInstance a = OrdInstance (a -> a -> Bool)
05:01:00 <kmc> you can, effectively
05:01:00 <copumpkin> data OrdInstance a = OrdInstance (a -> a -> Bool) a
05:01:12 <copumpkin> instance Ord (OrdInstance a) where
05:01:22 <copumpkin> you can't guarantee they're the same?
05:01:26 <elliott> class Foo a where bar :: (forall f. f a -> g a) -> g ()
05:01:43 <elliott> I mean you can do it for each individual class
05:01:53 <elliott> But I'm not sure you can really do it in general
05:02:01 <elliott> But anyway bundling it with values like that is gross
05:02:14 <elliott> copumpkin: Anyway, this started out as something which let you define an instance for a newtype and then use that as the instance for the main type in context
05:02:32 <elliott> i.e. define a crazy show instance for a newtype over Ints and then use it as an instance for Ints in a certain context
05:02:49 <elliott> I'm just trying to generalise that by coercing the obvious record translation of a class into my existential dictionary type
05:03:17 <elliott> Which lets you construct, at runtime, an arbitrary instance record for a type, and then use it as an instance for that type for some code
05:03:50 <elliott> The problems are twofold: one, GHC likes to make a bunch of correct assumptions about instances that my crazy code violates; two, I can't get record → dictionary coercion to work quite right, although I've had some very promising failures.
05:04:07 <elliott> I'm focusing on the latter because I have this sneaking suspicion the former might not be entirely resolvable.
05:05:09 <elliott> >>> ctx = cl.create_some_context()
05:05:09 <elliott> Traceback (most recent call last):
05:05:09 <elliott> File "<stdin>", line 1, in <module>
05:05:09 <elliott> File "/usr/lib/pymodules/python2.6/pyopencl/__init__.py", line 346, in create_some_context
05:05:10 <elliott> pyopencl.RuntimeError: Context failed: out of host memory
05:05:14 <elliott> Oh good, at least it fails with the bindings too.
05:06:53 <CakeProphet> yes consistency of failure is a good thing .
05:08:57 <elliott> Maybe my GPU just has no memory :|
05:10:20 <copumpkin> I'll rent you my extensive GPU collection if you want
05:10:28 -!- derrik has quit (Read error: Connection reset by peer).
05:11:03 <elliott> copumpkin: I'll take you up on that, if a restart doesn't fix things
05:11:06 -!- derrik has joined.
05:11:16 -!- derrik has left.
05:11:16 <copumpkin> actually, my machine is offline right now
05:11:27 <copumpkin> otherwise I'd probably just let you use it for free
05:11:28 <zzo38> The "dviout" program seems to have some mistakes in it, such as lack of all commands available in menus and keyboard configuration, and some things don't work. But in general the program works OK, and in fact it is the only one that can print.
05:11:32 <copumpkin> assuming you don't peg my GPUs for days on end
05:12:57 -!- elliott has quit (Read error: Connection reset by peer).
05:13:08 -!- elliott has joined.
05:13:12 <zzo38> I want to use "CMYKX" color specials, where the "X" parameter is like "K" but is used only on printers that do not print in colors (or if color printing is turned off).
05:13:16 <elliott> Now it's happy... I guess I really was out of ram :-|
05:13:17 <CakeProphet> copumpkin: no worries, I don't think any of us are into that stuff.
05:13:53 <zzo38> (Each parameter is one byte in range 0-255)
05:24:35 <elliott> OpenCL error on line 62: CL_BUILD_PROGRAM_FAILURE
05:26:27 <kmc> have now watched Erlang: The Movie four times and I still don't know Erlang
05:26:47 <kmc> maybe i should read some documentation instead of just watching swedish people make telephone calls
05:27:29 <CakeProphet> nothing gets me quite as excited as writing IMAP code.
05:28:29 <CakeProphet> there's a standard practice something-or-other that is highly confusing to me though.
05:28:51 <elliott> Compilation error: <program source>:1:34: error: invalid address space for argument to __kernel function
05:28:52 <elliott> __kernel void crack(__global int a)
05:29:34 <elliott> I'm cracking crypt() because why not.
05:29:50 <CakeProphet> that's interesting. I would not know how to do that.
05:31:23 <zzo38> What is the algorithm for using minimum storage space writing a series of natural numbers to a file, each one having a maximum, but that the maximums are not known ahead of time?
05:32:24 <mauke> each natural number has a maximum? well, look at that
05:33:37 <zzo38> For example, the first item is a number ranging from zero to eight. If it is five, then the next number ranges from zero to forty-two; but if the first number is two, then the nxt number instead ranges from zero to sixteen.
05:33:48 <elliott> I found imaplib easy and high-level when I needed to wrangle IMAP from Python.
05:35:59 <zzo38> Is there any such algorithm?
05:36:57 <CakeProphet> but all of the methods are pretty much the protocol verbatim, with some exceptions.
05:37:06 <CakeProphet> raises Exceptions instead of returning the bad responses.
05:37:52 <zzo38> Is there anything better than just using bignums for this purpose?
05:40:06 <oerjan> <kmc> maybe i should read some documentation instead of just watching swedish people make telephone calls <-- clearly the problem is that you don't know swedish.
05:42:23 -!- lifthrasiir has quit (Read error: Connection reset by peer).
05:42:55 -!- lifthrasiir has joined.
05:50:23 -!- oerjan has quit (Quit: Good night).
05:50:32 -!- lifthras1ir has joined.
05:56:57 <CakeProphet> ORing a lot of search criteria in IMAP looks somewhat painful
05:58:34 <CakeProphet> elliott: the documentation is kind of poor as well. It doesn't describe how the data is returned from search, nor does it describe whether or not an exception is raised on NO or BAD responses
06:00:52 <CakeProphet> find_element_by_id_name_or_class is a good one
06:02:33 <elliott> oecan i have the numbers one to eight thnaks
06:05:17 <CakeProphet> elliott: can IMAP search keys have parens? I'm wondering how or works.
06:08:45 <elliott> parentheses with fixed prefix notation
06:10:20 -!- itidus20 has joined.
06:13:49 <CakeProphet> they just chill out and wait to be garbage collected.
06:14:17 <CakeProphet> they may have forgotten to delete them or something.
06:17:11 <Sgeo> Why didn't you need 9?
06:18:19 <elliott> monqy: -9 -99 -99 -999 -9999 -99999 -999999 -9 -9
06:18:27 <monqy> is that it working
06:18:28 <elliott> ok now. NOW to try it with a HUGE array.
06:18:33 <monqy> is that what it's supposed to do
06:19:17 -!- itidus20 has quit (Ping timeout: 276 seconds).
06:28:12 <CakeProphet> string[] data = expression.Split("==".ToCharArray());
06:28:18 <CakeProphet> yep, that's how you evaluate infix operators.
06:28:31 <elliott> I thought you were under an NDA.
06:39:11 -!- GreaseMonkey has quit (Quit: The Other Game).
06:45:52 -!- augur has quit (Remote host closed the connection).
06:55:51 <zzo38> Why does Haskell say a name is ambiguous even if only one of the choices is of the correct type?
06:56:39 <mauke> because Haskell doesn't care about the type
06:57:20 <zzo38> What do you mean by that?
06:59:15 <zzo38> For example, you have function with the same name but imported from different modules, it says ambiguous, both functions of same name they require different type of parameter, and you have specified the parameter which is one of those correct types.
06:59:40 <CakeProphet> I guess the idea is that it doesn't do that because that would assume one is the correct type.
07:00:46 <CakeProphet> so it would be more helpful to make sure the name is not ambiguous so it does not accidentally use the wrong function.
07:01:04 <CakeProphet> thus making debugging not quite so mysterious.
07:01:25 <zzo38> Is there an extension to make it not error for that?
07:01:45 <CakeProphet> there is actually not a GHC extension for everything. This is surprising I know.
07:03:48 <zzo38> I suppose in some cases you can do it by making a class
07:03:57 <CakeProphet> zzo38: you can however, always just disambiguate your function names, either by qualifying the Module or defining two different names in your module.
07:04:09 <zzo38> CakeProphet: I know you can do that too.
07:06:38 <CakeProphet> practically speaking, the compiler should a) try to compile your program accurately and have it run as fast as possible, b) aid the programmer in debugging their programming.
07:07:16 <CakeProphet> so I guess requiring qualified names when names overlap is helping with part b.
07:09:03 <zzo38> It should be able to turn off part (b) in cases where it is unable to do part (b)
07:09:29 <zzo38> Actually the same should apply to part (a) in some cases, maybe.
07:09:51 <elliott> it is doing part (b), you're just not listening
07:09:55 <mauke> ghc -fignore-errors -fcompile-approximately
07:10:12 <elliott> and asking us how to shut it up
07:10:27 <elliott> your program is wrong, fix it
07:11:01 <CakeProphet> elliott: uh, imap.uid("FETCH", uid, "BODY") should just give me the body text of the email right?
07:11:12 <CakeProphet> I am having a hard time understanding the RFC :P
07:11:21 <zzo38> It should only turn on part (a) and (b) if such things are possible to do, and turn them off otherwise (possibly displaying warnings if necessary, or errors if it is unable to do what you typed at all)
07:11:48 <CakeProphet> oh dear, I've defined a convention for this discussion.
07:12:04 <zzo38> (Or, unable to do it properly, at least.)
07:12:13 <CakeProphet> there is officially a part a and part b now. What have I done.
07:13:21 <CakeProphet> requiring overlapping names to be qualifies is aiding you in debugging, because even if only one of the names matches the types in that context
07:13:38 <CakeProphet> so it is in effect completely negating the point of having static typing.
07:14:34 <zzo38> If it is still the wrong function then it should be error. Or, if the name "a" is ambiguous and you type "b = a" without a type signature, then that is also ambiguous and is error.
07:14:56 <CakeProphet> whether or not it's the wrong function is not something the compiler knows.
07:15:02 * Sgeo proceeds to add psychic abilities to Haskell
07:15:09 <CakeProphet> the function could have the right type and still be the wrong function, because the context is wrong.
07:15:16 <CakeProphet> thus you won't receive any indication that there is an error in your program
07:15:21 <CakeProphet> and will get a logic error in that situation.
07:15:23 <Sgeo> Next step: Making it so the programmer only has to type one line:
07:15:25 <zzo38> CakeProphet: Why? It should know, if there is only one function of the correct type and only one possible type in that context.
07:15:51 <Sgeo> Do The Opposite Of What I Mean
07:15:59 <CakeProphet> the context may be the wrong one and match the wrong function.
07:16:00 * Sgeo watches the compiler explode
07:16:11 <CakeProphet> but everything types because you have ambiguous names.
07:16:20 <CakeProphet> whereas in the non-ambiguous situation you would get a type error.
07:17:13 <CakeProphet> zzo38: GHC is trying to help you make your program accurate. you should be glad.
07:17:37 <zzo38> I mean, for example, if "a" is ambiguous because one module it is Int, one module it is String, then you have "b = a; c :: Int; c = a; d :: Int; d = a;" and you have no other module with "a" then definition of "b" is error but "c" and "d" should not be ambiguous because there is only one possible match.
07:17:47 <CakeProphet> yes I understand completely what you are saying
07:17:59 <CakeProphet> I understand the premise and understand that it is possible.
07:18:10 <Sgeo> What if the one possible match is the wrong match from what the programmer means?
07:18:44 <CakeProphet> the compiler cannot determine the "right" function from an ambiguous set of functions because that is assuming that your code is already correct.
07:19:10 <CakeProphet> "right as in "this is what I wanted the program to do at runtime"
07:19:23 <zzo38> Sgeo: Then the programmer made a mistake by specifying the wrong type.
07:19:45 <CakeProphet> zzo38: and won't know until he runs the program. might as well use Python or Perl.
07:20:00 <Sgeo> And CakeProphet is saying that the entire point of type checking is to help prevent the programmer from making mistakes as much as possible.
07:20:28 <zzo38> I always specify the type when defining a function.
07:22:17 <CakeProphet> the problem is that your context has a mistake, a bug if you will
07:23:16 <CakeProphet> the functions, whether explicitly typed or not, are in the wrong place, but GHC just goes ahead and matches a function from a list of ambiguous functions and everything types correctly
07:23:30 <CakeProphet> even though the program is wrong and the situation can be avoided if the names were non-ambiguous
07:23:58 <CakeProphet> you may not have just two ambiguous choices.
07:24:02 <lambdabot> Data.HashTable fromList :: Eq key => (key -> Int32) -> [(key, val)] -> IO (HashTable key val)
07:24:02 <lambdabot> Data.IntMap fromList :: [(Key, a)] -> IntMap a
07:24:02 <lambdabot> Data.IntSet fromList :: [Int] -> IntSet
07:24:06 <elliott> why are you guys beating your heads against a brick wall
07:25:07 <CakeProphet> programmers who enjoy programming obviously also enjoy pain.
07:26:27 <monqy> good thing i hate programming 8)
07:26:38 <zzo38> If there is more than one choice of the correct type then it should still be error, though.
07:26:59 <elliott> "The programming language used to write computation kernels is based on C99 with some limitations and additions. It omits the use of function pointers, recursion, bit fields, variable-length arrays, and standard C99 header files."
07:27:25 -!- Nisstyre has joined.
07:28:15 <CakeProphet> zzo38: even though the scenario I described isn't necessarily going to happen or even be likely to happen, it can still happen and really you are just better off avoiding it.
07:28:25 <CakeProphet> so add a M. to the front of your names and be happy.
07:29:05 <zzo38> Or, in some cases, I can write a class.
07:31:31 <zzo38> A class might not work in all cases, but it should work in many cases where such things is useful to have.
07:31:48 <CakeProphet> add enough parameters and it will work most likely.
07:35:18 <CakeProphet> class FromListable t a | t -> a where fromList :: [a] -> t
07:35:54 <CakeProphet> not sure if the fundep is necessary. I don't really understand when fundeps are needed.
07:35:56 -!- ive has quit (Quit: leaving).
07:36:50 <mauke> when things would be ambiguous otherwise
07:41:50 <CakeProphet> I remember when I first started reading about telnet when I started working on my first MUD.
07:42:05 <CakeProphet> I think that's when I first understood the idea of an interface in programming.
07:43:48 <CakeProphet> telnet is neat because it's basically an interface interface.
07:44:12 <CakeProphet> "Please support this feature" "Okay I will support this feature"
07:45:03 <elliott> does anyone know how DES works
07:45:11 <CakeProphet> BUT IT IS MY FIRST PROTOCOL. MY FIRST PROTOCOL-LOVE.
07:46:16 <elliott> hmm, I think I'll wait for ais
07:48:46 <zzo38> I think telnet is not too bad. It is good. Almost everything is optional, anyways. If you do not need telnet commands, you can use raw terminal connection; but usually you would use telnet commands to ensure terminal compatibility.
07:49:43 <CakeProphet> okay so are attachments part of the DATA message in SMTP?
07:49:56 -!- itidus20 has joined.
07:50:16 <zzo38> CakeProphet: Yes; the entire message and everything with it (attachment, etc) are all sent using DATA. The only thing isn't is recipient and sender address.
07:50:49 <CakeProphet> okay so if I only want the text what is that?
07:52:59 <CakeProphet> at least I am learning things from all of this.
07:53:32 <elliott> does anyone here have experience with OpenCL? :P
07:54:12 <CakeProphet> elliott: there is totally an #opencl though
07:54:51 <CakeProphet> it is your second option when Google fails you.
08:00:32 * elliott notes http://vandreev.wordpress.com/2007/06/18/feistel-ciphers-and-des-in-haskell/ to self
08:02:37 <Vorpal> <elliott> does anyone here have experience with OpenCL? :P <-- a tiny bit. I installed the SDK for using it with AMD cards. And I read the docs.
08:02:54 <Vorpal> but I haven't got around to using it yet
08:02:57 <elliott> Vorpal: good. aid me. aid me.
08:03:04 <Vorpal> because I couldn't think of a useful project
08:03:09 <Vorpal> elliott, the spec iirc
08:03:14 <elliott> - the khronos reference is really deep hierarchy-wise and basically unordered so is useless
08:03:24 <elliott> - the spec is way too detailed and low-level and asdflghj'
08:03:37 <elliott> but some of the nvidia SDK examples are useful
08:03:48 <elliott> they all use non-free-licensed helper functions that you get to replace
08:03:52 <Vorpal> elliott, whatever it was, it was a bit like the C99 spec in how it was written
08:04:02 <Vorpal> not a tutorial by any measure
08:04:25 <elliott> i have the basics down and it's about two hundred lines of C
08:04:39 <elliott> so I basically only have one real question left, an architectural one :/
08:05:25 <Vorpal> elliott, anyway this might be useful: http://developer.amd.com/zones/openclzone/pages/default.aspx (perhaps)
08:06:40 <elliott> Vorpal: what I'm writing is a DES cracker, for the hell of it. so, I know each thread is basically going to repeatedly DES on "the next input", check if it's right, and if it's not, continue. but if it _is_ right, I want to know how I should handle the output. (the way I'm cracking means that there can be _multiple_ successful crackings.) I could simply have a fixed-size output buffer and then stop when it's full or the iterations grow too many,
08:06:40 <elliott> and then collect it all on the CPU thread, output the successful crackings, and repeat
08:06:57 <elliott> it feels like I want an instruction "STOP WHAT YOU'RE DOING, WAKE UP THE CPU THREAD, AND GIVE IT THIS DATA" :P
08:07:49 <Vorpal> elliott, hm, sorry, I don't know best way to notify the CPU-run program from a GPU thread
08:08:01 <Vorpal> surely there must be a way though
08:08:27 <elliott> I suspect you can't, without massive overhead; the poclbm bitcoin cracker -- which yes, ha ha, libertarians, but it's a program of a very similar structure, so -- seems to take that output buffer solution
08:09:41 <elliott> anyway, I ought to figure out how to actually implement DES. especially on an architecture this unconventional.
08:09:44 <Vorpal> elliott, it was made by engineers, did you expect a beautiful solution? XD
08:10:09 <elliott> I expect something focused on performance at all costs; this doesn't seem performant, but then I have no intuition as to how GPUs work
08:10:09 -!- ais523 has joined.
08:10:28 <elliott> But I'm really likely to just write a high-level Haskell API using OpenCL after this and then never write an OpenCL C program again
08:10:34 <elliott> And speak of the devil, here's ais523
08:10:46 <Vorpal> would he know about GPU programming?
08:11:08 <elliott> Vorpal: http://esolangs.org/wiki/Checkout
08:11:14 <elliott> At least fifty tl;drs worth about it.
08:12:04 <Vorpal> heh, interesting language
08:12:23 <ais523> elliott: were you speaking of me?
08:12:39 <elliott> ais523: Yep, saying I'd wait for you before I continued writing my GPGPU program
08:13:52 <elliott> <elliott> Vorpal: what I'm writing is a DES cracker, for the hell of it. so, I know each thread is basically going to repeatedly DES on "the next input", check if it's right, and if it's not, continue. but if it _is_ right, I want to know how I should handle the output. (the way I'm cracking means that there can be _multiple_ successful crackings.) I could simply have a fixed-size output buffer and then stop when it's full or the iterations grow
08:13:53 <elliott> <elliott> and then collect it all on the CPU thread, output the successful crackings, and repeat
08:13:54 <elliott> <elliott> it feels like I want an instruction "STOP WHAT YOU'RE DOING, WAKE UP THE CPU THREAD, AND GIVE IT THIS DATA" :P
08:14:00 <Vorpal> elliott, you could do GPGPU calculations with shaders too. I think GPU support of hugin's panorama stitcher nona is done by shaders rather than OpenCL. Not sure why.
08:14:13 <elliott> Because OpenCL/CUDA are much newer than shaders.
08:14:23 <ais523> elliott: each thread should have a block of memory it writes to
08:14:44 <ais523> then periodically, you stop all the threads temporarily to do an en-masse transfer of that memory to somewhere the CPU can read
08:14:56 <elliott> Right, so what I said then
08:15:04 <ais523> actually, you need a really really recent graphics card (as in, last few months) to be able to read the memory before the computation's finished altogether
08:15:09 <elliott> That's gross in tons of ways though :/
08:15:10 <Vorpal> ais523, why no way to send a signal back to the CPU?
08:15:14 <ais523> so you might want to just repeatedly invoke the computation
08:15:23 <ais523> on a subset of the search space
08:15:25 <elliott> ais523: Yeah, that's what I said
08:15:32 <elliott> ais523: It makes some things a lot less fun though
08:15:40 <elliott> I can't offer a semi-realtime count of cracking speed for instance :P
08:15:46 <ais523> Vorpal: because of massive threading, basically
08:16:48 <elliott> ais523: So here's another question: I was thinking each thread would basically get its own chunk of the keyspace, and then try repeatedly to fill out its output buffer, trying new keys each time. But looking at several SDK examples, I have a feeling that it'd be better to make it be one thread : one attempted key, and just have millions of them, letting the GPU scheduler do the equivalent of my loop.
08:16:55 <elliott> Is this a good way to go about things?
08:17:25 <ais523> elliott: the number of threads you can have the GPU scheduler deal with is relatively large, but finite
08:17:43 <elliott> ais523: Yep, but my computational workload is also finite, because of the above architecture
08:17:44 <ais523> getting the scheduler to do as much scheduling as possible is generally more efficient because it can do tricks like pipeline memory accesses
08:17:53 <ais523> it's finite as in about a million or so, maybe a bit less
08:17:57 <ais523> and I have a feeling that might be too small
08:18:04 <elliott> Right; so ten times the threads > a loop...
08:18:07 <elliott> ais523: More than a million
08:18:18 <elliott> This SDK example uses 1277944
08:18:37 <elliott> Nearest multiple of two hundred and fifty-six to that
08:19:02 <elliott> ais523: I guess I should just max out the number of threads the GPU can deal with, and then have them repeat their workload until my desired computation workload is filled?
08:19:07 <elliott> As in, no advantage to having _less_ threads
08:21:10 <elliott> ais523: And there's no way to tell the GPU "kill every thread", right, just "kill this thread" (return)?
08:21:32 <ais523> you don't kill a thread at all, threads exit when they reach the end of the code they have
08:21:41 <elliott> ais523: "return" in a __kernel kills a thread :)
08:22:02 -!- Patashu has joined.
08:22:16 <elliott> I'm basically just grounding my entire thinking in terms of array languages like J.
08:22:38 <elliott> Plus the sort of nice Haskell array-handling pipelines that end up being fused away because they're just compositions.
08:22:45 <ais523> I ground my thinking in GPUs
08:22:58 <ais523> they're a paradigm of their own, but not one that's impossible to learn
08:23:06 <elliott> ais523: That's the best way to do it, but unfortunately I don't know how GPUs work, other than being vector CPUs with shitloads of cores
08:23:14 <elliott> So I have to work with bad metaphors until it clicks
08:24:12 <elliott> OK, so TODO: Learn how to actually code DES, figure out how to divide the keyspace nicely, find a nice compute workload for a single "run"
08:25:09 <elliott> ais523: I take it GPUs are lousy at matching regular expressions?
08:25:31 <ais523> it depends on how you interpret them
08:25:49 <ais523> a DFA that was small enough to fit into block memory might work well
08:25:57 <elliott> Well, the input string is exactly ten characters
08:26:12 <ais523> (i.e. no pipeline stalls in doing a jump-table-equivalent)
08:26:20 <elliott> So hell, I could compile it down to 2560 bytes of lookup table
08:26:28 <elliott> That's too big to be local data though, right?
08:27:28 <elliott> Oh wait, no, of course a lookup table doesn't work
08:27:51 <elliott> Although, hmm; I could do that simple "none of the ten characters are _definitely_ invalid" check, add it to the output, and have the CPU filter those out
08:28:10 <elliott> ais523: But it might be better just to do it all on the GPU
08:28:25 <elliott> I guess most regexps trying to match only ten characters will fit into block memory :)
08:28:34 <elliott> And if that's not good enough you can always grep the rest
08:28:44 <elliott> Is there any way to find out exactly how much block memory my GPU does, btw?
08:28:48 <ais523> I'd suggest only doing simple checks on the GPU
08:28:54 <ais523> and there should be some API function to query that
08:29:08 <ais523> I know CUDA has one, although I've forgotten what it's called
08:29:18 <elliott> ais523: Well, a simple regexp is pretty simple, but I don't know what counts as simple for GPUs.
08:29:29 <ais523> (the amount of block memory /per block/ is obviously what you're interested in; it's also called shared memory sometimes)
08:29:39 <ais523> you normally get a few kilobytes of it per block
08:30:11 <elliott> My GPU is not all that good; it's integrated, after all.
08:30:28 <elliott> Hmm, if 2560 isn't good enough, I could always do a kind of bloom filter thing
08:30:40 <elliott> ais523: BTW, is CUDA's C API this insanely verbose???
08:31:07 <ais523> elliott: I'm used to Java, so it didn't look /that/ out of place
08:31:12 <elliott> Also my program keeps failing just because I only have like a gig of memory free. :/
08:31:27 <ais523> you might want to make it a bit more memory-efficient
08:31:27 <elliott> Even though it only deals with about a hundred megs of data on both CPU and GPU side???
08:31:36 <ais523> GPUs definitely don't have a gig of memory to spare
08:31:38 <elliott> It's perfectly memory-efficient, it's just a trivial test program I wrote
08:31:49 <elliott> ais523: Well yeah, but it complained about lack of host memory before
08:31:57 <elliott> I guess my GPU is probably just using more than half its RAM though :)
08:32:03 <elliott> I only have two hundred and fifty megabytes of it, which is ugh
08:32:12 <elliott> Thankfully DES cracking is a rather constant space thing
08:32:16 <elliott> That doesn't count towards GPU ram, does it?
08:32:19 <elliott> Because they're like registers
08:32:44 <ais523> you have thread memory, block memory, and global memory, they're all separate memory spaces
08:32:51 <ais523> global memory is the only sort of memory you can have pointers into
08:32:58 <ais523> although you can still index arrays in thread or block memory
08:33:07 <ais523> and so you can fake pointers like that if you really want to
08:33:11 <elliott> What's the two-five-six figure; combined, or global?
08:34:18 <ais523> that sounds plausible for the amount of block memory in a block
08:34:31 <ais523> the names the API uses are often confusing, you often have to figure out what they are just from their sizes
08:34:51 <elliott> oh, I'm not quoting the API, I'm quoting what my GPU claims to the rest of the computer
08:35:23 <elliott> That's two-five-six megabytes, btw
08:35:47 <ais523> oh, /megabytes/? probably global memory, then
08:35:58 <ais523> nothing else would be that big
08:36:27 <elliott> ais523: But, umm, you said I had a few kilobytes per thread
08:36:38 <ais523> global memory has nothing to do with shared memory
08:36:43 <elliott> Is that swapped out into global memory or something? Because I don't have two gigs of RAM on my GPU
08:36:47 <ais523> shared memory is shared by a block of threads, they all read/write into it
08:36:50 <elliott> (Going by a million threads)
08:36:52 <ais523> and no, but only finitely many threads run at once
08:37:03 <elliott> Yeah, so where does it go when they're not running :P
08:37:20 <ais523> normally, it'll switch between around 100 threads until they're all finished, then do another block of 100 or so, etc
08:37:27 <ais523> so it doesn't go anywhere because the threads have already exited
08:37:41 <ais523> you can't assume all the threads as a whole are immune to starvation, they almost certainly won't be
08:37:51 <ais523> threads /within a block/, you can assume are immune to starvation and all that
08:37:58 <elliott> Do I actually have to account for threads just losing their ram
08:37:59 <ais523> elliott: the chance that a thread won't run at all until it's the last thread remaining
08:38:12 <elliott> Why would that matter, this is embarrassingly parallel
08:38:17 <elliott> They don't need to talk at all :P
08:38:18 <ais523> it doesn't, in this case
08:38:25 <ais523> but it explains where the RAM Goes
08:38:35 <elliott> BTW, with my output array, I want one index per thread, right? Because otherwise they might just step on each other's toes
08:38:46 <ais523> it runs a group of threads until they've all finished and so don't need any more RAM, then the next group, then the next, etc
08:38:51 <elliott> And it's easier to have to allocate like two hundred megs on the host than to communicate between threads to resolve that
08:38:59 <ais523> yep, one index per thread is an incredibly common trick on a GPU
08:39:34 <elliott> ais523: hmm, that might not quite work, since the successful output is like a short string
08:39:42 <ais523> 256MB is a little low even for that, but that memory doesn't really matter
08:39:46 <Vorpal> ais523, which is different from video ram iirc?
08:39:48 <elliott> eight (seven-bit) characters
08:40:02 <elliott> so that's eight times a million threads, say
08:40:03 <ais523> Vorpal: it has nothing to do with video RAM
08:40:05 <elliott> oh, that's just eight megabytes
08:40:13 <elliott> why don't I have an intuition for this kind of thing?
08:40:20 <Vorpal> ais523, what is video ram then?
08:40:25 <ais523> in graphics programming, a hardware buffer is in GPU memory, a software buffer is in video RAM
08:40:34 <ais523> err, maybe not, actually
08:40:39 <ais523> a hardware buffer might be in GPU memory or video RAM
08:40:46 <ais523> and a software buffer is just in general-purpose RAM
08:41:02 <elliott> ais523: I don't suppose there's like a common source of cryptographic algorithms for GPUs
08:41:07 <Vorpal> my GPU has 1 GB RAM of whatever is on the PCIE-card
08:41:08 <elliott> DES instructions in the hardware? No?
08:41:11 -!- FireFly has joined.
08:41:14 <elliott> I might actually have to learn something.
08:41:22 <ais523> it wouldn't surprise me if video RAM was memory-mapped into GPU global memory, actually; I don't know how the CPU and GPU actually communicate
08:42:07 <Vorpal> ais523, I suspect /proc/mtrr could tell you something about that. If you just knew which section was video ram
08:42:17 <Vorpal> but yeah I think at least some of it is mapped into CPU address space
08:42:25 <Vorpal> pretty sure I read that somewhere
08:42:34 <CakeProphet> all devices should communicate via telnet protocol
08:42:49 <Vorpal> reg00: base=0x000000000 ( 0MB), size=16384MB, count=1: write-back
08:42:49 <Vorpal> reg01: base=0x400000000 (16384MB), size= 1024MB, count=1: write-back
08:42:49 <Vorpal> reg03: base=0x0e0000000 ( 3584MB), size= 512MB, count=1: uncachable
08:42:49 <Vorpal> reg04: base=0x42f800000 (17144MB), size= 8MB, count=1: uncachable
08:42:50 <Vorpal> reg05: base=0x430000000 (17152MB), size= 256MB, count=1: uncachable
08:42:56 <Vorpal> can't really make any sense of that
08:44:42 <ais523> I don't know what /proc/mtrr is for
08:46:08 <Deewiant> Vorpal: You might want to fix that, I had terrible random performance problems when my MTRR setup was messed up
08:47:33 <Deewiant> It says some things are both uncachable and write-back
08:48:46 <elliott> Unless I'm seriously misinterpreting that
08:50:32 <Deewiant> Oh, and the other uncachable areas too, actually
08:50:57 <Deewiant> reg00: base=0x000000000 ( 0MB), size=16384MB, count=1: write-back
08:51:08 <elliott> That's not uncachable, the line uncachable isn't there
08:52:21 <Deewiant> Maybe it's supposed to work like that, dunno
08:52:32 <Deewiant> All I know is I had major issues while I had overlap
08:53:56 <Deewiant> Wikipedia at least says that overlap is fine so I guess that's fine
08:57:36 -!- azaq23 has joined.
08:57:40 <Vorpal> Deewiant, I think there is an order of precedence.
08:57:49 <Vorpal> at least from what I remember
08:58:14 <Vorpal> Deewiant, oh and performance is fine. So are you suggesting I could get even better performance by messing with them?
08:58:26 <elliott> Does anyone know a public domain reference implementation of DES; I am way too tired for this reading shit right now
08:58:47 <Deewiant> I just thought it might be a problem since it was a really bad problem for me
08:59:01 <Deewiant> But it appears it shouldn't be a problem in general
09:01:30 <elliott> "can anyone give me a working c program for DES algorithm(64/56 bit key)....
09:01:30 <elliott> I want to write the program but cant.
09:01:30 <elliott> I got many programs from google but no one is running.
09:01:31 <elliott> Please send me the program............."
09:01:34 <elliott> Then: "dont u guys have any interest in DES..........."
09:01:43 <elliott> Afraid not, dear friend; none of this cruel internet has any interest in DES
09:02:10 <elliott> ais523: function calls are inlined on a GPU, right?
09:02:31 <ais523> elliott: yes, they don't have much of a call stack to speak of
09:02:50 <elliott> Right; just checking that I'm not losing anything by using functions instead of macros here
09:03:14 <ais523> it's reasonably common to unroll loops, too (GPU programming languages tend to have pragmas for that nowadays; hand-unrolling nearly always beats compiler-unrolling because the compilers are bad at guessing how many iterations to unroll)
09:04:51 <elliott> DES is gross, why can't these encryption algorithms be pretty
09:12:31 <ais523> I suppose I shouldn't be helping you make a password cracker
09:12:37 <ais523> even if it is for practice
09:12:57 <Patashu> What even uses DES anymore
09:12:59 <ais523> those things are probably illegal nowadays
09:13:02 <ais523> or at least, a pending law
09:15:06 <elliott> ais523: I'm not cracking passwords
09:15:35 <ais523> even so, IIRC there's a new law outlawing programs which have an obvious illegal purpose
09:15:40 <ais523> and I think that includes password crackers
09:15:45 <ais523> (it's quite a stupid one, really...)
09:15:45 <elliott> It's not a password cracker
09:15:56 <ais523> well, it's reversing crypt(3), right?
09:16:22 <ais523> what is it doing, then?
09:16:25 <elliott> It's processing crypt() output and checking it for certain conditions.
09:16:33 <elliott> Certain conditions that would be useless for cracking a pre-given hash.
09:16:35 <elliott> The only thing you could use to crack DES passwords using this program would be to rip out the crypt() implementation and write your own cracker.
09:16:42 <elliott> Other things that include a crypt implementation: libc.
09:16:58 <ais523> so what is the intended purpose? or is that secret?
09:17:05 <ais523> (as in, what do you plan to use it for?)
09:17:27 <elliott> I don't plan to use it at all once it works, but that would be telling. :p It's not any big secret or anything, it's just a silly little program.
09:17:36 <ais523> also, I just did sudo cat /etc/shadow, it seems that the only loginnable account on this computer (mine) is using a salt starting $6$, so definitely not DES-based
09:17:44 <ais523> I don't recognise that particular algo at all, in fact
09:17:58 <elliott> But yeah, the only way you could use this to track passwords would be... to enlarge a bunch of the arrays, fill out the GPU-check tables in a really weird manner, remove the CPU checks... yeah, it'd basically be equivalent to rewriting everything but crypt().
09:18:21 <elliott> hmm, I've never heard of $six$
09:19:25 <elliott> So you should be happy about that
09:20:51 <ais523> does SHA2 describe a particular hash algo? I thought it was a family
09:21:24 <elliott> ais523: Well, it's one of the SHA2s, but all of them are pretty good :P
09:26:41 <elliott> `addquote <elliott> help me i am so alone :( <monqy> new computer good enough to simulate real parents
09:26:46 <HackEgo> 637) <elliott> help me i am so alone :( <monqy> new computer good enough to simulate real parents
09:27:06 <ais523> elliott: what do you think about the Wikileaks/Guardian situation?
09:27:23 <elliott> ais523: I forgot to pay attention; brief summary?
09:27:32 <ais523> summary: Wikileaks send an unredacted version of the diplomatic cables to a Guardian journalist via encrypted archive
09:27:48 <ais523> telling them the password in a relatively secure manner (at least, it wasn't intercepted)
09:27:54 <elliott> (The only thing I remembered reading was a funny quote about someone failing to use GPG and Assange helping them)
09:27:58 <ais523> the encrypted archive itself leaks when it's accidentally mirrored
09:28:10 <ais523> and the password leaks when the journalist uses it as a title for a book chapter
09:28:14 <ais523> so the entire information is out there now
09:28:22 <ais523> elliott: it's the same person, as it happens
09:28:37 <elliott> ais523: haha, that _can't_ have been unintentional
09:28:54 <ais523> Wikileaks has since deliberately published an unencrypted version of the same archive on the basis that the information's out there, and Australia responded with an arrest warrant
09:29:05 <elliott> BTW, were the details of that "insurance" file Wikileaks released ages ago ever revealed?
09:29:17 <elliott> It was with another big leak, just an encrypted blob that people torrented about on the assumption that it /must/ be something important
09:29:18 <ais523> elliott: it seems that the journalist wasn't too tech-savvy and thought that the password had expired
09:29:34 <ais523> and the insurance file still hasn't been decrypted; it doesn't have the same password, people have checked that
09:29:53 <elliott> ais523: on the one hand, I can believe the incompetence part; on the other hand, how stupid do you have to be to take a "risk" like that?
09:30:15 <ais523> even I can excuse a journalist for not realising that encrypted archives don't have expiring passwords
09:30:22 <ais523> because it's only obvious if you understand the tech
09:30:33 <elliott> yep, but I'd call naming a chapter after an expired password pretty irresponsible, too
09:30:36 <ais523> but Wikileaks should possibly have noticed that, and used some other method of communication, or at least a warning
09:31:05 <ais523> it's the sort of thing I'd expect a journalist to do, it's "good journalism" in the sense that it draws attention and makes for a good story
09:31:18 <elliott> anyway, I'm not sure what my opinions on it are, other than that it's amusing
09:31:53 <elliott> I doubt the availability of the unredacted files will cause much harm; there was an awful lot of hyperbole about it when the cables were first released, but I don't recall anything ever actually happening so it sounds like FUD To me
09:33:04 <ais523> the best advice I've seen on slashdot is to make passwords long, random, and boring, so that they don't make for interesting book titles
09:33:55 <elliott> the new book from a Wikileaks insider and Guardian journalist: 95UaipciJ6gIBpJvNYuSu
09:34:03 <elliott> (I actually got that from /dev/urandom for authenticity)
09:34:19 <Patashu> Is that base 58 or base 64
09:34:49 <Patashu> I find it amusing that the original unix crypt was based on the enigma machine
09:34:52 <Patashu> Like, wow, it was that old
09:34:58 <Patashu> ais: youtube I think uses it
09:34:59 <elliott> That's not the crypt function
09:35:01 <ais523> wouldn't 62 make more sense?
09:35:04 <elliott> that has never existed ever
09:35:06 <CakeProphet> wow IMAP sequence points are a terrible idea.
09:35:13 <ais523> elliott: I've used perl for it on occasion
09:35:32 <Patashu> it's 58 because you take out o O 0 i I l
09:35:32 <ais523> it's a one-liner there, it has crypt(3) as a builtin function for reasons I don't fully understand
09:35:38 <Patashu> because they look like each other depending on the typography
09:35:44 <elliott> ais523: the crypt tool is unrelated.
09:36:08 <elliott> it's a ridiculously insecure text encryption that was replaced with a caesar cypher in many unixes because of export laws
09:36:17 <elliott> so basically linux has never had it ever because it's bloody useless
09:36:23 <elliott> and broken in the forties, by definition
09:36:28 <elliott> or earlier, if a caesar cypher
09:36:33 <Patashu> :cryptography export laws:
09:36:43 <Patashu> caesar cyphers were broken around the time of jesus
09:36:51 <elliott> wouldn't it be really cool to be alive in the times when the caesar cypher was actually being used to send war-critical messages
09:37:04 <elliott> TURNS OUT I BROKE THE INTERCEPTED MESSAGE IN FIVE MINUTES
09:37:16 <elliott> [rolls in money, accolades]
09:37:44 <ais523> back then, it wasn't common knowledge that codes were crackable at all
09:37:44 <Patashu> They should have used a one time pad
09:37:49 <ais523> so you'd first have to have thought of it
09:38:05 <ais523> Patashu: for a hundreds-of-megabytes document? pretty much the only way to do that would be to allow it to be downloaded somehow
09:38:05 <elliott> ais523: well, when everyone is /that/ stupid...
09:38:09 <zzo38> If you know (or can figure out) that it is a caesar cipher, it would be very easy to decode by trying a few keys, there is not much to try and you do not have to decode the entire message to know that it is wrong
09:38:12 <elliott> (yeah, yeah, I know, product of our society)
09:38:13 <ais523> and then it's too likely that both the OTP and the original will be intercepted
09:38:28 <elliott> ais523: hundreds of megabytes in caesar's time :ok:
09:38:38 <elliott> :ais523madeaconversationalerror:
09:38:43 <ais523> elliott: I interpreted a different context to the one you did
09:38:53 <Patashu> He's right to miss the context, it was ambiguous
09:38:54 <ais523> I assumed Patashu was talking about the Guardian/Wikileaks situation not the military situation
09:39:01 <elliott> :smileydepictingrespondingtoallmessagesintermsofsmilies:
09:39:04 <ais523> and in fact, still think that was the context, unless told otherwise
09:39:29 <monqy> i cant think of anyway to use :help: :help:
09:40:00 <monqy> :how could i make such a stupid mistake:
09:40:25 <CakeProphet> ...why are we using posix-style named character classes?
09:40:32 <monqy> :also, when i said "i mean" i meant :i mean::
09:40:40 <ais523> surely the smiley should be :hlep:?
09:40:41 <elliott> :im going to have to draw all of these:
09:40:47 <CakeProphet> okay I'm pretty sure that's not posix compliant.
09:41:00 * ais523 notices how difficult it is to make an intentional typo once your fingers are used to typing words at a time rather than letters at a time
09:41:10 <elliott> :smiley depicting infinite tower of smilies; inside, the image of death itself:
09:41:23 <monqy> story of my life, ais523
09:41:58 <ais523> CakeProphet: normally used to delimit smileys on webforums
09:42:01 <elliott> :iiam: oh wait that one's real
09:42:08 <ais523> e.g. BlogNomic which uses :FOR: for a FOR-vote smiley
09:42:19 <ais523> those things tend to accumulate stupidly large amounts of smileys
09:42:22 <Patashu> are nomics interesting to play?
09:42:28 <ais523> elliott: no idea, I don't know of that one
09:42:35 <elliott> ais523: "it is a mystery" ghost
09:42:35 <ais523> Patashu: they can be; normally they are sometimes and aren't sometimes
09:42:39 <elliott> http://www.itisamystery.com/itisamystery.gif
09:42:55 <ais523> wait, does that website exist just to serve one image?
09:42:57 <elliott> Patashu: not right now, they aren't
09:43:12 <monqy> http://www.skype-emoticons.com/images/emoticon-00169-dance.gif http://www.skype-emoticons.com/images/emoticon-00119-puke.gif
09:43:56 <elliott> "Photo books on your Mac. Just add summer." good god apple, I would unsubscribe from your emails if they weren't so hilarious
09:44:10 <elliott> who the hell makes an actual printed book with maps of their travels abroad
09:44:12 <ais523> in unrelated news, there are allegations going around of Apple impersonating police
09:44:15 <elliott> how rich is the average apple customer
09:44:18 <elliott> how rich does apple think the average apple customer is
09:44:24 <ais523> although there are a huge number of fishy things about the story
09:44:36 <ais523> so most people involved are smelling a rat even if they're not sure what color the rat is
09:44:51 <elliott> whatever colour the rat is i will love and care for it all the same
09:45:02 <elliott> do you normally use "color"?
09:45:56 <ais523> I'm about 50/50 on that word
09:46:10 <ais523> and strangely, it doesn't seem to have much correlation with whether I'm programming
09:46:22 <ais523> although it goes up to 100% for "color" when programming if I actually think about the spelling
09:46:24 <elliott> i hate using apis that use different spelling conventions to m
09:46:25 <ais523> and likewise, "colour" when not
09:46:33 <elliott> i was going to name my variable
09:46:35 <ais523> elliott: use MySql, then, it has both ANALYSE and ANALYZE!
09:46:57 <elliott> ais523: hmm, there's that language whose name escapes me where foo_bar, foobar and fooBar are all the same identifier
09:46:57 <monqy> type Colour = Color -- witty comment here
09:47:00 <elliott> clearly it just needs generalising...
09:47:12 <elliott> in fact, how about we put a whole thesaurus in there?
09:47:38 <ais523> elliott: eso or non-eso?
09:47:46 <ais523> it'd be more interesting if foobar was different from the other two
09:48:04 <ais523> as in, the language conceptually had multiword identifiers, and various ways to notate them in ASCII
09:48:34 <ais523> in Algol 68, foo_bar is the same as foo bar (the underscore is an unkeywordiser, and neither foo nor bar are keywords)
09:48:37 <elliott> well, it was case insensitive :P
09:48:49 <ais523> and is a variable not a keyword
09:49:08 <ais523> (.foo.bar would be a two-word keyword, which would then cause a syntax error as foo bar isn't a keyword)
09:49:50 <elliott> ok, so the keyspace is fifty-six bits.
09:49:55 <elliott> now to divide that up reasonably.
09:50:19 <ais523> elliott: hmm, are you doing some iterated-DES sort of HashCash?
09:50:44 <elliott> nope; that would be some hashcash
09:50:53 <elliott> Patashu: no, hashcash is something that just about everyone agrees is a pretty good idea
09:51:02 <elliott> it's similar in implementation, though
09:51:03 <elliott> http://en.wikipedia.org/wiki/Hashcash
09:51:14 <ais523> Patashu: not really; it's an anti-spam scheme that works by forcing an email sender to do some provable pointless calculations before sending
09:51:27 <elliott> hmm, so DES actually works on seven characters
09:51:33 <ais523> the idea being that if you send one email, it's only going to tie up your CPU for two seconds or so and you won't care
09:51:36 <elliott> I should probably make it work on eight characters with the ignored bit still there
09:51:42 <elliott> because char8 is a type that exists
09:51:43 <ais523> but if you send a million, you're going to need a giant server farm which is very expensive
09:51:51 <elliott> and because the implementations probably assume that
09:52:06 <Patashu> It seems unfair against embedded systems
09:52:23 <elliott> embedded systems don't send email
09:52:48 <elliott> hmm, and the salt is one hundred and twenty eight bits.
09:52:53 <Patashu> my microwave emails me when it's done
09:52:56 <elliott> crypt() literally takes a salt larger than the password.
09:53:08 <elliott> Patashu: I suspect it has a pretty decent processor, then
09:53:20 <Patashu> (it doesn't really but it should)
09:53:36 <Patashu> WIll be the next big innovation
09:54:08 <elliott> email is a rather bad protocol for that
09:54:11 <elliott> XMPP or something would be better
09:55:07 -!- elliott has quit (Remote host closed the connection).
09:55:08 <zzo38> Use the Message Send Protocol.
09:55:23 <Patashu> Anyway, hashcash is like bitcoin
09:55:29 <Patashu> except everyone who wants to use it has to hash instead of just miners
09:55:31 -!- elliott has joined.
09:55:44 <elliott> ais523: btw, the nice thing about OpenCL (imo) is that you don't need any sort of SDK to use it
09:56:02 <ais523> you have to compile it somehow
09:56:12 <elliott> ais523: the header files are portable, few in number, and available from Khronos; and the only other thing you need is /usr/lib/libOpenCL.so, which ships with my graphics card drivers and I'm sure yours too
09:56:28 <ais523> oh, is it embedded into C in some sort of crazy fashion?
09:56:38 <elliott> oh, you compile the actual code at runtime
09:56:43 <ais523> or is libOpenCL.so the compiler?
09:56:56 <elliott> but the compiler's API is standardised, so
09:57:05 <elliott> I think there's something to precompile, but that probably involves writing your own API-using program to do it
09:57:18 <elliott> Maybe there's tools for it in the SDKs, I don't know, I'm fine with this portable stuff
09:58:24 <ais523> something I'm wondering about: suppose you use a POSIX-extended printf call to print just the second variable argument to printf
09:58:43 <ais523> as in printf("%2$d\n", 4, 5);
09:59:04 <ais523> does that actually work? I'm having trouble figuring out how it would figure out where the second arg was on the stack without knowing the type of the first
09:59:33 <Patashu> !c printf("%2$d\n", 4, 5);
09:59:57 <Patashu> !c printf("%2$d\n", 4.0, 5);
09:59:57 <Deewiant> !c printf("%2$d\n", (long double)4.2, 5);
09:59:58 <elliott> !c printf("%2$d\n", 'c', 5);
10:00:07 <ais523> Deewiant: heh, I had the same idea as you
10:00:10 <elliott> !c printf("%2$d\n", (long double)4.2, 5);
10:00:15 <elliott> !c printf("%2$d\n", (long double)4.2, 5);
10:00:20 <ais523> elliott: chars are widened to ints in a ... argument
10:00:27 <elliott> ais523: i realised that right a i sent it
10:01:00 <ais523> <man printf> There may be no gaps in the numbers of arguments specified using '$'; for example, if arguments 1 and 3 are specified, argument 2 must also be specified somewhere in the format string.
10:01:06 <elliott> "A 12-bit salt is used to perturb the encryption algorithm, so standard DES implementations can't be used to implement crypt()."
10:01:24 <ais523> wait, the salt alters the /encryption algorithm/, rather than the /input/?
10:01:39 <ais523> whoever invented crypt probably doesn't understand hashing
10:01:46 <elliott> hmm, DES' block size is 64 bits
10:01:53 <elliott> does that mean that a DES output is 64 bits, if you only have one block?
10:02:24 <ais523> either that or they understand it well enough to know how to perturb DES without making it less secure
10:03:45 <elliott> ais523: hmm, (assume CUDA since I guess it's comparable) how would I pass in, say, two kilobytes of data to a kernel function?
10:03:58 <elliott> note: the data is constant for all threads but should be quick to access
10:04:39 <ais523> two possibilities; one is to place it in global memory and get each block of threads to copy it into shared memory as the first thing they do, and read it from there
10:04:49 <ais523> and the other is to place it in texture memory and hope it ends up in the texture cache
10:05:03 <ais523> the first's more suitable for small amounts of data, the second for large amounts
10:05:04 <elliott> Couldn't I just pass a really large number of function arguments? :-)
10:05:08 <ais523> and 2K is somewhere in between
10:05:21 <elliott> It's literally just ten tables of two-five-six bytes each.
10:05:27 <ais523> I'm not entirely sure how function arguments are passed
10:05:30 <elliott> But I figure bytes are quicker to index.
10:05:48 <elliott> Hmm, I guess I have to base64 in the kernels too
10:05:54 <ais523> note that copying blocks of global to shared memory is a reasonably fast operation; it accesses global memory more efficiently than any other way of accessing it
10:06:10 <elliott> No, I could just divide it into eight bytes and do it based on that
10:06:14 <elliott> Hmm, that'd be really false-positivey
10:06:20 <ais523> typically you get the threads to cooperate on the copy
10:06:30 <elliott> ais523: cooperation sonuds like communicatino :(
10:06:37 <ais523> there's an operation for that in Checkout
10:06:40 <ais523> elliott: it's actually the opposite
10:06:51 <ais523> each thread does a fraction of the copy, in such a way that between them they do all the copy
10:07:12 <ais523> it is, but it's also standard
10:07:12 -!- lifthrasiir has quit (Quit: leaving).
10:07:18 <ais523> you get used to that sort of thing after a while
10:07:37 <elliott> ais523: I don't _want_ to get used to it :-\
10:07:38 <ais523> you won't really get a good feel for GPU programming unless you work on something a bit less embarrassingly parallel than your current problem
10:08:00 <ais523> as GPUs are designed for tasks that parallelize well but not perfectly (as that's what graphics programming is like)
10:08:01 <elliott> but that may be a good thing :P
10:08:27 <zzo38> Too bad there are no (Free-software) Checkout implementations.
10:08:29 -!- lifthras1ir has changed nick to lifthrasiir.
10:08:39 <elliott> there are non-Free-software implementations?
10:08:40 <ais523> zzo38: there are no Checkout implementations at all
10:08:57 <elliott> Too bad there are no Checkout implementations targeting badgers.
10:09:21 <ais523> if it's general enough to run even on badgers, I'm not sure if I've done something right or wrong
10:09:25 <elliott> ais523: I have half a mind to write a little library that compiles special Haskell code symbolically to OpenCL and executing that
10:09:27 <ais523> what license do horses typically use, btw?
10:09:40 <elliott> At least, I /think/ you could reduce typical zip/map/associative fold code to something pretty direct
10:10:00 <ais523> associative fold is very standard
10:10:07 <ais523> and map is so parallel it doesn't even count as a building block
10:10:11 <elliott> That kind of code tends to be idiomatic in Haskell anyway (i.e. a "pipeline" composition chain of functions with no conditionals), so I'm pretty sure it could produce good OpenCL code for good Haskell code
10:10:16 <elliott> ais523: It does in Haskell
10:10:29 <Patashu> haskell can't already compile to opencl?
10:10:37 <elliott> Also, I really want to see Checkout running on a badger now, even though that sounds terrible and illegal
10:10:41 <elliott> Patashu: that would be insane
10:10:50 <ais523> there's a slideshow by NVidia somewhere where they did lots and lots of optimisations on an associative fold and watched it get faster and faster
10:10:51 <elliott> I'm talking about what amounts to a symbolic EDSL
10:11:08 <olsner> an EDSL for running on badgers?
10:11:24 <elliott> ais523: I wonder what programming would be like if the (GP)GPU was invented before the CPU?
10:11:41 <elliott> I see no reason why it couldn't be the "main" processor, it'd just be bizarro-world from ours
10:11:52 <ais523> elliott: it probably wouldn't have operating systems
10:11:58 <ais523> not software operating systems, at least
10:12:01 <elliott> why not? CPUs didn't at first, either
10:12:04 <ais523> instead, they'd be built into the hardware
10:12:15 <elliott> but then they grew the hardware support for OSes to be written
10:12:34 <elliott> ais523: hmm, do I really have to iterate through a megabyte just to see if any of my kernels managed to produce a hit :-|
10:12:39 <elliott> (an array of bools, one per kernel)
10:12:46 <ais523> I think the inclination would be "make the GPU better at scheduling" rather than "allow the GPU to have customizable scheduling"
10:13:00 <ais523> perhaps the CPU would be invented so that it could do OSy tasks
10:13:13 <ais523> btw, GPUs tend to be very bad at integers, and especially bitwise operations
10:13:19 <ais523> they're designed for floating-point
10:13:28 <elliott> hmm, well this definitely isn't an fp operation
10:13:30 <elliott> I can avoid bitwise, though
10:13:58 <ais523> can you (easily) use doubles that always have integer values?
10:14:11 <ais523> I think they can represent the entire 32-bit range exactly
10:14:28 <elliott> ais523: sure; would that really be faster? I mean, DES is pretty much bitwise twiddling all the way
10:14:30 <ais523> (the whole float bad, int good mentality of CPU programming is sort-of upside-down on GPUs)
10:14:33 <Patashu> the entire 32 bit range? no way
10:14:38 <Patashu> maybe the entire 16 bit range
10:14:46 <ais523> Patashu: double = 64 bits, isn't it?
10:15:13 <elliott> JS uses doubles for all integers so I would be astonished if they only managed sixteen bits.
10:15:15 <ais523> and it doesn't surprise me at all that in the 64 bits' worth of doubles, there's the entire 32-bit integer range
10:15:18 <elliott> "An IEEE754 8-byte double can represent any 4-byte integer, simply because it has 53-odd bits available for precision (and the 4-byte integer only needs 32).
10:15:22 <ais523> and shouldn't surprise you either
10:15:51 <elliott> ais523: Anyway, I realise I'm not exactly exploiting the GPU's huge strengths, but it has many more cores than my CPU, so it'll still thrash it massively
10:16:08 <ais523> I think it can probably do up to 54-bit signed ints; the sign bit is separate, and for any int value, there'll be some exponent value that makes that mantissa value multiply by 1
10:17:00 <ais523> btw, I've been told that the term GPGPU technically only applies to general-purpose programming done with graphics primitives, like pixel shaders
10:17:14 <ais523> and doing it with primitives more suitable for the task is called something else, which I can't remember
10:17:29 <ais523> but I don't really care
10:18:51 <elliott> hmm, oh, a gap in my rudimentary opencl knowledge
10:19:00 <zzo38> How would you implement the NES PPU + NES APU on the GPU?
10:19:14 <elliott> ais523: how do I vary an argument to each kernel in CUDA? :-P
10:19:29 <elliott> (yeah, I'm using OpenCL, but similar enough, right?)
10:19:37 <elliott> as in, all I've been doing is setting constant arguments and then running a bunch of threads that use their global ID
10:19:39 <cheater> mantissa values multiplying by 1? base-1 system?
10:19:41 <ais523> elliott: the call looks something like kernel_name(args)<<<threads,blocks>>>
10:19:55 <elliott> first_key needs offsetting by the global id
10:20:18 <ais523> cheater: no, mantissa is scaled by 2^n, you just change the value of n to undo the first scaling of the mantissa to lie in the range 1..2
10:20:35 <ais523> I might have that threads/blocks backwards
10:21:00 <elliott> ais523: I take it GPU buffers generally aren't 0-initialised...
10:21:01 <cheater> are there cryptographic functions which allow to decrypt parts of the data depending what key is supplied?
10:21:14 <ais523> cheater: encrypt them separately, concatenate?
10:21:19 <cheater> different parts which are not mutually exclusive
10:21:29 <ais523> elliott: no, but you can 0-initialize them manually easily enough
10:21:31 <cheater> i realize you can do this but it is not efficient
10:21:43 <ais523> someone actually found a security hole in WebGL based on that
10:21:57 <ais523> that you could grab parts of people's video memory, and thus what they were viewing on the screen, by exploiting that sort of thing
10:22:03 <ais523> and send it back to the website you were viewing
10:22:10 <elliott> ais523: I want to reuse my allocated buffers throughout each kernel call if I can, right?
10:22:25 <ais523> you're allocating in global GPU memory, right? yes, reuse it
10:22:34 <ais523> mostly just because it'll save the memory allocator a bit of work
10:22:58 <ais523> oh, and /make sure/ you free, the OS won't necessarily be able to clean up after you if you don't, because GPUs don't have an OS
10:23:12 <ais523> I've seen computers wedged due to GPU memory leaks before now
10:24:07 <ais523> (a little surprising, because in theory the API to the GPU should be able to track all the memory being allocated as it's allocated, and deallocate in an atexit or something)
10:25:23 <cheater> ais523, the original question is: if an SaaS is storing my data, how to make sure the SaaS can only extract the data i need it to extract for the purpose of reducing a large (~GB) data set to something that i would like to download over the internet (~500 KB)
10:25:54 <cheater> i.e. search through files without knowing their full contents.
10:26:14 <cheater> more generally, how to wite progrems that process data without knowing most of it.
10:26:34 <ais523> cheater: there's been some research into that recently, but IIRC it's still in early stages
10:26:53 <ais523> I haven't seen it, just seen occasional talk about it
10:27:13 <cheater> i am thinking of a bloom filter style encryption
10:27:15 <ais523> technologically-inclined news sites, I think, but I'm not sure
10:28:10 <Patashu> encrypt it in blocks, and give the keys to blocks you want it to read?
10:28:35 <cheater> yes, that would be the kind of approach i mean as "bloom filter" approach
10:28:49 <Patashu> bloom filter's a completely different thing I thought
10:29:46 <cheater> well, what i mean is you give the SaaS part of the meta data (in your blocks) and it either includes or precludes other blocks from being selected for being sent to you
10:30:34 <cheater> then you process these blocks (say they contain some extended metadata) and based on that you query more blocks.
10:32:44 <cheater> but search and filtering is just one of the things performed on remote data sets
10:32:54 <cheater> what about some forms of (simple) compilation
10:34:14 <zzo38> Is there any Haskell function like: f x y z = if z then x else y
10:34:51 <cheater> can you write a compiler which either 1. is distributed and therefore no node sees the whole source code or 2. works on only parts of the source with the other parts not being necessary to see, just a simple copy and paste recipe is given to the user
10:35:42 <Patashu> a compiler to machine code or bytecode?
10:36:42 <cheater> let's say a compiler to C--
10:38:28 -!- sebbu2 has changed nick to sebbu.
10:38:54 <cheater> or a compiler from some language to python
10:39:15 <Patashu> seems easy enough then - libraries exist for example
10:39:21 <Patashu> unless you're fragmenting it further than the subroutine level?
10:40:00 <zzo38> Why isn't condition in Haskell implemented using a function like I said, instead of how it is?
10:41:51 <olsner> zzo38: because having special syntax is convenient
10:41:57 <monqy> except when it isn't at all
10:42:08 <monqy> it's hurt me more than helped me, at least
10:42:40 <zzo38> I don't think the special syntax is convenient. I think a function like that I described would make more sense and have a lot more uses.
10:43:23 <Patashu> there's a function like that in lisp I believe
10:44:33 <zzo38> Notice, I put the condition last on purpose.
10:45:38 -!- azaq23 has quit (Ping timeout: 258 seconds).
10:45:38 <monqy> it'd also be great to have a multi-clause lambda but nope
10:48:57 <zzo38> I wrote an implementation of Huffman trees in Haskell.
11:00:11 <zzo38> I wrote an implementation of Huffman trees in Haskell: http://sprunge.us/ARVR
11:02:59 -!- azaq23 has joined.
11:07:07 <zzo38> It can use a tree for decoding, but for encoding the tree is flipped.
11:09:36 -!- azaq231 has joined.
11:10:06 -!- azaq23 has quit (Ping timeout: 260 seconds).
11:10:08 <elliott> <ais523> oh, and /make sure/ you free, the OS won't necessarily be able to clean up after you if you don't, because GPUs don't have an OS
11:10:12 <elliott> ais523: wow, you really need to free every time?
11:10:54 <elliott> olsner: haskell's if syntax is not convenient
11:11:23 <monqy> is there a better way than what I'm doing to get something like J's forks into haskell
11:11:29 <elliott> bool t _ True = t; bool _ f False = f; if b t f = bool t f b
11:11:44 <elliott> monqy: fork f g h x = f x `g` h x
11:11:52 <elliott> ?pl \f g h x -> f x `g` h x
11:11:56 <monqy> yeah but I wanted something syntactically convenient
11:12:14 <monqy> right now I defined (<|) and (|>) to be (flip (.)) and (<*>), respectively
11:12:16 <elliott> fork (+) (/) length seems pretty convenient :P
11:12:19 <zzo38> elliott: Yes that way "bool" is better.
11:12:42 <monqy> but your fork might be better
11:13:20 -!- zid has joined.
11:13:27 <monqy> oh and the usage of <| and |> is like (f <|g|> h)
11:13:37 <zid> someone just linked me to the bfjoust wiki page
11:13:59 <zid> do they all play off against each other, or do you just play individual matches
11:14:08 <ais523> you play against the hill
11:14:15 <elliott> they play individual matches against every other program on the hill
11:14:17 <ais523> so the top n programs from the past, you play against
11:14:22 <zid> ais523: yay
11:14:24 <zid> That's fun
11:14:25 <ais523> if you beat any of them in average, you get on the hill yourself
11:14:35 <zid> koth has loop problems, invidiaul has sniping problems
11:14:44 <elliott> http://codu.org/eso/bfjoust/report.txt is the current report
11:14:50 <elliott> program sources at http://codu.org/eso/bfjoust/in_egobot/
11:14:50 <zid> I should try to remember bf
11:14:58 <ais523> the relevant parts are in the article
11:15:05 <elliott> ais523: unfortunately it's the new unreadable article
11:15:06 <ais523> remember the abbreviations exist, too, they'll save you lots of typing
11:15:18 <zzo38> At least, I think that way "bool" is more sensible way to make the condition commands in Haskell, rather than if...then...else, due to functional programming and currying and so on.
11:15:20 <ais523> I thought someone fixed that, or at least toned it down
11:15:24 <ais523> or weren't you going to sort it out?
11:15:26 <elliott> zid: bfjoust programming is quite unlike bf programming; the abbreviations are key, and obvious algorithms don't work because of speed/unreliability
11:15:31 <ais523> zid: there was an edit war over the formatting of that article
11:15:34 <elliott> ais523: I was too lazy in the end
11:15:38 <zid> It's still bad :P
11:15:41 <elliott> no war, I just told quintopia it was stupid :P
11:15:46 <elliott> zid: http://esolangs.org/w/index.php?title=BF_Joust&oldid=21108 this page might be more readable for you
11:15:55 <ais523> I think I removed all the gratuitous italics
11:16:05 <elliott> zid: http://esolangs.org/wiki/BF_Joust_strategies is also invaluable, and includes lots of in-depth explanations of winning programs
11:16:14 <elliott> mostly ais523's, since he never stops typing
11:16:27 <ais523> I only started dominating the hill towards the end
11:16:34 <zid> I want top 100
11:16:36 <ais523> by submitting a few ludicrously complex programs, then a much simpler one
11:16:37 <elliott> ais523: I meant the in-depth things
11:16:46 <ais523> the hill only goes to 40-something
11:16:47 <elliott> the current hill is already pretty huge
11:16:59 <ais523> including 100 is probably not viable with the current state of BF Joust warriors
11:17:03 <elliott> I mean, the programs at the bottom are already pretty bad
11:17:14 <zid> My programs will be pretty bad too :P
11:17:41 <elliott> zid: http://codu.org/eso/bfjoust/egojsout/ is very useful for writing bots
11:17:44 * zid ponders befunge wars
11:17:54 <elliott> it lets you pit a program against anything on the current hill or anything you paste in, with full trace and animation
11:18:04 <elliott> befunge wars predates bf joust :)
11:18:10 <elliott> (fukyorbrane; but it's fatally broken, alas)
11:18:16 <zid> I like befunge a lot
11:18:21 <zid> I wrote an interpreter for it
11:18:22 <elliott> fukyourbrane was brainfuck
11:18:28 <elliott> has nobody actually done befunge yet?
11:18:32 <ais523> !bfjoust simple_attack_with_decoys >>>>(-)*5<(+)*12<(-)*33<(+)*64(>)*7(>(+)*5[-])*19
11:18:39 <zzo38> I made the Huffman encode function is simple due to flipped trees: encode x = (>>= flip (findWithDefault []) (flipTree x));
11:18:40 <EgoBot> Score for ais523_simple_attack_with_decoys: 19.8
11:18:43 <ais523> elliott: BeYourFunge was yours, wasn't it? but you never got very far with it
11:18:44 <zid> elliott: I made my own
11:18:48 <zid> I don't like 93 or 98
11:18:54 <elliott> zid: so it's not befunge, then
11:18:56 <zid> it read 93 I think
11:19:01 <zid> but also supported my funge
11:19:12 <ais523> OK, a simple attack program that just follows all the rules of making a simple rush program did in fact get on the hill
11:19:14 <zid> I had graphics support :D
11:19:17 <ais523> and I'd expect it to not have managed that
11:19:20 <elliott> there's been a lot of progress on funge-98 in the past few years
11:19:29 <elliott> (with the release of the first even vaguely-compliant implementation four years ago)
11:19:30 <ais523> pity fungot isn't here to show off
11:19:30 <zid> push x,y,c on stack then there was a put pixel operation that popped them off
11:19:53 <elliott> zid: (fungot is our bot written in befunge-98, it does a bunch of language interpretation and markov babbling)
11:19:54 <ais523> elliott: incidentally, all this stemmed from a discussion on #nethack about how C++ was unreadable
11:19:57 <zid> I never did get around to writing funge using cardinally linked lists
11:20:06 <elliott> probably the only useful funge program anyone's ever witten
11:20:15 <ais523> then someone mentioned brainfuck, and it spiralled from there
11:20:29 <zid> I made a quip !
11:20:32 <elliott> ais523: btw, everything gets on the hill
11:20:38 <elliott> it just usually gets shoved off next time
11:20:46 <ais523> elliott: I know, I mean it's not in last place
11:20:46 <zid> I still need to figure out how this joust thing works
11:20:52 <elliott> also, /me stern glares at submitting programs in private
11:20:59 <EgoBot> Score for elliott_clever: 0.0
11:21:07 <ais523> asking questions in here can be a good idea
11:21:09 <zid> !bfjoust righty >
11:21:11 <EgoBot> Score for zid_righty: 4.3
11:21:13 <ais523> elliott: < always scores 0
11:21:14 <HackEgo> 294) <Vorpal> !bfjoust test (-)*10000 <EgoBot> Score for Vorpal_test: 12.9 <Vorpal> yay \ 295) <Vorpal> !bfjoust test (++-)*1000000 <Vorpal> probably will suck <EgoBot> Score for Vorpal_test: 30.4 <Vorpal> what \ 305) <Deewiant> !bfjoust sm3 < <EgoBot> Score for Deewiant_sm3: 43.4
11:21:17 <CakeProphet> help I added a #coding line to my python file but it still complains about unicode
11:21:22 <elliott> ais523: <Deewiant> !bfjoust sm3 < <EgoBot> Score for Deewiant_sm3: 43.4
11:21:24 <ais523> unless someone puts something on the hill that also suicides turn 1
11:21:25 <elliott> or at least it didn't used to :)
11:21:33 <ais523> elliott: the hill is no longer upside-down
11:21:36 <elliott> that might have been during the randomisation days, though
11:21:41 <zid> I scored 4.3 that means I'm better?
11:21:48 <elliott> zid: well, out of a hundred
11:21:53 <ais523> zid: > basically moves to the second cell, then waits there forever
11:21:57 <ais523> so it only wins if the opponent suicides
11:22:11 <ais523> and < moves off the tape and suicides instantly, so it's worse
11:22:16 <ais523> you typically replace a program with < to delete it
11:22:20 <zid> !bfjoust zid1 [>]
11:22:23 <EgoBot> Score for zid_zid1: 4.3
11:22:35 <ais523> elliott: in the early days of the hill, losing programs got better scores
11:22:49 <ais523> zid: the hill's padded with zeroes, so that moves to the second cell then exits
11:22:50 <Vorpal> elliott, that 43.4 score was a bug iirc that got fixed.
11:22:52 <elliott> I think this was after that
11:22:57 <zid> !bfjoust zid1 [>+]
11:23:00 <EgoBot> Score for zid_zid1: 0.0
11:23:08 <ais523> I suspect that runs off the /right/ end against most programs
11:23:11 <elliott> zid: that'll just run off the end, yeah
11:23:13 <ais523> you can run it in egojsout or somewhere to check
11:23:38 <zid> Can I detect the 128 nonses without doing 128 test-subtracts? :P
11:23:40 <CakeProphet> SyntaxError: UTF-16 stream does not start with BOM
11:23:53 <ais523> zid: no, that's the main issue of the game
11:24:07 <ais523> !bfjoust the_inevitable_next_thing_to_try [>(-)*128]
11:24:09 <EgoBot> Score for ais523_the_inevitable_next_thing_to_try: 4.7
11:24:12 <zid> it's 128 to be large enough that you spend forever trying to detect it?
11:24:15 <ais523> well, it's marginally better...
11:24:21 <elliott> zid: it's 128 for symmetry
11:24:37 <elliott> zid: programs are run with +- swapped in one situation; it's not important to understand right now but it helps balance
11:24:37 <ais523> zid: yep, so most programs try to figure out that a cell isn't a decoy before trying to clear it
11:24:48 <ais523> zid: basically, so that you can clear them with 128 +s or 128 -s
11:25:07 <ais523> 128 + 128 = 256 = 0 in 8-bit arithmetic
11:25:22 <zid> I should read this wiki page first
11:25:37 <ais523> the strategies page, in particular, will help explain the basics
11:25:47 <zid> I still don't understand the rules yet
11:26:02 <elliott> this channel is just me, ais523 and bots, btw
11:26:08 <monqy> i don't want to read strategies but i want to try my stupid hand at some bfjoust, so I'll do that
11:26:25 <elliott> monqy is the stupidest of all our bots.
11:26:35 <zid> I lose if I have a 0 to the left of my program counter?
11:26:39 <ais523> actually, statistically speaking, everyone but elliott is insignificant
11:26:40 <zid> err tape pointer
11:26:46 <elliott> ais523: I, er, don't think OpenCL has anything to free buffers
11:26:50 <ais523> zid: no, you lose if the tape cell the pointer started on is 0 for two cycles in a row
11:26:59 <ais523> elliott: perhaps it's automatic in OpenCL, then; check the docs
11:27:16 <elliott> ais523: unfortunately, I don't know where the docs /are/; the spec is not really light reading
11:27:27 <ais523> zid: that's called your "flag"; generally, the goal of the game is to locate the enemy flag and zero it before they do the same to yours, without falling off the end of the tape
11:27:31 <ais523> which is just past the flag
11:27:43 <ais523> therefore, paranoid programs have to zero every single cell from the tenth onwards before moving on
11:27:58 <elliott> ais523: btw, what does GPU assembly actually look like? I mean, in the abstract
11:27:59 <zid> why tenth onwards?
11:28:03 <ais523> elliott: I don't actually know
11:28:08 <elliott> zid: tape is ten to thirty elements
11:28:10 <ais523> zid: because the tape's always at least 10 cells long
11:28:15 <zid> I don't know either, the driver translates to it doesn't it?
11:28:21 <ais523> so you can go to the tenth safely without a risk of falling off, but not beyond
11:28:24 <zid> that's how DX worked
11:28:43 <zid> ais523: Why is zeroing what's ahead important?
11:28:55 <elliott> zid: because that's the goal of the game?
11:28:57 <ais523> well, if you move past the opponent's flag, you lose (that's one of the rules of the game)
11:29:13 <ais523> if you zero the cell before moving off it, and hold it at 0 for two cycles, then you know it's safe to move on
11:29:23 <ais523> because if you were already at the flag, doing that makes you win
11:29:30 <ais523> so if you haven't won yet, it must be because you aren't at the flag
11:29:43 <zid> is it not that it makes me lose, but it makes me not win?
11:30:22 <ais523> you lose instantly if you fall off the tape (rule of the game), just as you lose if your flag's zero for two cycles (also a rule of the game)
11:30:28 <ais523> those are the only two ways to lose, IIRC
11:30:57 <zid> it says you don't lose if you fall off
11:30:59 <zid> you just don't win
11:31:04 <zid> unless the other bot suicides
11:31:06 <ais523> zid: you don't lose if you fall off the end of the program
11:31:11 <ais523> you do lose if you fall off the end of the tape
11:31:16 <ais523> and that probably needs fixing in the wiki if it's unclear
11:31:18 <elliott> ais523: hmm, a few separate read requests from the same buffer are faster than copying the whole sixteen megabyte thing, right?
11:31:18 <zid> then fix the page? :/
11:31:29 <elliott> zid: the page needs a total rewrite, but nobody cba enough to do so
11:31:37 <zid> you can just explain it to me then :P
11:31:38 <zid> http://codu.org/eso/bfjoust/egojsout/?ap&l=04363d6a559fdb8a002cd6a7b0f284f741f791a0&r=simple&t=25
11:31:44 <zid> explain that pretty animation too while you're at it
11:31:47 <ais523> "Note that reaching the end of the program (as opposed to the tape) is not a loss; rather, a program that does that takes no action on any future cycle, and thus loses, wins, or draws according to whether the opponent manages to zero its flag, commit suicide, or do neither."
11:31:51 <ais523> seems reasonably clear
11:31:57 <elliott> zid: warriors are the things in the middle line, position is them moving
11:32:01 <zid> oh, it's the gamefield left to right, with a heightmap?
11:32:03 <elliott> the bars are the tape values, treated as signed
11:32:24 <ais523> and the flags are at the end, initialized to 128
11:32:32 -!- CakeProphet has quit (Quit: leaving).
11:32:38 <ais523> in this case, the red bot wins by a very small margin
11:32:48 <zid> This is SO much clearer
11:32:50 <zid> than ANY of the wiki
11:32:52 <ais523> because it zeroes the blue flag just before the blue bot zeroes the red flag
11:32:59 <ais523> yep, I think looking at the trace is probably the way to go
11:33:21 <elliott> <elliott> ais523: hmm, a few separate read requests from the same buffer are faster than copying the whole sixteen megabyte thing, right?
11:33:33 <elliott> I suspect only a handful, if that, of workers will actually succeed
11:33:34 <zid> are you trying to read from gpu memory?
11:33:58 <elliott> zid: I'm doing GPU programming, how else am I meant to get my results out?
11:34:05 <zid> stop trying to do useful work
11:34:05 <elliott> I'm going through the defined APIs. :p
11:34:06 <ais523> elliott: basically, you have to do a complicated and slow memory transfer thing to read from global GPU memory (the details are abstracted for you with most good libraries)
11:34:08 <zid> and use the result as a texture
11:34:18 <elliott> They're not textures, this is OpenCL
11:34:21 -!- CakeProphet has joined.
11:34:25 <zid> I know, but you can do.
11:34:31 <ais523> a GPU->CPU transfer isn't that bad, and the length of time is probably going to be proportional to the size of the read plus a constant
11:34:35 <zid> Stop trying to do useful work, just calculate textures
11:34:38 <ais523> it's similar in speed to a CPU->CPU transfer
11:34:50 <CakeProphet> uh.... any idea why Python would give me an attributeerror when trying to access a method
11:35:01 <elliott> ais523: right, but copying sixteen bytes dotted around a buffer is faster than copying sixteen megabytes all at once, surely?
11:35:06 <zid> ais523: Why doesn't the 0 rule apply to red in this trace?
11:35:28 <ais523> zid: because red 0s blue's flag just before blue 0s red's flag
11:35:42 <zid> wait, I think I completely misread something
11:35:42 <ais523> you'll see that red's flag still has a few pixels left when blue's is zeroed
11:35:48 <ais523> and when you win, you've won, game over
11:35:53 <zid> Yes, I did
11:36:02 <zid> I put an extra 'pointer' in there in my mind
11:36:15 <zid> know offhand an averagely strong bot I can try snipe?
11:36:46 <elliott> slowpoke. (Note: advice not advisable.)
11:36:54 <ais523> "simple" in egojsout is designed to be beaten by programs people are testing
11:37:11 <elliott> Allow a * b + c to be replaced by a mad. The mad computes a * b + c with reduced accuracy. For example, some OpenCL devices implement mad as truncate the result of a * b before adding it to c."
11:37:20 <elliott> haha, these flags are insane
11:37:27 <elliott> you can basically pass -cl-break-the-entire-IEEE-floating-point-spec
11:37:33 <zid> I want a pretty picture
11:37:36 <elliott> -cl-fortran (-cl-strict-aliasing)
11:37:44 <ais523> don't test against slowpoke, a) it's really really good, b) it'll probably crash your browser (but waterfall variants are even better at doing that)
11:38:01 <ais523> if you want a good program that's short to test against, try allegro
11:38:04 <zid> Right wins apparently
11:38:04 <ais523> (it's in the dropdown)
11:38:09 <zid> Can I get a red/blue graph of this somehow
11:38:15 <monqy> !bfjoust winner [[-]-]
11:38:19 <EgoBot> Score for monqy_winner: 14.2
11:38:32 <ais523> zid: click on one of the < or > marks
11:38:35 <zid> !bfjoust winner [[-]>What is this I don't even]
11:38:38 <ais523> and it'll show you the graph for one tape length
11:38:38 <EgoBot> Score for zid_winner: 13.7
11:38:57 <ais523> monqy: wait, how does [[-]-] not simply suicide at the start of the game?
11:39:12 <zid> I am always perceived to be on the left hand side?
11:39:27 <ais523> the first program entered will be the "left program", the red one attacking from the left
11:39:28 <monqy> ais523: how does scoring work?
11:39:30 <ais523> i.e. the one in the top text box
11:39:43 <ais523> monqy: http://codu.org/eso/bfjoust/SCORES explains it
11:40:23 <zid> My browser is dying a death :P
11:40:44 <zid> is ( the same as [
11:40:56 <ais523> no, ()* is an abbreviation for allowing you to abbreviate long programs
11:41:03 <ais523> instead of writing ++++++++++ you can just write (+)*10
11:41:17 <zid> (>)*9 makes sense now
11:41:25 <ais523> it's just syntactic sugar, but it helps a lot, particularly with high repeat counts
11:41:30 <monqy> anyway [[-]-] was my stalemating bot
11:41:47 <ais523> monqy: after the 128th - it runs ], checks that the square's 0, and now it's been 0 two cycles in a row
11:41:51 <ais523> one setting it to 0, one checking it's 0
11:41:54 <ais523> so it's actually a suiciding bot
11:42:08 <monqy> hopefully the enemy would have tampered with it by then
11:42:10 <ais523> a trivial stalemate on the flag is intentionally very hard to do
11:42:23 <ais523> monqy: that's where your only wins were coming from
11:42:26 -!- zzo38 has quit (Quit: Quitting are not permitted!!!).
11:42:32 <elliott> wtf, "const size_t foo = bar;" where bar is "const size_t bar = 999;" doesn't work because foo's initialiser is not constant?
11:42:37 -!- jix has quit (Read error: Connection reset by peer).
11:42:53 <monqy> while writing I forgot [ and ] were actually instructions
11:43:03 <monqy> as noted previously, I am the stupidest bot
11:43:05 <elliott> [ and ] actually feature quite rarely in the top programs
11:43:18 <ais523> they're necessary, though
11:43:23 <ais523> actually, anticipation is mostly square brackets, IIRC
11:43:42 <elliott> they're not really that necessary
11:43:50 <elliott> I mean, most of their uses can be totally inlined at the expense of insane explosion
11:43:52 <zid> I beat simple
11:43:53 <ais523> and the only program that beats slowpoke without being specifically designed to beat it
11:44:05 <ais523> why not post the program in-channel to see if it gets on the hill
11:44:11 <zid> !bfjoust simple_sniper >(+)*9(>)*8([-]>)*400
11:44:14 <EgoBot> Score for zid_simple_sniper: 20.8
11:44:19 <elliott> zid: want to feel daunted?
11:44:20 <elliott> http://codu.org/eso/bfjoust/in_egobot/quintopia_space_elevator.bfjoust
11:44:21 <elliott> http://codu.org/eso/bfjoust/in_egobot/ais523_waterfall3.bfjoust
11:44:29 <ais523> you might be interested in http://codu.org/eso/bfjoust/breakdown.txt
11:44:30 <elliott> (programs partially machine-generated)
11:44:36 <ais523> which shows you which programs your program beat, and which it lost to
11:44:43 <zid> doing me vs waterfall 3 atm
11:44:45 <ais523> elliott: I actually understand space_elevator, or did once
11:44:50 <zid> Right wins, 12
11:45:07 <elliott> zid: the various traces it links to are the different tape lengths and polarities
11:45:10 <ais523> I was studying my opposition in great detail
11:45:11 <zid> Oh, You can dump -1's in to delay them, I guess
11:45:17 <zid> I should do that
11:45:21 <ais523> zid: yep, the concept of decoys
11:45:28 <elliott> basically, the polarities are: in "sieve" polarity, the left and right programs have +- as normal; but with "kettle" polarity, +- is swapped for one of the programs
11:45:29 <zid> !bfjoust simpler >(-)*9(>)*8([-]>)*400
11:45:32 <EgoBot> Score for zid_simpler: 19.2
11:45:34 <elliott> (it doesn't matter which, as far as the winner goes)
11:45:40 <ais523> most programs will more or less effortlessly clear past smallish decoys, though
11:45:45 <zid> !bfjoust simpler (>-)*9([-]>)*400
11:45:49 <EgoBot> Score for zid_simpler: 6.3
11:45:55 <elliott> zid: this is because in the early days, people submitted programs that were just +- swaps of others, and did unreasonably well
11:45:58 <ais523> so your decoy of size 9 worked better than a decoy of size 1
11:46:16 <ais523> and the reason is that most programs know that decoys of size 1 are easy to make
11:46:20 <zid> how do you figure out if a decoy is a decoy?
11:46:28 <zid> increment once?
11:46:31 <ais523> you normally try making small changes to it to see if it becomes zero
11:46:43 <zid> so I could make an anti-decoy with a +? :)
11:46:47 <ais523> the "offset clear" revolutionized BF Joust, I think
11:46:57 <ais523> it's explained in the strategy article
11:47:02 <ais523> but basically, you clear with, say, ++[-]
11:47:13 <ais523> so that any decoy value from -2 to +2 will be cleared almost instantly
11:47:14 <elliott> Compilation error: <program source>:9:24: error: can't convert between vector values of different size ('key_t' and 'int')
11:47:24 <elliott> guess I should learn how opencl vectors work
11:47:33 <monqy> !bfjoust winner_ii [[+-](+)*64]
11:47:37 <EgoBot> Score for monqy_winner_ii: 8.1
11:47:46 <zid> !bfjoust simpler (>-)*9([+]>)*400
11:47:48 <EgoBot> Score for zid_simpler: 15.0
11:47:52 <zid> !bfjoust simpler (>---)*9([+]>)*400
11:47:55 <EgoBot> Score for zid_simpler: 11.0
11:47:57 <zid> !bfjoust simpler (>---)*3([+]>)*400
11:48:00 <EgoBot> Score for zid_simpler: 14.3
11:48:10 <zid> !bfjoust simpler (>)*9([+]>)*400
11:48:13 <EgoBot> Score for zid_simpler: 16.1
11:48:23 <zid> Still can't beat my 20.8 :P
11:48:25 <monqy> !bfjoust winner_ii [[-](-)*64]
11:48:29 <EgoBot> Score for monqy_winner_ii: 15.5
11:48:32 <ais523> zid: one marginal improvement: there's never any point in doing > more than 29 times without a < in between, so you can do, say, *9 then *20 and get a slight improvement for free
11:48:42 <monqy> woohoo I beat winner
11:48:52 <zid> I beat waterfall 3
11:48:52 <ais523> I'm not sure if there are any vibration programs on the hill that it would help against, though
11:49:12 <ais523> waterfall3 is a little fragile in one of its detection loops
11:49:26 <elliott> Compilation error: <program source>:12:2: error: statement requires expression of scalar type ('char __attribute__((ext_vector_type(8,8)))' invalid)
11:49:26 <elliott> while (key < first_key + (key_t)KEY_WORKLOAD);
11:49:27 <elliott> ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11:49:27 <elliott> I don't even know any more...
11:49:29 <ais523> I used a GA to tweak the constants in it so that it wouldn't lose against any of the programs on the hill at the time
11:49:34 <zid> Either I beat it, or it beat me :P
11:49:35 <monqy> !bfjoust winner_iii [[(-)*64](-)*64]
11:49:38 <EgoBot> Score for monqy_winner_iii: 8.4
11:49:45 <ais523> EgoBot: are you trying to compare vectors with <?
11:49:47 <elliott> ais523: (vec<othervec) does an _elementwise_ comparison?
11:49:51 <monqy> winner iii how could you
11:49:56 <ais523> elliott: I think it's just an error
11:50:07 <zid> Yea, I beat waterfall 3
11:50:11 <elliott> ais523: evidently not, since it's turned into a vector and while is complaining that it's not a scalar
11:50:12 <zid> what does the number mean after wins
11:50:16 <zid> (-2) or (10) or whatever
11:50:25 <elliott> <elliott> zid: the various traces it links to are the different tape lengths and polarities
11:50:28 <elliott> <elliott> basically, the polarities are: in "sieve" polarity, the left and right programs have +- as normal; but with "kettle" polarity, +- is swapped for one of the programs
11:50:33 <elliott> it's just showing by how many of those you won
11:50:38 <ais523> so 10, for instance, means left beats right on 10 more possibilities than right beats left (or is it the other way round?)
11:50:38 <elliott> well ok i didn't say it explicitly :P
11:50:49 <ais523> it's always going to be an even number unless there are draws
11:51:02 <zid> http://codu.org/eso/bfjoust/egojsout/?l=15396a05bd5bf1a9cf46c801df0d4408d6a43277&r=721bcf3b62a9de45dd13d789ddc874fce091e147&t=10
11:51:19 <zid> untouched!
11:51:19 <ais523> wait, does that URL link to waterfall3 in any way?
11:51:23 <ais523> if so, it'll crash my computer
11:51:25 <ais523> so I'd better avoid it
11:51:27 <zid> fine by me
11:51:35 <elliott> works in Chrome just fine :P
11:51:41 <elliott> ais523: hmm, can you coerce an integer of an appropriate size into a vector?
11:51:42 <zid> firefox is only using 460MB of ram
11:51:45 <ais523> crashes Chromium too for me
11:51:51 <ais523> I think I just have a weak computer
11:51:51 -!- MSleep has changed nick to MDude.
11:51:55 <zid> I'm using firefox 9.0a1
11:51:57 <elliott> if so, I think I should keep the key counter as an integer, and just cast it in the loop body
11:52:04 <zid> or whatever the fuck minefield is called these days
11:52:40 <zid> 9.0a1 (2011-09-01)
11:53:02 <zid> ais523: Do I get a prize for sniping waterfall 3?
11:53:16 <ais523> zid: I'm looking at it atm
11:53:24 <ais523> it seems to be very close, and vary a lot at different tape lengths
11:53:35 <ais523> (I'm looking in my own BF Joust program "juiced")
11:53:46 <elliott> zid: it's easy to counter a single program; significantly harder to counter more than one strategy :)
11:53:48 <zid> I want a single step debugger
11:54:00 <zid> elliott: shh, that was my 2nd attempt at a program
11:54:06 <zid> It just happened to randomly beat waterfall 3 :P
11:54:09 <elliott> although http://codu.org/eso/bfjoust/in_egobot/elliott_interior_crocodile_alligator.bfjoust did surprisingly well just by countering one program
11:54:14 <elliott> mostly because it produced something utterly mad
11:54:19 <zid> awesome name
11:54:20 <elliott> I don't even understand how it works myself
11:54:32 -!- sllide has joined.
11:54:46 <ais523> aha, it beats waterfall3 by being a very fast rush that isn't triplockable
11:54:56 <zid> triplock? :)
11:55:02 <ais523> on the basis that fast rushes coded that naively tend not to stay on the hill long
11:55:15 <ais523> zid: basically, it's a method of attacking ]]] in a program's control flow
11:55:16 <elliott> zid: http://esolangs.org/wiki/BF_Joust_strategies#Triplock
11:55:30 <ais523> by detecting the first ] falling through and making sure the cell isn't zero for the third
11:55:36 <ais523> so that the opposing program gets stuck in a loop
11:55:49 <ais523> it was trying to triplock your program, which of course has no ]]] anywhere
11:56:04 <ais523> and its reverse tripwires don't work to detect it because it rushes past them before they can be set up
11:56:17 <ais523> so it's using the triplock as a last resort, and failing
11:56:26 <ais523> I had fun making waterfall3, but it's way too complex for its own good
11:56:42 <zid> I like vibrator
11:57:13 <ais523> it beats waterfall2 the same way, incidentally
11:57:23 <ais523> in fact, that one's much more decisive
11:57:26 <zid> i'm not quite sure how to come up with a strategy for this
11:57:33 <zid> I'm currently 6 pooling
11:57:38 <ais523> neither is anyone else, that's part of the fun in the game
11:57:44 <zid> Maybe I can work my way up to a 4 gate
11:57:55 <zid> waterfall3 is like a 1 gate fast expand :P
11:58:02 * zid starcraft 2 references galore
11:58:50 <ais523> heh, I know a starcraft 2 player, so I get the references even though I don't play it myself
11:59:19 <ais523> hmm, defend9.75 is still up there too
11:59:26 <ais523> perhaps there'll be a renaissance of fast rush programs
11:59:47 <elliott> ais523: what endianness are GPUs this decade?
11:59:52 <ais523> the issue is, they seem far too easy to decoy against, and tripwire-avoidance is a) the only known fastrush counterstrategy, and b) it doesn't work
11:59:57 <CakeProphet> zid: it is time to write a lingrush.bfjoust
12:00:01 <ais523> elliott: I, um, don't know, I've never written code where it's relevant
12:00:06 <zid> right wins (24)
12:00:24 <elliott> ais523: neither have I, but I suspect casting a ulong to a uchar8 vector makes it relevant
12:00:38 <monqy> !bfjoust winner_iii >[[+]+]<[[+]+]
12:00:39 <zid> Oh god, 26
12:00:42 <EgoBot> Score for monqy_winner_iii: 14.3
12:00:43 <monqy> ok I'm done with winners for now
12:00:44 <ais523> elliott: write a test program and find out?
12:01:00 <ais523> 14.3 seems standard for programs that slowly suicide
12:01:05 <ais523> it probably beats turtles, or something
12:01:05 <elliott> ais523: already have, just wondering whether it mightn't be broken
12:01:13 <monqy> CakeProphet: I'm not even trying
12:01:29 <ais523> elliott: it's probably float-endian or something insane like that
12:01:37 <monqy> how about a quick suicide
12:02:04 <monqy> !bfjoust whats_bfjoust_help [-]
12:02:05 <ais523> !bfjoust how_many_turtles (+)*88
12:02:09 <EgoBot> Score for monqy_whats_bfjoust_help: 13.2
12:02:09 <EgoBot> Score for ais523_how_many_turtles: 14.1
12:02:13 <zid> !bfjoust meow >->+>->>-------------+>>>-([+]>)*400
12:02:16 <EgoBot> Score for zid_meow: 12.4
12:02:40 <zid> It beats waterfall3 on tape size 10!
12:02:43 <ais523> hmm, now I'm wondering if part of the winner score is a result of accidentally locking reverse offset clears
12:02:47 <zid> And only loses by 16 overall
12:02:48 <ais523> zid: waterfalls do better on long tapes
12:03:03 <zid> why is it named waterfall?
12:03:06 <ais523> anything that sets up that many tripwires and locks will
12:03:15 <ais523> basically, it's a pun on lock as in canal lock
12:03:25 <ais523> if you string lots of those together, you basically get a (slow) waterfall
12:03:54 <monqy> !bfjoust winner_iv [[(-)*128](+)*128]
12:03:57 <EgoBot> Score for monqy_winner_iv: 8.2
12:04:20 <ais523> !bfjoust i_love_vibrations ((+)*128(-)*128)*1000
12:04:25 <EgoBot> Score for ais523_i_love_vibrations: 11.9
12:04:28 <CakeProphet> !bfjoust the_best (>)*7+++>--->(++[-]>)*50
12:04:31 <EgoBot> Score for CakeProphet_the_best: 10.4
12:04:43 <ais523> i_love_vibrations did far too well, go add more antishudders, people!
12:04:56 <monqy> someone should snipe winner
12:04:57 <ais523> elliott: well, making a defend9.75 or a waterfall3 takes time
12:04:58 <zid> what does { do
12:05:03 <zid> expansion again?
12:05:13 <ais523> yep, but for nested brackets
12:05:24 * zid needs to figure out how to write what he wants to write
12:05:27 <ais523> (a{b}c)*5 = (a)*5b(c)*5 = aaaaabccccc
12:05:43 <ais523> and it only exists because brackets have to match, you can't write ([)*5
12:05:53 <ais523> umm, (a{b}c)%5, I mean
12:06:07 <zid> I suck at control flow in brainfuck
12:06:20 <ais523> so if you need to abbreviate lots of nested loops, you do it like that
12:06:23 <zid> I want to increment by 1, check for 0, otherwise decrement by 2, else increment until 0
12:07:00 <zid> is there an 'ad infinitum' structure I can use
12:07:02 <ais523> in that case, it's possible to almost directly convert the words into symbols and have it work
12:07:13 <ais523> because 100000 is the cycle limit
12:07:39 <ais523> I think many interps accept *-1 as a shorthand for that; I'm not sure if the one egobot's using does (iirc chainlance or cranklance, I forget which)
12:07:44 <zid> !bfjoust wiggly (>)*9+([--[+]]>)*1000000
12:07:47 <EgoBot> Score for zid_wiggly: 14.3
12:07:55 <monqy> !bfjoust winner_v [](+)*100000
12:07:57 <EgoBot> Score for monqy_winner_v: 4.4
12:07:59 <elliott> it's the agreed-upon abbreviation >:D
12:08:02 <zid> !bfjoust wiggly (>)*9+([++[-]]>)*-1
12:08:05 <EgoBot> Score for zid_wiggly: 14.0
12:08:14 <ais523> elliott: just like "sieve" and "kettle" are agreed-upon?
12:08:28 <elliott> ais523: yes, except that more than just me supports -1
12:08:29 <ais523> half of BF Joust terminology seems to have been you imposing your views on things
12:08:31 <CakeProphet> !bfjoust the_best (>)*9([-]>)*5(++[-.])*100
12:08:34 <EgoBot> Score for CakeProphet_the_best: 3.3
12:08:36 <ais523> now I wonder if juiced does
12:08:38 <zid> !bfjoust wiggly (++>-->)*9+([--[+]]>)*-1
12:08:39 <ais523> I guess it does, but am not sure
12:08:41 <EgoBot> Score for zid_wiggly: 5.2
12:09:03 <ais523> oh, seems I rewrite it to 1000000 during parsing
12:09:09 <ais523> zid: you start with 18 >s
12:09:13 <ais523> that's going to run off the tape quite a lot
12:09:31 <ais523> (you have two >s in the *9 abbreviation)
12:09:43 <zid> oops it misdirects the flag
12:09:54 <zid> !bfjoust wiggly (++>-->)*4+([--[+]]>)*-1
12:09:56 <EgoBot> Score for zid_wiggly: 21.5
12:10:00 <zid> highscore!
12:10:05 <CakeProphet> !bfjoust stupid_rush (>)*9([+]>)*5([-])*100
12:10:07 <EgoBot> Score for CakeProphet_stupid_rush: 5.8
12:10:24 <ais523> and it's made it onto the hill, in position 39
12:10:25 <zid> lol wtf did it do there..
12:10:38 <zid> oh, your bot fucking reset it
12:10:45 <ais523> the bot only shows the last run
12:10:51 <ais523> you can just resubmit, or run locally
12:10:58 <zid> waterfall 3 zipped across the screen and flipped it from 0 to 1
12:11:02 <zid> so I started incrementing it again
12:11:18 <ais523> it's a defensive program
12:11:21 <zid> Could I carpet bomb 10-35 with 1s every now and then?
12:11:35 <ais523> you can't go past the opponent's flag, if you do, instant loss
12:11:39 <zid> oh right..
12:11:47 <ais523> you can carpet bomb 2->current safe known location, if you like
12:11:59 <zid> can I pick a length of tape
12:12:01 <ais523> although the program for that would likely be machine-generated as it doesn't code trivially into BF
12:12:21 <ais523> in the simulators, yes, that's what the links in egojsout are for (various tape lengths)
12:12:30 <ais523> in the actual game, no, as it'd make it obvious where the flag was
12:12:33 <zid> I lose length 13
12:12:42 <zid> I get caught in a trap
12:12:59 <ais523> that's a good summary of waterfall3 :D
12:13:04 <zid> three times..
12:13:07 <zid> it's stunlocked me :(
12:13:14 <zid> four times :D
12:13:34 <zid> up to 8 so far
12:13:51 <zid> I'm stuck on the square before your flag, perpetually decrementing a square
12:13:55 <elliott> ais523: what will happen if I for (;;); on a GPU?
12:14:06 <ais523> elliott: bad things, I'm not sure exactly how bad
12:14:20 <elliott> ais523: hmm, I'll find out
12:14:21 -!- olsner has quit (Ping timeout: 240 seconds).
12:14:24 -!- Phantom_Hoover has joined.
12:14:26 <ais523> zid: that's known as a lock; it's what waterfall3 attempts to achieve, as a lock-based defense program
12:14:31 <ais523> it'll win eventually, but it may take it a while
12:14:40 <ais523> as it's going to clear every other square on the tape really thoroughly, in order
12:14:41 <zid> ais523: oh wow, I actually trapped waterfall 3
12:14:42 <elliott> ais523: absolutely nothing happened -- mostly because I hvae this sneaking feeling my kernel isn't executing
12:14:46 <zid> I shorted its logic out, it's completely stuck
12:14:58 <ais523> zid: on which tape length?
12:14:59 <zid> I'd link you it but you won't click it
12:15:08 <zid> (++>-->)*4+([--[+]]>)*-1
12:15:40 <ais523> zid: yep, what's happening is that the decoys collided with each other
12:15:58 <ais523> defense programs get more-or-less random results on short tapes as a result of the details of how decoy setups mix
12:16:46 <elliott> ais523: hmm, is there any good way to crash a GPU? I'm fairly sure my kernel isn't actually running :P
12:17:02 <zid> I did some opencl very very briefly
12:17:07 <ais523> elliott: I'm not sure, but crashing a GPU typically requires a hard reboot of your computer
12:17:12 <ais523> so it's probably not what you want to do
12:17:14 <elliott> ais523: that's OK, I'm desperate
12:17:17 <zid> I lost the source though it was on some guy's machine with 4 expensive radeons for bitcoin mining
12:17:17 <ais523> if you're lucky, the driver will notice
12:17:22 <elliott> for(;;); is executing in 0 time, s
12:17:26 <ais523> and get things back to a roughly sane state
12:17:39 <ais523> try doing an infinite loop that can't be obviously optimized out
12:17:43 * ais523 waits for elliott to ping out
12:17:43 -!- jix has joined.
12:17:59 <elliott> zid: I'm starting to worry that the entire userbase and market of OpenCL might be built around libertarians
12:18:11 <zid> the replays get horrendously slow on tape length 30
12:18:17 <elliott> (I wonder how many dollars have been spent on bitcoin mining hardware so far?)
12:18:34 <ais523> zid: waterfall3 actually rushes the last few tape cells in some situations, to avoid hitting the cycle limit
12:18:48 <zid> no, I mean computationally
12:18:50 <zid> I'm getting 1fps
12:18:55 <zid> tape 10 I get about 100fps
12:19:00 <ais523> that's because it's still computing the end of the run
12:19:09 <elliott> or maybe your cpu is just slow :|
12:19:13 <zid> I'm not installing a browse for 1 website
12:19:19 <ais523> at 100fps, it's playing back a recording
12:19:19 <zid> elliott: 2.4GHz core2 quad
12:19:28 <ais523> at 1fps, it's trying to play back a recording while computing the end of that recording
12:19:38 <zid> even though it said 'right wins' ?
12:19:44 <zid> or is it shipping it off to some cgi to do
12:19:49 <zid> but if I watch the recording, js fights
12:19:55 <ais523> it has to actually compute the recording as well as just run the program
12:20:00 <ais523> and you can watch the start while the end's being generated
12:20:12 <ais523> scroll to the end of the page to see how far it's got generating the runthrough
12:20:24 <zid> ais523: is your decoy setup the same each run?
12:20:39 <ais523> there's no way to randomize it, so yes
12:20:49 <ais523> different programs of mine use different decoy setups, unsurprisingly
12:20:53 <zid> could I just do the complete inverse of what waterfall3 does for any tape length wide enough to contain all of your decoys, I guess I'm asking
12:21:25 <zid> I think for tape length >20 there's basically two parts, the 'head' end which tries to navigate the decoys, and the 'tail' end that sets them up
12:21:36 <zid> and then a bunch of coinflip wins/losses for short tapes :P
12:21:44 <elliott> zid: it's possible, for any BF Joust program, to generate a program that beats it on all configurations
12:21:55 <elliott> this hasn't ever been actually proven but is pretty obvious
12:21:58 <ais523> elliott: was that ever proved? I strongly suspect it's true, but don't actually /know/
12:21:58 <zid> elliott: seems likely, but have you proven it
12:22:01 <elliott> I mean, it could be false, but I'd rather not believe it's false
12:22:10 <elliott> Anyway, point is, it's possible in practice even if not in theory :P
12:22:11 <zid> my gut says it's true
12:22:23 <elliott> zid: tl;dr Yes, you can, but it'll probably make no sense at all and do terribly against other programs
12:22:34 <zid> elliott: well, depends
12:22:42 <zid> I think it could work just fine
12:22:48 <ais523> elliott: I'm actually wondering if whether given any set of programs, there's always some program that beats them all on all configs
12:22:56 <zid> say a bot leaves a +4, -5, +2, 128
12:23:03 <elliott> ais523: That's a rather stronger hypothesis, but one that breaks the game quite thoroughly
12:23:08 <elliott> ais523: Finite set, I presume
12:23:09 <ais523> at one point, I was considering proving that, then programatically generating that program and submitting it to the hill
12:23:10 <zid> I just do - until 0, + until 0, - until 0, + until zero
12:23:20 <zid> and that bot will never *fail* to kill the flag
12:23:24 <zid> it just won't be optimal against a lot of stuff
12:23:26 <elliott> ais523: if you're evil, generate it, submit it, and then iterate
12:23:28 <ais523> zid: no, you recognise the decoy on tape length 10, then go straight to the flag and zero it
12:23:51 <zid> ais523: i wasn't going to do that. I wanted less specific
12:23:56 <zid> just a soft-counter
12:23:56 <ais523> elliott: I remember when you submitted a copy of then-beating-everything waterfall3 and I tweaked a constant slightly to make it beat even the original waterfall3
12:24:01 <zid> not a hard counter
12:24:33 <zid> yea, this is eating my browser
12:24:46 <zid> 1.2GB of memory in use and 25% cpu :D
12:24:57 <ais523> I use a C program to test programs against each other, it's rather faster than egojsout
12:25:17 <ais523> although the animations aren't as pretty
12:25:33 <zid> i'd be fine with ncurses tbh
12:25:43 <zid> %02X * 30 with ansi codes to colour red/blue or purple
12:25:50 <zid> * tape size rather
12:25:51 <ais523> it's X11, and just uses numbers to show values rather than a histogram
12:26:02 <zid> I should make an ncurses version
12:26:08 <elliott> raw X11 protocol over sockets? impressive
12:26:16 <elliott> also, wait for lance, everyone, chainlance and egojoust are both really terrible :P
12:26:18 <zid> rather than X11
12:26:25 <elliott> zid: rather than Xlib, you mean
12:26:32 <zid> well, rather than either
12:26:34 <ais523> here we go: http://sprunge.us/fALT
12:26:43 <elliott> xcb is gross because it's asynchronous and asynchronous shit is gross because C is gross and lacks continuations
12:26:54 <zid> that's very.. good.. ais
12:26:58 <zid> (christ look at that mess)
12:27:10 <ais523> give it filename to both programs as first and second args, tape length as third arg to limit to one tape length, anything as fourth arg to get an "animation"
12:27:12 <zid> It has 20 levels of nesting!
12:27:24 -!- olsner has joined.
12:27:35 <ais523> it's an imperative C program, you'd expect many layers of nesting
12:27:47 <ais523> it's not an OO program that uses lots of helper functions to keep cyclomatic complexity down
12:27:47 <zid> ais523 how does it know to sabotage me?
12:27:56 <zid> It doesn't have to be OO
12:27:57 <ais523> what do you mean by that?
12:28:01 <zid> you just have to be function names :P
12:28:07 <zid> it's backtracking exactly to where i am
12:28:14 <zid> and fuzzing the cell I'm [-]ing
12:28:18 <ais523> oh, because it locked you there in the first place
12:28:28 <zid> oh, it's using prior knowledge?
12:28:35 <ais523> it's not a case of it guessing where you are; rather, it decided where it wanted you to be, and made sure you went there
12:28:45 <zid> this shit is retardedly clever :P
12:28:53 <elliott> "retardedly clever" --zid, genius.
12:29:18 <zid> About 184 results (0.12 seconds)
12:29:22 <zid> I AM NOT A UNIQUE SNOWFLAKE :(
12:30:50 <zid> I think ais is too clever for me by like several orders of metric
12:31:03 <ais523> zid: I've had a few years' head start when it's come to jousting
12:31:54 <zid> I wonder if I could win by never leaving cells 0-3
12:32:01 <zid> vs any amount of things
12:32:26 <elliott> that would be a defence program
12:32:43 <elliott> it will just sit there if the other program is defence, unless you give up after a while and go attack (hybrid)
12:32:46 <zid> I am being highly unoriginal here aren't I
12:32:52 <elliott> hybrid strategies are difficult to write, but have large payoff
12:33:00 <elliott> zid: no, it's very hard to think of a new strategy nowadays
12:33:01 <ais523> zid: being original is probably quite difficult to do
12:33:06 <elliott> deep poke was the last one
12:33:10 <elliott> and lead to ais523 almost declaring the game beaten
12:33:20 <ais523> elliott: no, that's not what made me declare the game beaten
12:33:21 <elliott> but then he thought of a counterstrategy that might beat the game instead :
12:33:22 <zid> I read a post about that
12:33:29 <monqy> need a new game now
12:33:34 <ais523> that was timer clear, which destroys all defense programs, as far as I can tell
12:33:42 <zid> Games you play are fun while everybody is bad, but eventually get less fun as you get better, because the limits of the game are exposed
12:33:45 <ais523> I even figured out how to get it to beat anticipation, which I thought was a counterstrategy
12:33:51 <zid> I can't remember the example game now, it was something about asking questions
12:34:07 <ais523> it doesn't necessarily beat all rush programs, just all defense
12:34:12 <zid> It was a bit of a.. erm.. deepity
12:34:14 <elliott> ais523: I thought you thought that a revised slowpoke might beat the game
12:34:18 <elliott> but then realised it was beatable
12:34:22 <elliott> but then thought of another strategy
12:34:25 <elliott> that might beat the game instead
12:34:34 <ais523> elliott: I thought that it might completely destroy defense, not the game in general
12:34:44 <ais523> anticipation was what I thought the counterexample was (you'll notice it beats slowpoke)
12:34:50 <elliott> well, defence is three/fourths of the game nowadays
12:34:51 <ais523> but then I came up with a way for slowpoke to beat that too
12:35:03 <ais523> luckily, I've forgotten what it was
12:35:11 <ais523> but unfortunately, I imagine I'll work it out again with some thought
12:35:12 <zid> nice writeup of waterfall 3
12:35:32 <ais523> elliott: I think defense isn't that high a proportion; it's mostly me who submits complex defense programs, and only because I enjoy writing them
12:35:34 <zid> "figure out the fuck the other guy must be doing to have cleared certain cells, and plant stuff that would kill it" is pretty much it?
12:36:08 <zid> presumably a more chaotic program would be harder to beat for waterfall3
12:36:10 <ais523> although it's more measuring how long it takes to clear cells, than which cells are cleared
12:36:31 <ais523> alternating between more than two strategies for clearing beats it, for instance
12:36:33 <zid> I guess longer programs have an advantage
12:36:41 <elliott> ICA is basically the typical chaotic program -- wow
12:36:48 <ais523> (there are some sneaky tricks in there for beating progams that just alternate between two things)
12:36:55 <ais523> elliott: it can't be /that/ rare an acronym
12:37:02 <zid> am I at least thinking about strategy well? :/
12:37:03 <ais523> also, make an inferior_crocodile_alligator that's not quite as good
12:37:23 <zid> I declare myself a fast learning, if not skillful, then :P
12:37:27 <elliott> most people just spend a few days submitting nonsense programs that happen to get high results on the current hill before giving up and copying others
12:37:28 <ais523> ICA only wins because it behaves so stupidly that defense programs have no idea what it's going to do next
12:37:47 <elliott> ais523: sorry, but the only continuation of the ICA naming scheme is the inevitable chevrolet_movie_theatre
12:37:54 <elliott> which I suppose I'll use if I come up with a program that does massively well
12:38:05 <ais523> elliott: I'm amused that Gregor and I came to more or less the same program strategy via indepedent reasoning
12:38:12 <ais523> sufficiently so, that Gregor accused me of copying him
12:38:26 <ais523> although slowpoke does much better than the furry girls, because it doesn't try to be too complicated
12:38:26 <zid> Is there one called I_drive_a
12:38:30 <zid> to fill that gap
12:39:07 <ais523> also, about long programs: allegro is third, and it's a oneliner
12:39:13 <EgoBot> Score for elliott_i_drive_a: 4.5
12:39:25 <ais523> that's slightly more than 4.3!
12:39:28 <zid> define oneliner? :P
12:39:33 <ais523> fits into one line of IRC
12:39:42 <ais523> here's allegro: ->++>-->>+>>->+>+(>[(+)*9[-].[.+]])*2(+<)*4(+)*23<(-)*23<(-)*30<(+)*30<(-)*30<(+)*29(>)*9++(>[(+)*16[-].[.+]][-[+]])*19
12:39:44 <zid> where is the link to the hill again?
12:39:49 <ais523> http://codu.org/eso/bfjoust/report.txt
12:39:57 <ais523> (you can submit long programs via giving URLs to EgoBot)
12:40:11 <zid> shouldn't I be on there?
12:40:17 <elliott> (my program is leaky and I want to play DF)
12:40:22 <ais523> for a time, people were submitting arbitrary pages to EgoBot as a joke, like the report, and Google
12:40:27 <ais523> elliott: not in general, no
12:40:30 <ais523> restarting X might work
12:40:43 <ais523> but I wouldn't count on it
12:40:54 <elliott> by literally holding the power button
12:40:58 * zid is pretty sure he scored >20 twice
12:41:09 <zid> ctrl-f zid 404
12:41:10 <ais523> wiggly and simple_sniper are both on the list
12:41:18 <zid> oh, cache is wrong
12:41:22 <ais523> 39 47 21.13 -7.79 zid_wiggly.bfjoust
12:41:31 <zid> firefox seems to be ignoring it
12:41:37 <zid> the no-cache header
12:41:53 <zid> how come there's a 4.47?
12:42:06 <ais523> that's the most recently submitted program
12:42:11 <zid> it always gets 48th?
12:42:15 <ais523> it's not on the hill, but it's shown in comparison to the others
12:42:18 <ais523> so that people know how well it did
12:42:26 -!- elliott_ has joined.
12:42:47 <zid> 39th will do, I said I wanted a hill position and I got one :P
12:43:02 <ais523> the most recently eliminated program (which is often but not always the most recently submitted) is shown on the list at the top too
12:43:28 <ais523> hmm, space_elevator is still #5
12:43:49 <ais523> I should try to remember how it works
12:43:51 <quintopia> i've been thinking about improving it
12:43:53 -!- elliott has quit (Read error: Connection reset by peer).
12:44:01 <ais523> quintopia: does anyone but you and me understand it at all?
12:44:07 <zid> I should think about a funge war would work
12:44:16 <zid> bf is cool because it has the idea of a tape already in it
12:44:29 <zid> you don't really need to add anything but machine architecture
12:44:46 <ais523> even so, Kerim coming up with sharing the tapes was a pretty nifty idea that got it all started
12:44:47 <quintopia> ais523: you understood it once. i am too lazy to write it out, but it is actually less complicated than slow poke
12:45:03 <zid> ais523: We should write quad core bf apps, obviously
12:45:04 <ais523> yep, seems about right, it just has stupidly many cases
12:45:07 <ais523> which makes it look confusing
12:45:23 <ais523> (most of which are the same basic concept but differ in the details)
12:45:33 <ais523> and slowpoke is relatively simple too
12:45:40 * zid ponders about competitive spacechem
12:45:40 <ais523> at least compared to waterfall3
12:45:48 <quintopia> zid: i had a plan for a funge game. shared fungespace with code that is unwritable by the other guy, since the goal is to overwrite a certain shared area
12:45:49 <zid> red vs blue waldo
12:45:59 <zid> quintopia: Hmm, nice idea
12:46:25 <zid> What about befunge where both players appear to be 'above' the other's grid, and there's an instruction that drops a bomb
12:46:28 <zid> and destroys a symbol
12:46:33 <zid> and you win by making the other guy hit an edge
12:46:54 <ais523> Befunge doesn't really have edges, but I suppose you could surround the area with landmines or something
12:46:55 <zid> obviously most programs would be perfect grids of > on the left edge, < on the right edge, etc
12:47:03 <zid> but it might work
12:47:10 <ais523> it wouldn't be interesting unless you could read the enemy fungespace
12:47:15 <zid> See, I'm already coming up with strategy :P
12:47:19 <ais523> so as to get an idea about what the opponent was doing
12:47:31 <zid> ais523: but of course, you're limited by your own processing space
12:47:32 <ais523> zid: well, even something as basic as the rule of 9 took a while to come up with in BF Joust
12:47:38 <ais523> and the offset clear was revolutionary
12:47:39 <zid> does the read instuction take an x,y pair
12:47:43 <zid> or does it read under your 'reader'
12:48:07 <elliott_> zid: you want viewing distance
12:48:08 <lambdabot> elliott_: You have 1 new message. '/msg lambdabot @messages' to read it.
12:48:08 <zid> I just don't think funge is well-fitting enough, which is a shame
12:48:27 <zid> You could shoe-horn a billion games into funge wars
12:48:33 <zid> but bf joust really fits in nicely to BF
12:48:42 <zid> you're just adding machine architecture around the existing cpu
12:49:37 <zid> wow, I just had an idea like.. battle stations for bf joust, you put your program on a flash stick
12:49:43 <zid> and plug it into a machine with 2 usb ports
12:49:48 <zid> and it battles them and says who wins
12:49:57 <elliott_> that's called a really limited computer :P
12:50:00 <zid> and you win some ELO
12:50:16 <zid> It'd be like pokemans in real life, but with brainfuck :P
12:50:32 <quintopia> i feel like the us needs an esolang event o.o
12:50:47 -!- ralc has joined.
12:50:50 <zid> I feel like the US needs carpet bombing, what a strange difference in views
12:52:16 <elliott_> I, too, think that the correct solution to a difference in political opinion or culture or whatever is mass murder.
12:52:16 <quintopia> my guess is that zid lives in the us
12:52:33 <quintopia> you have to live here to hate it that much
12:52:51 <zid> Thankfully, no
12:52:58 <zid> I live in little britain
12:53:13 <elliott_> why do you want to carpet bomb the us again
12:53:29 <zid> free carpets for EVERYBODY
12:54:59 <zid> The real reason is that their wallpaper is too ugly
12:55:21 <monqy> !bfjoust true_winner (-)*-1
12:55:25 <EgoBot> Score for monqy_true_winner: 11.7
12:55:37 <monqy> my fingers were offset by one
12:55:46 <monqy> this is how stupid I am
12:55:54 <monqy> I can't even place my robot fingers properly :(
12:56:13 <zid> what led to the decision of making it two consecutive turns at 0 for the flag? more strategy?
12:57:28 <quintopia> i think making it three consecutive turns would make it even more strategy
12:57:46 <zid> You mean stratelogical
12:58:22 <monqy> ten turns and true winner will have its way
12:59:41 <quintopia> ten turns: shudder is automatic winner
13:01:43 <quintopia> hell it'd be hard to beat even with three turns, but once you can, everything becomes richer
13:07:08 <zid> I'd be more interested if bf joust used a fixed tape length I think
13:07:20 <zid> actually no
13:07:24 <zid> I just didn't think that through
13:07:37 -!- sebbu has quit (Ping timeout: 245 seconds).
13:08:20 -!- sebbu has joined.
13:12:09 <quintopia> a fixed tape with a wandering flag?
13:13:51 <ais523> quintopia: a three-turn wait allows triplocking on your own flag, which is AFAICT a broken strategy
13:18:19 <ais523> monqy: wow true_winner gets a lot of ties
13:18:30 <ais523> ah, that's the program that lots of people have submitted
13:18:48 <ais523> I can't remember who called it you_spin_me_right_round, that was the best name for it I've seen
13:18:52 <monqy> well tying was the goal
13:19:55 <ais523> a good antishudder clear will be able to beat it on both polarities; most programs will beat it on one
13:22:29 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40>[]<([{<(+)*-1}]<(-)*-1)%120
13:22:35 <EgoBot> Score for ais523_polarity_spinner: 11.8
13:23:11 <ais523> !bfjoust polarity_spinner >>>>(+)*6<+<(+)*40>[]<([{<<(+)*-1}]<<(-)*-1)%120
13:23:17 <EgoBot> Score for ais523_polarity_spinner: 9.0
13:23:27 <ais523> looks like that particular cheap trick doesn't work any more
13:23:53 <zid> speaking of cheap tricks, hi ais
13:24:16 <zid> I went and made a snack
13:24:21 <zid> now I'm watching minish cap
13:24:23 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40<(-)*33>>[]<([{<<(+)*-1}]<(-)*-1)%120
13:24:27 <EgoBot> Score for ais523_polarity_spinner: 3.0
13:24:33 <zid> how does that one work then?
13:24:37 <ais523> must have miscounted, I take it
13:24:57 <ais523> it's meant to be like true_winner/increase/you_spin_me_right_round/all the other names that have been used
13:25:06 <zid> I don't know what that is
13:25:11 <zid> how does it work?
13:25:11 <ais523> except that it detects what polarity the opponent is using, and matches it
13:25:20 <ais523> basically, keep adjusting your flag in one direction
13:25:36 <ais523> the opponent can only win by adjusting it the other way, otherwise it's either a draw or they fall off the end
13:25:41 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40>[]<([{<(+)*-1}]<(-)*-1)%120
13:25:47 <EgoBot> Score for ais523_polarity_spinner: 11.8
13:25:51 <zid> yea, my bot loses to 'falls off the end'
13:25:54 <ais523> I /have/ got this the right way round, right?
13:25:56 <zid> unless I wrap the [-] in another loop
13:26:00 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40>[]<([{<(-)*-1}]<(+)*-1)%120
13:26:05 <EgoBot> Score for ais523_polarity_spinner: 4.3
13:26:44 <ais523> there's a way of wrapping loops to guarantee you can't fall off, let me try to rememebr it
13:27:12 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40>[]<([{<(-)*-1}]<(+)*-1)%130
13:27:16 <EgoBot> Score for ais523_polarity_spinner: 6.7
13:27:23 <zid> what happens if your flag is 0 for a turn, then one bot +s it and one bot -s it, does that make a loss?
13:27:31 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40>[]<([{<(-)*-1}]<(+)*-1)%121
13:27:36 <EgoBot> Score for ais523_polarity_spinner: 5.7
13:27:45 <ais523> otherwise (+)*-1 would be unbeatable
13:27:50 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40>[]<([{<(-)*-1}]<(+)*-1)%118
13:27:56 <EgoBot> Score for ais523_polarity_spinner: 5.2
13:27:59 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40>[]<([{<(-)*-1}]<(+)*-1)%120
13:28:04 <EgoBot> Score for ais523_polarity_spinner: 4.3
13:28:08 <ais523> aha, this is the backwards version
13:28:19 <ais523> zid: that wouldn't, you could beat it via going to the flag then (-)*-1
13:28:29 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40>[]<([{<(+)*-1}]<(-)*-1)%130
13:28:29 <zid> oh you could beat it by doing -- twice yea
13:28:34 <EgoBot> Score for ais523_polarity_spinner: 12.4
13:28:39 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40>[]<([{<(+)*-1}]<(-)*-1)%140
13:28:45 <EgoBot> Score for ais523_polarity_spinner: 11.9
13:28:50 <ais523> I used to not tweak constants, now I'm shameless about it
13:29:03 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40<(-)*10>>[]<([{<(+)*-1}]<(-)*-1)%130
13:29:05 <zid> "If the theory is solid it should win regardless" ?
13:29:09 <EgoBot> Score for ais523_polarity_spinner: 15.1
13:29:41 <ais523> yep, that's the principle
13:30:51 -!- monqy has quit (Quit: hello).
13:30:56 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40<(-)*10>>([{(>)*6(>+++++[-.+-])*21}]<([{<(+)*-1}]<(-)*-1)%130)%8000
13:31:01 <EgoBot> Score for ais523_polarity_spinner: 15.4
13:32:04 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40<(-)*10>>([{(>)*6(>+++++[-....])*21}]<([{<(+)*-1}]<(-)*-1)%130)%8000
13:32:09 <EgoBot> Score for ais523_polarity_spinner: 20.6
13:32:20 <ais523> there we go, I think that's beating the defense programs
13:32:39 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40<(-)*10>>([{(>)*6(>+++++[-....])*21}]<([{<(+)*-1}]<(-)*-1)%130)%80000
13:32:45 <EgoBot> Score for ais523_polarity_spinner: 17.0
13:32:50 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40<(-)*10>>([{(>)*6(>+++++[-....])*21}]<([{<(+)*-1}]<(-)*-1)%130)%4000
13:32:57 <EgoBot> Score for ais523_polarity_spinner: 19.8
13:33:06 <ais523> well, if two defense programs end up against each other, they do nothing forever, right?
13:33:10 <zid> I don't get how that scores differently?
13:33:16 <ais523> so if you think that's happened, you go and use an anti-defense program
13:33:28 <ais523> the large number at the end is the number of cycles it waits before assuming defense
13:33:35 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40<(-)*10>>([{(>)*6(>+++++[-....])*21}]<([{<(+)*-1}]<(-)*-1)%130)%12000
13:33:41 <EgoBot> Score for ais523_polarity_spinner: 19.0
13:33:43 <zid> you should figure it out! :D
13:33:47 <ais523> !bfjoust polarity_spinner >>>(+)*6<+<(+)*40<(-)*10>>([{(>)*6(>+++++[-....])*21}]<([{<(+)*-1}]<(-)*-1)%130)%8000
13:33:53 <EgoBot> Score for ais523_polarity_spinner: 19.6
13:33:53 <ais523> looks like I was right first time
13:33:59 <zid> be cycle perfect on 0ing their flag ;)
13:34:19 <ais523> that's how I tweaked waterfall3 to beat elliott_'s copy of it when he submitted a copy of it
13:34:33 <zid> has fixed duration "highest value flag loses" been tried as a variant?
13:34:37 <ais523> started attacking a couple of cycles sooner, and beat the clone of itself to the flag while not changing the result against anything
13:34:49 <zid> sounds interesting to me
13:34:55 <ais523> would falling off the end still be a loss?
13:35:23 <zid> I think it'd just HALT you
13:35:23 <ais523> lowest flag looses seems potentially more interesting, otherwise the optimal behaviour is clearly to just set the flag to 0 so the opponent can't tell where it is
13:35:31 <ais523> unless, hmm, the opponent pokes you
13:35:38 <zid> I prefer yours I think
13:35:46 <zid> do flags start at 0?
13:36:03 <ais523> in highest-wins, I don't see why not
13:36:08 <zid> that sounds fun
13:36:24 <zid> it'd balance incing your own flag vs decing theirs
13:36:30 <zid> and bobytraps of course
13:38:12 <zid> I guess (+)*128 would be the standard intro, rather than (>)*9
13:38:28 <zid> or you could do +120 then rush their flag, to get their first
13:38:33 <ais523> !bfjoust undermine >>>>(>[[>](>(-)*120[-])*-1])*-1
13:38:36 <EgoBot> Score for ais523_undermine: 15.6
13:38:57 <zid> I wonder if it has anything that just stops it working as a competitive thing
13:39:04 <ais523> heh, I've made a program that mostly just beats my own programs
13:39:05 <zid> like it's really easily solveable or something
13:39:36 <ais523> am I really the only person using reverse decoy setup?
13:39:49 <ais523> I'd add that strategy to the strategies page if it were at all good, as I don't think it's there yet
13:41:03 <ais523> oh, I clearly need a small offset before doing the reverse offset clear
13:41:38 <zid> I would have told you but I didn't want to ruin the surprise
13:41:54 <ais523> !bfjoust undermine >>>>(>[[>]((>++++[-[-[-[-[-[-[-[-[(-)*120[-]{}]]]]]]]])%29)*-1])*-1
13:41:56 <EgoBot> Score for ais523_undermine: 0.0
13:42:02 <ais523> err, that obviously doesn't compile
13:42:08 <zid> I think you have a boog :P
13:42:18 <ais523> !bfjoust undermine >>>>(>[[>]((>++++[-[-[-[-[-[-[-[-[(-)*120[-]{}]]]]]]]])%29)*-1])*-1
13:42:20 <EgoBot> Score for ais523_undermine: 0.0
13:42:22 <ais523> !bfjoust undermine >>>>(>[[>]((>++++[-[-[-[-[-[-[-[-[(-)*120[-]{}]]]]]]]]])%29)*-1])*-1
13:42:24 <EgoBot> Score for ais523_undermine: 21.4
13:42:55 <zid> damnit, you beat me by .3
13:43:02 <zid> am I 40th now? :P
13:43:05 <ais523> heh, it's pushed you down from #39
13:43:40 <zid> Is there anything stopping you just submitting a program that does the same thing, but with different names, and maybe an unreachable statement to stop a string match?
13:44:59 <elliott_> well, programs draw against themselves
13:45:03 <elliott_> win and lose against the same things
13:45:08 <elliott_> so it's basically just another draw
13:45:12 <elliott_> i guess it might work to flood the hill
13:45:30 <zid> because the sniper for it will just end up beating it?
13:45:42 <zid> it might work for knocking people out of the list though
13:45:55 <zid> if I put 40 waterfalls up, that *would* have gotten the top 40, the waterfall sniper will instead get #1
13:46:03 <zid> even if sniper would otherwise have been lower ranked
13:47:14 -!- ais523_ has joined.
13:47:29 -!- ais523 has quit (Disconnected by services).
13:47:30 -!- ais523_ has changed nick to ais523.
13:47:34 <ais523> !bfjoust undermine >>>>(>[[-[++[>]]]((>++++[-[-[-[-[-[-[-[-[(-)*120[-]{}]]]]]]]]])%29)*-1])*-1
13:47:37 <EgoBot> Score for ais523_undermine: 18.7
13:47:43 <zid> I would manipulate first place but I can't be bothered :P
13:48:06 <ais523> it's about seeing your programs do well, rather than seeing programs you submitted do well
13:48:23 <zid> I could get my bot #1
13:48:25 <zid> the one I wrote
13:48:35 <zid> if I flooded with bots that it beat that are higher scored against it
13:48:49 <zid> so I write a bot to beat spam_poke, then submit 100 spam_pokes
13:49:02 <zid> and the top 40 that would be spampoke, gets beaten by my bot that beats spam_poke
13:49:04 <zid> every time
13:49:07 <ais523> no you couldn't, the scoring system is designed to counteract that
13:49:18 <zid> how does it do that?
13:49:25 <ais523> you'll find that the more duplicates of a program are submitted, the worse it tends to do
13:49:35 <ais523> simply because the same programs beat it each time
13:49:35 <zid> right, that also helps me though
13:49:40 <ais523> for instance, anticipation beats slowpoke
13:49:41 <zid> I submit *my* program once
13:49:48 <zid> and submit 30 copies of everything else
13:49:54 <zid> they all get draws, I get 30 free wins from spampoke
13:49:55 <ais523> so it'll climb in the rankings the more clones of anticipation are submitted
13:49:59 <ais523> and that only counts for duplicates on the hill
13:50:07 <ais523> your clones will have trouble staying on the hill after a while
13:50:18 <zid> I still think there's some manipulation I could do, even if not for a guarenteed first
13:50:31 <ais523> (that said, if a program beats the entire hill, like waterfall3 and slowpoke both did for a time, you can ruin the hill by spamming copies of it; someone actually did that and we had to revert the hill, it was a mess)
13:50:54 <ais523> !bfjoust undermine >>>>(>[([-[++[>{}]]]((>++++[-[-[-[-[-[-[-[-[(-)*120[-]{}]]]]]]]]])%29)*-1)%29])*-1
13:50:57 <EgoBot> Score for ais523_undermine: 15.4
13:51:07 <ais523> wow, I didn't expect that to do worse
13:51:10 <zid> has bruteforce been tried
13:51:11 <ais523> must just be that it's too slow
13:51:30 * zid wonders how quickly powers of 6 scale
13:52:02 <ais523> oh, aha, why is it reverse offset clearing a value -1 decoy?
13:52:21 <zid> ais, could I bruteforce all 10 character programs (no expansion stuff)
13:52:22 <ais523> evolutionary programming's been tried, but it didn't do all that well
13:52:26 <zid> not evolutionary
13:52:27 <zid> bruteforce
13:53:09 <ais523> the real problem's that I have a test backwards
13:53:16 <ais523> zid: possibly, but I suspect none would do well
13:54:45 <zid> shame it runs so slowly
13:54:48 <zid> need that brainfuck cpu
13:55:10 <zid> Maybe I should learn how to make bfj in an fpga
13:55:21 <zid> 8GHz clockrate gogo
13:56:21 <zid> I should just write the program that fights programs
13:57:44 <ais523> !bfjoust undermine >>>>((>[-[++[>([-[++[>{}]]]((>++++[-[-[-[-[-[-[-[-[(-)*120[-]{}]]]]]]]]])%29)*-1)%29]{}]])%29)*-1
13:57:46 <EgoBot> Score for ais523_undermine: 10.9
13:57:59 <ais523> you mean it does better with the test backwards?
13:58:34 <zid> handling the expansion will suck :/
13:58:57 <ais523> my interp, just like most competitive interps, run rather faster than egojsout, which is more of a debugger
13:59:08 <ais523> and optimises expansion
13:59:18 <zid> do you do complicated representations
13:59:22 <zid> or just use the string
13:59:31 <ais523> complicated representations, of course
13:59:32 <ais523> !bfjoust undermine >>>>(>[[>]((>++++[-[-[-[-[-[-[-[-[(-)*120[-]{}]]]]]]]]])%29)*-1])*-1
13:59:34 <elliott_> the important thing is about expansions
13:59:35 <EgoBot> Score for ais523_undermine: 20.3
13:59:36 <zid> I might have to go for complicated just to make the expansion easy
13:59:38 <ais523> strings are not a good format
13:59:50 <zid> I can just use a signed int for TTL
13:59:50 <elliott_> zid: we have well-established general algorithms for that
13:59:54 <zid> and <0 is infinite
13:59:59 <zid> elliott_: YES FUN!
14:00:06 <elliott_> zid: ok, enjoy your slow interp
14:00:07 <zid> wow I accidently the wrong word entirely
14:00:10 <zid> fuck off :/
14:00:53 <ais523> I'm not entirely sure I followed oerjan's algo
14:00:59 <ais523> I think I came up with basically the same thing independently
14:01:10 <zid> I was thinking of basically a linked list
14:01:13 <zid> but without it being linear
14:01:26 <zid> int command; with a couple of pointers to other nodes
14:01:31 <zid> if the command is ] or whatever
14:01:39 <zid> and expansion gets an int ttl;
14:01:48 <zid> which takes a different node once ttl hits 0
14:01:54 <zid> (or is never decrement in the -1 case)
14:02:01 <ais523> yep, it's usual to have a linked list with the body of a loop connected in a different direction
14:02:04 <zid> not that it'd matter actually, it'd never hit -2billion before the counter expired
14:02:13 <ais523> what you're describing is pretty much what juiced does internally
14:02:16 <zid> I don't see why this would be slow
14:02:35 <elliott_> the entire speed is dependent on the fancy interpretations of those
14:02:49 <zid> I could just do some 'external' cheating for those I'm sure
14:03:06 <elliott_> You mean expanding ahead of time?
14:03:06 <zid> just replace some flow control pointers
14:03:28 <zid> expanding ahead of time would work easily of course
14:03:33 <zid> even for the -1 case there's a cycle limit
14:03:34 <elliott_> It wouldn't because you run out of memory.
14:03:38 <zid> so it wouldn't use more than 100KB or whatever
14:03:54 <zid> oh right you can have any length thing inside ()
14:03:58 <elliott_> Paths can be not taken as well as taken
14:04:04 <elliott_> Plenty of programs blow up on any expanding interpreter
14:04:07 <zid> so it's 100k per ()
14:04:08 <ais523> !bfjoust undermine >>>>(>[[>]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1])*-1
14:04:10 <EgoBot> Score for ais523_undermine: 20.5
14:04:14 <zid> what's the cycle limit?
14:04:17 <ais523> now, that's interesting
14:04:21 <ais523> zid: 100000 in egojoust
14:04:24 <elliott_> But the cycle limit is irrelevant.
14:04:28 <ais523> and that's become a defacto standard as a result
14:04:35 <zid> why doesn't it matter?
14:04:36 <ais523> also, it's not irrelevant
14:04:46 <zid> If I enter a () I can prove it won't be in there any more than 100k cycles
14:04:49 <ais523> waterfall3 would hit it if I didn't change to a fast rush when it was at around cycle 96000
14:04:51 <zid> so I only need to expand it to a 100kB limit
14:05:03 <zid> not that I'm even doing it this way
14:05:07 <zid> I'm just saying it's possible
14:05:10 <zid> and works fine
14:05:11 <elliott_> ais523: tell zid why pre-expansion doesn't work, I'm too busy
14:05:23 <ais523> zid: you can have masses of nested loops
14:05:30 <ais523> !bfjoust undermine >>>>(>[[>]((>++++[-[-[-[-[-[-[-[-[(-)*116[.-]{}]]]]]]]]])%29)*-1])*-1
14:05:33 <EgoBot> Score for ais523_undermine: 20.5
14:05:42 <ais523> good to know that tweaking /that/ constant doesn't matter
14:05:53 <ais523> changing to the three-cycle clear makes it beat space_elevator, interestingly enough
14:05:54 <zid> or 116-120 both work fine
14:05:59 <zid> but 114 is way better :P
14:06:40 <ais523> what command are you supposed to run after hg pull (if any)? I've forgotten
14:07:37 <ais523> zid: I know; there's an hg repo of the egojoust competitors, though, and I wanted to update it
14:07:52 <zid> I just wanted to say "no idea"
14:07:57 <zid> in a way that'd also give some context why
14:08:12 <Vorpal> ais523, you can do hg pull -u iirc to do the hg up automatically
14:08:29 <zid> The tape itself has a random length from 135 to 167 elements; isn't it 10-35?
14:08:43 <elliott_> zid: you're reading an old document
14:08:51 <zid> someone linked me it and told me to read it (stares at ais)
14:08:54 <ais523> it used to be much longer, but shorter tapes were more interesting
14:09:01 <ais523> zid: that was elliott_ who linked you to it, not me
14:09:10 <zid> the staring worked regardless :D
14:09:17 <zid> proxy staring!
14:09:24 <zid> http://esolangs.org/w/index.php?title=BF_Joust&oldid=21108
14:09:28 <elliott_> oh, that explains the new version later on
14:10:24 <zid> anybody doing [ or ] has presendence over someone doing + or - is all I really need to know about regarding synchrroniziging?
14:10:43 <ais523> !bfjoust undermine >>>>(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%5])*-1
14:10:46 <EgoBot> Score for ais523_undermine: 22.2
14:10:53 <ais523> zid: pretty much, it's the only case where there can be a contradictoin
14:11:07 <zid> 22.2, you MONSTER
14:11:52 <ais523> wow, that little change worked wonders against quite a few programs
14:11:56 <ais523> and did nothing at all against most of the others
14:12:05 <ais523> (it might look like a big change, but I just duplicated the clear loop)
14:13:12 <ais523> it does really well at the start of the alphabet, but then is beaten horrifficaly by myndzi's programs
14:13:20 <ais523> let me put an antiturtle in there and see how much difference it makes
14:13:28 <ais523> !bfjoust undermine (+)*9>>>>(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%5])*-1
14:13:31 <ais523> I expect it to do worse
14:13:31 <EgoBot> Score for ais523_undermine: 28.5
14:13:36 <zid> MONSTER KILL
14:14:02 <ais523> guess I can't disregard turtles after all
14:14:24 <ais523> that only seems to really hurt against anticipation
14:14:35 <ais523> and it still beats that, just not by as much
14:16:20 <ais523> !bfjoust undermine (+)*9>>>>>>(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%5])*-1
14:16:23 <EgoBot> Score for ais523_undermine: 24.7
14:16:27 <ais523> !bfjoust undermine (+)*9>>>>>(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%5])*-1
14:16:30 <EgoBot> Score for ais523_undermine: 27.1
14:16:35 <ais523> !bfjoust undermine (+)*9>>>(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%5])*-1
14:16:38 <EgoBot> Score for ais523_undermine: 29.8
14:16:43 <ais523> !bfjoust undermine (+)*9>>(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%5])*-1
14:16:46 <EgoBot> Score for ais523_undermine: 30.8
14:16:50 <ais523> !bfjoust undermine (+)*9>(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%5])*-1
14:16:53 <EgoBot> Score for ais523_undermine: 31.4
14:16:57 <ais523> !bfjoust undermine (+)*9(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%5])*-1
14:17:00 <EgoBot> Score for ais523_undermine: 31.9
14:17:10 * zid stabs ais523 in the winningness
14:17:21 <ais523> Patashu: I was expecting the opposite pattern :)
14:17:30 <ais523> negative >s seems to be a bad idea, though
14:18:05 <Patashu> (+)*9(> <-- I found one you can remove here
14:18:22 <ais523> Patashu: indeed, but that would cause it to detect its own flag as an enemy decoy
14:18:54 <ais523> I think this is conclusive evidence that at least one program does not benefit from rule of 9
14:19:24 <zid> well it isn't using it is it
14:19:32 <ais523> anyone else figured out the principle I'm using there?
14:19:34 -!- monqy has joined.
14:19:53 <ais523> zid: no; the longest used there is a rule of 7, and reducing it all the way, eventually to a rule of 1, helped every time
14:20:25 <zid> rule of 9 only helps if you're not trying to trap your flag
14:20:29 <zid> so why would rule of 9 always be good?
14:20:42 <ais523> when attacking, it basically means you don't waste time clearing enemy decoys
14:20:54 <ais523> defensive programs use rule of 9 only when they switch to an attack loop, like a full-tape clear
14:20:59 * zid thinks of a good way to handle the square bracket detection
14:21:00 <ais523> that program, though, is looking for enemy decoys
14:21:07 <ais523> to be precise, it's looking for a reverse decoy setup
14:21:16 <ais523> then it goes forwards until there's a cell on which there /isn't/ a decoy
14:21:29 <ais523> then it goes forwards again until it finds a nonzero cell, and if it isn't small-valued assumes it's a flag
14:21:54 <ais523> should it find more than five "decoys" in a row, it assumes it's facing a trail rather than a reverse decoy setup, and changes tactics to ones that beat trailing programs
14:22:25 <ais523> then it uses a 3-cycle reverse offset clear at the end, because some programs try to defend against fast rushes using a 2-cycle lock
14:22:40 <ais523> so I suppose this is an evolution of tripwire_avoider and of fast_rush_slow_clear
14:23:18 <ais523> so, so far I've got it up to between the two wirelesses
14:23:24 <ais523> anyone notice any more obvious improvements?
14:23:33 <ais523> I'll run it through the constant tweaker, just in case it helps
14:23:40 * ais523 tries to remember how the constant tweaker works
14:24:16 <ais523> ah, flag tweakable constants as ##CONSTANT5## rather than 5
14:24:31 <zid> if((p1c == '[' || p1c == ']') && (p2c == '+' || p2c == '-'))
14:24:31 <zid> p1_first(&p1, &p2);
14:24:31 <zid> p2_first(&p1, &p2);
14:24:37 <ais523> wait no, that's internal
14:24:37 <zid> can you think of anything that would break that
14:25:02 -!- Patashu has quit (Quit: MSN: Patashu@hotmail.com , Gmail: Patashu0@gmail.com , AIM: Patashu0 , YIM: patashu2 .).
14:27:18 <ais523> !bfjoust undermine (+)*9(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%4])*-1
14:27:21 <EgoBot> Score for ais523_undermine: 27.7
14:27:24 <ais523> !bfjoust undermine (+)*9(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%6])*-1
14:27:27 <EgoBot> Score for ais523_undermine: 31.2
14:27:31 <ais523> !bfjoust undermine (+)*9(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%7])*-1
14:27:34 <EgoBot> Score for ais523_undermine: 28.5
14:27:40 <ais523> !bfjoust undermine (+)*10(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%6])*-1
14:27:43 <EgoBot> Score for ais523_undermine: 31.5
14:27:49 <ais523> !bfjoust undermine (+)*11(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%6])*-1
14:27:52 <EgoBot> Score for ais523_undermine: 33.9
14:27:56 <ais523> !bfjoust undermine (+)*12(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%6])*-1
14:27:59 <EgoBot> Score for ais523_undermine: 34.0
14:28:04 <ais523> presumably this is catching out some of the turtles
14:28:12 <ais523> while also giving the opponent more time to get into the meat of its decoy setup
14:29:53 <zid> heh piss off gcc
14:29:59 <zid> trying to test if this inlines well or not
14:30:24 <zid> yep, it sure does, my entire program compiles to push ebp / xor eax, eax / mov ebp, esp / pop ebp / ret
14:31:01 <ais523> !bfjoust undermine (+)*6(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:31:04 <EgoBot> Score for ais523_undermine: 35.9
14:31:20 <ais523> !bfjoust undermine (+)*6(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%3])*-1
14:31:23 <EgoBot> Score for ais523_undermine: 27.7
14:31:23 <zid> http://codepad.org/ABjrTpw8
14:31:29 <zid> it amazes me that gcc can compile that down to xor eax, eax
14:31:29 <ais523> !bfjoust undermine (+)*5(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:31:32 <EgoBot> Score for ais523_undermine: 38.8
14:32:06 <ais523> !bfjoust undermine (+)*0(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:32:09 <EgoBot> Score for ais523_undermine: 32.1
14:32:13 <ais523> !bfjoust undermine (+)*4(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:32:16 <EgoBot> Score for ais523_undermine: 35.2
14:32:22 <ais523> !bfjoust undermine (+)*5(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:32:25 <EgoBot> Score for ais523_undermine: 38.8
14:32:28 * zid fixes an off-by one in the cycle count
14:32:30 <ais523> seems to be a sweet spot there
14:32:56 <zid> I need to write the little compiler thing
14:33:08 <zid> that generates the flow control linked-list bastard thing
14:33:08 <ais523> !bfjoust undermine (+)*12(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:33:11 <EgoBot> Score for ais523_undermine: 35.4
14:33:35 <ais523> hmm, so either I can do well against quintopia, or I can do well against myndzi
14:33:41 <monqy> does the record file keep the best score or the most recent one
14:34:08 <ais523> most recent for each program
14:34:18 <ais523> so you can delete a program by replacing it with <
14:34:46 <zid> < would increase my score ;)
14:34:54 <EgoBot> Score for monqy_lazy: 6.6
14:35:21 <monqy> I guess I won against suicides or something?
14:35:37 <zid> () without a * is valid but does nothing?
14:35:47 <ais523> !bfjoust undermine (+)*12(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%6])*-1
14:35:49 <EgoBot> Score for ais523_undermine: 34.0
14:36:04 <ais523> !bfjoust undermine (+)*12(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:36:06 <EgoBot> Score for ais523_undermine: 35.4
14:36:13 <ais523> !bfjoust undermine (+)*10(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:36:15 <EgoBot> Score for ais523_undermine: 35.0
14:36:20 <ais523> !bfjoust undermine (+)*9(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:36:23 <EgoBot> Score for ais523_undermine: 38.7
14:37:18 <ais523> !bfjoust undermine (+)*6(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:37:21 <EgoBot> Score for ais523_undermine: 35.9
14:37:24 <zid> that saves me some trouble then
14:37:28 <ais523> !bfjoust undermine (+)*13(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:37:31 <EgoBot> Score for ais523_undermine: 39.1
14:37:40 <ais523> I wasn't expecting /that/
14:37:44 <kmc> what's all this then
14:37:53 <zid> ais == dirty cheater
14:38:17 <zid> he's a dirty version of you
14:38:18 <cheater> no reason to get unfriendly
14:38:26 <ais523> !bfjoust undermine (+)*14(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:38:28 <kmc> cheater, you don't have servants to do it for you?
14:38:29 <EgoBot> Score for ais523_undermine: 34.1
14:38:29 <monqy> what does undermine do? the bracket patterns look sort of like something I was trying to write but then gave up
14:38:36 <ais523> 13 seems to hit a sweet spot
14:38:43 <cheater> kmc, that was the royal I.
14:38:46 <ais523> mostly because it gets a flawless victory against FFLDG for reasons I don't fully understand
14:38:53 <ais523> !bfjoust undermine (+)*15(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:38:56 <EgoBot> Score for ais523_undermine: 37.6
14:39:02 <ais523> !bfjoust undermine (+)*16(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:39:07 <EgoBot> Score for ais523_undermine: 32.8
14:39:21 <ais523> !bfjoust undermine (+)*12>+([([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2]>)*-1
14:39:25 <EgoBot> Score for ais523_undermine: 25.3
14:39:41 <ais523> !bfjoust undermine (+)*12>+(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:39:43 <EgoBot> Score for ais523_undermine: 36.6
14:39:52 <ais523> !bfjoust undermine (+)*11>+(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:39:54 <EgoBot> Score for ais523_undermine: 40.8
14:40:08 <kmc> no seriously, what the hell is this
14:40:10 <ais523> what a difference a decoy can make, eh?
14:40:16 <kmc> you said that
14:40:18 <ais523> http://esolangs.org/wiki/BF_Joust
14:40:44 <monqy> I wish I had some good language/game ideas
14:40:47 <zid> http://codepad.org/ghmwa5G1
14:40:52 <zid> that's basically v0.1a of my struct
14:40:59 <zid> command is + or - etc
14:41:33 <ais523> !bfjoust undermine (+)*11>+(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%3])*-1
14:41:36 <EgoBot> Score for ais523_undermine: 30.6
14:42:07 <zid> every turn decrements count, if count is 0 you take next_paren, otherwise next_instruction, next_bracket is if your [ or ] executes a jump
14:42:13 <ais523> heh, changing it to %3 suddently caused it to lose to loads of things
14:42:15 <ais523> !bfjoust undermine (+)*11>+(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:42:18 <EgoBot> Score for ais523_undermine: 40.8
14:42:30 <zid> should work I hope
14:42:40 <zid> what do you think ais, or will that break your concentration
14:42:52 <ais523> it's similar to what I'm doing in juiced
14:43:00 <ais523> I haven't checked to see if you've got the details right
14:43:07 <ais523> but you've got the general principle right
14:43:28 <zid> How I'm going to free this I have no idea :P
14:43:33 <zid> Maybe I just won't ;)
14:43:34 <ais523> and hitting slightly above 50%
14:45:28 <ais523> time to add the strategy to the wiki, I guess
14:53:59 <ais523> heh, it loses to simple with all 42 combinations
14:54:11 <ais523> and I'm not surprised by that at all, simple doesn't use a reverse decoy setup
14:54:42 <ais523> pretty much all BF Joust strategies recently have been "find something that opponents do consistently, then work out how to exploit it"
14:56:05 <kmc> so this is probably obvious and cliché but: has anyone tried evolving bfjoust players, and if so how did it work out?
14:56:27 <ais523> kmc: they have, and not massively well
14:56:41 <ais523> I sometimes use an evolutionary algorithm to tweak constants
14:56:50 <ais523> !bfjoust undermine (+)*11>+>+(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:56:52 <EgoBot> Score for ais523_undermine: 40.5
14:56:58 <ais523> !bfjoust undermine (+)*11>+>++(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:57:01 <EgoBot> Score for ais523_undermine: 36.5
14:57:06 <ais523> !bfjoust undermine (+)*11>->+(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:57:09 <EgoBot> Score for ais523_undermine: 38.9
14:57:16 <ais523> !bfjoust undermine (+)*11>-->(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:57:18 <EgoBot> Score for ais523_undermine: 39.5
14:57:23 <ais523> !bfjoust undermine (+)*11>--(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:57:26 <EgoBot> Score for ais523_undermine: 35.3
14:57:44 <zid> ais523: that sounds pretty much perfect
14:57:46 <ais523> !bfjoust undermine (+)*10>->+(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:57:48 <EgoBot> Score for ais523_undermine: 34.0
14:57:49 <zid> find the optimal value in a local minima
14:57:54 <ais523> !bfjoust undermine (+)*9>->+(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:57:57 <EgoBot> Score for ais523_undermine: 38.0
14:58:09 <ais523> !bfjoust undermine (+)*11>+(>[([>{((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1}]((>++++[-[-[-[-[-[-[-[-[(-)*120[.-]{}]]]]]]]]])%29)*-1)%2])*-1
14:58:12 <EgoBot> Score for ais523_undermine: 40.8
14:58:42 <ais523> what could be interesting: a program that went through all the games by a particular program, highlighting commands by the win percentage when that command ran
14:58:47 <ais523> so you know which codepaths you tend to be in when losing
15:03:09 <ais523> in fact, that might be an interesting way to evolve a program
15:03:18 <ais523> codepaths with more of a tendency to lose get mutated more
15:07:15 <zid> wouldn't really help I don't think
15:07:20 <zid> it'd still get stuck in a minima somewhere
15:07:53 <zid> GA seems great at perfecting tactics
15:07:57 <zid> but poor for strategy
15:16:24 -!- nys has joined.
15:22:28 <elliott_> this is a channel about programming
15:22:53 <nys> I go by the name Twistle on the wiki .-.
15:23:23 <elliott_> oh, most people come here looking for the other kind of esoteric
15:23:27 <Gregor> b[9<<20],*a=b;main(){while(scanf("%d",a++)>0);for(a=b;*a;)a+=(a[*a]-=a[a[1]])?3:a[2];while(*++a)putchar(*a);} // 109
15:23:48 <elliott_> oh, you invented itflabtijtslwi? cool!
15:24:30 <nys> well, it's pretty simples
15:25:04 <nys> I thought /// was a beautifully simple language that lacked input
15:26:01 <nys> so I put in an arbitrary construct :<
15:26:16 <ais523> an incredibly arbitrary construct
15:26:27 <ais523> but hey, that's what eso's about
15:27:03 <elliott_> it's a pretty nice input mechanism for ///
15:27:06 <nys> oh, now that I think about it, I should have made it even more arbitrary
15:27:11 <elliott_> perhaps modulo the characters used but you can solve that with /// :)
15:27:19 <nys> like INOUTOOPSIMEANTINPUT
15:28:14 <nys> that would be a fun construct
15:29:45 <nys> oh, I also made this --> http://esolangs.org/wiki/TRUE <-- and went on here afterwards, someone told me it would be turing complete if I added a queue instead of a stack, so that's what I did ^^
15:38:27 -!- sebbu has quit (Ping timeout: 245 seconds).
15:38:50 <nys> and it is unimplemented
15:39:32 -!- elliott_ has quit (Remote host closed the connection).
15:39:34 -!- elliott has joined.
15:45:05 <Gregor> Hm hm hm ... 109 is pretty good :P
15:45:18 <Gregor> Short enough for RT @CaptainHats 109B interp: <it>
15:46:01 -!- sebbu has joined.
15:46:22 <cheater> a program i am trying to automate with pexpect is running /usr/bin/pager (full path). i want it to run cat at that point. can i hack it with some non-portable trickery?
15:46:38 <elliott> ln -s /bin/cat /usr/bin/pager
15:46:53 <ais523> elliott: I assume he means without overwriting /usr/bin
15:47:17 <cheater> ais523, elliott is obviously trolling
15:47:43 <ais523> cheater: you could use a chroot; that's reasonably portable, but annoying to set up
15:47:43 <Gregor> Yeah, elliott's was perfectly portable
15:48:04 <Gregor> But anyway, most pagers won't page if the output isn't a TTY.
15:48:07 <Gregor> So it shouldn't be an issue.
15:48:14 <ais523> for a nonportable method, you could hook whatever exec variant it was using in the library with LD_LIBRARY_PATH
15:48:23 <ais523> Gregor: the output is a pty, cheater's using pexpect
15:48:59 <Gregor> Why does pexpect use a pty :P
15:49:00 <cheater> wonder if i can control pager (which is less here) not to page at all
15:49:08 <ais523> Gregor: because that's the whole point
15:49:20 <Gregor> Well, in that case, you could run the command as whateverlol | cat
15:49:23 <ais523> if you didn't need a pty, you wouldn't need something pexpect-style at all
15:50:01 <Gregor> ais523: Depends on what you're testing *shrugs*
15:50:25 <Gregor> But if you're testing something interactive and you have the pty anyway, why not just send a 'Q' to the pager?
15:52:37 -!- sebbu has quit (Ping timeout: 245 seconds).
15:59:30 -!- sebbu has joined.
16:26:04 -!- oklopol has joined.
16:28:40 <oklopol> oops the https://wiki.helsinki.fi/display/lambda/esoteeriset+ohjelmointikielet guys accidentally forgot to mention clue :o well, no one's perfect i guess
16:30:26 <elliott> atehwa: you made a _fatal error_
16:31:23 <oklopol> first of all clue is probably the only esolang that has a theme song
16:32:02 <ais523> oklopol: now I'm audializing that hello world program I wrote in Fugue
16:33:17 <ais523> that list of esolangs there is bizarre
16:33:29 <ais523> at least, I can't figure out what the basis behind inclusion/exclusion is
16:33:41 <elliott> ais523: what we told them about, mostly
16:33:42 <ais523> I'm particularly surprised to see ABCDXYZ there, for instance
16:33:48 <elliott> ais523: that's because you said "all of mine"
16:33:58 <ais523> besides, not all of mine are there
16:34:00 <elliott> well, or words to that effect
16:34:11 <ais523> :≠ isn't, for instance, and it's part of the same group as BackFlip and ABCDXYZ
16:34:28 <elliott> man, clue is such a great language
16:34:32 <ais523> nor is Feather, but that is undoubtedly the correct choice
16:34:55 <elliott> I really love how it looks so obvious and intuitive but writing it is basically a process of brute force
16:35:02 <oklopol> be there even though it doesn't exist
16:35:44 <oklopol> yes clue is pretty fucking elegant
16:35:58 <oklopol> i wonder when i make clue2
16:36:14 <elliott> how could you possibly improve, I mean apart from including the function list
16:36:28 <elliott> it could just bruteforce with all permutations of all defined functions, using inferred type information to order the search
16:36:34 <elliott> (as in "this function uses lists let's look at list functions first")
16:36:41 <oklopol> a minor change to branching and types.
16:36:44 <elliott> that would only be about a hundred times slower and be about three times as elegant
16:37:03 <elliott> oklopol: hard to get more elegant than "function ~ {inputs -> outputs}" :P
16:37:06 <elliott> I mean maybe the recursion stuff
16:37:15 <elliott> if you did it higher order maybe you could just include fix and remove the recursion stuff :P
16:37:45 <oklopol> yyyyeah i'm sure you could somehow remove the main idea of clue
16:38:00 <elliott> oklopol: it would be great :-P
16:38:27 <oklopol> sure, it would then be the thing everyone's invented that's impossible to implement
16:39:09 <oklopol> hey wtf is just realized graphica is not on that list :D hahaha
16:39:13 <elliott> well, it depends how good your "type inference is". it still contins the original idea of thue, it's just about guessing the list for you. if you used like theorems for free you might be able to get a far way
16:39:38 <oklopol> yeah i totally agree with you
16:39:49 <oklopol> most agreeable nonsense i heard all day
16:39:51 <elliott> well it's kind of the same idea as djinn. only not, but
16:40:11 <elliott> theorems for free was wrt http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.38.9875
16:41:07 <oklopol> i have no idea what that has to do with anything though
16:42:20 <oklopol> i have to go now though, anyway that sounds like an article i should read
16:43:04 <oklopol> also toi seems to be lacking
16:43:36 <oklopol> even though it's the awesome
17:32:06 -!- jix_ has joined.
17:32:06 -!- jix_ has quit (Client Quit).
17:58:46 -!- Slereah has quit (Ping timeout: 258 seconds).
17:59:11 -!- GuestIceKovu has joined.
18:02:34 -!- ais523 has quit (Remote host closed the connection).
18:34:18 -!- Nisstyre has quit (Ping timeout: 245 seconds).
18:36:48 -!- cheater has quit (Ping timeout: 245 seconds).
18:43:22 -!- ais523 has joined.
18:48:40 -!- augur has joined.
18:51:28 -!- KingOfKarlsruhe has joined.
19:00:58 <zid> I'm awake!
19:01:16 * zid gets a marker pen
19:03:43 -!- oerjan has joined.
19:05:02 -!- zzo38 has joined.
19:11:27 <ais523> has there been much hill movement since I've been gone?
19:11:40 <ais523> I'm pretty astonished that I managed to drive a new strategy to #8 in just a day, really
19:12:01 -!- oerjan has set topic: It is the 90s and there is time for Esolang event @ Hel/Finland on 3.10.2011: https://wiki.helsinki.fi/display/lambda/esoteeriset+ohjelmointikielet | I think pointers are considerably more useful than lambda calculus | 12345678 | http://codu.org/logs/_esoteric/.
19:15:23 <Vorpal> oerjan, what did you change?
19:15:32 <oerjan> Vorpal: YOU WILL NEVER KNOW
19:15:54 <oerjan> although it did comply with a request by elliott in the logs
19:16:17 <Vorpal> also what is the first link in the topic about
19:16:26 <Vorpal> google translate claims the url is invalid.. (?)
19:16:51 <Vorpal> oh maybe it doesn't handle https
19:16:52 <Deewiant> Every Finnish-language paragraph there is followed by the equivalent in English
19:17:04 <Deewiant> And the URL itself is preceded by an explanation in the /topic
19:17:48 <Vorpal> Deewiant, yes that is what made me curious
19:18:14 <Vorpal> Deewiant, I don't get the things about the 90s though
19:18:17 <Deewiant> Just saying that it answers your "what is it about"
19:18:26 <Deewiant> That's an addition of Phantom_Hoover's
19:18:43 <Deewiant> The original was just "Esolang event @ Hel/Finland on 3.10.2011"
19:20:42 <oerjan> Vorpal: hint, you can frequently detect memes by typing the phrase into google and looking at the suggestions coming up. at least that's what i did for that thing in the topic.
19:21:08 <zid> what happens at an esolang event
19:21:22 <oerjan> zid: horrible brain-twisting stuff
19:21:48 -!- elliott has quit (Ping timeout: 245 seconds).
19:25:16 <zid> oerjan: Why would you be doing haskell at an esoland event? O_o
19:28:07 <oerjan> to implement esolangs in, of course
19:28:40 <ais523> is the event in Finnish? or English?
19:28:48 <ais523> if English, I want to see slides/recordings when it's done
19:29:06 <zid> You should send me to finland as your envoy
19:29:08 <Deewiant> Presumably Finnish if everybody present understands Finnish, otherwise English
19:29:40 <oerjan> it will be planned as dual finnish-english, which will be completely ruined when some prick insists that they must include swedish and there isn't time for that.
19:29:50 <oerjan> that's how it usually goes in finland, i think.
19:30:03 <zid> and then a norwegian will show up and call everybody uncultured
19:30:14 <Deewiant> I haven't run into such, anyway
19:30:21 <zid> yes, a .no prick :P
19:31:15 <fizzie> I've gotten one (1) report in Swedish out of about maybe a hundred and fifty (~150) that I've graded for the AI course. And I don't think they really *insisted* on being able to do it in Swedish.
19:31:56 -!- Taneb has joined.
19:32:43 <zid> nethack would be a good AI thesis
19:32:58 <Taneb> I am extuingished¬
19:34:06 <fizzie> I vaguely recall that a NetHack bot was one on the "suggestions for a project topic" list of the Prolog course.
19:34:12 <fizzie> I'm not sure if anyone ever did it.
19:34:34 <zid> problem is nethack is quite inaccessable for a bot
19:34:45 <zid> someone wrote api hooks for starcraft
19:34:49 <fizzie> You could possibly interface with some of the existing frameworks.
19:35:08 <zid> there's a starcraft AI competition too
19:35:18 <Taneb> I had a strange and crazy idea during my extuinguisment
19:35:53 <Taneb> A Non-Minimalistic OISC
19:37:06 <Taneb> Likeable? Probably not
19:37:27 <Taneb> It takes the entire point of a OISC and rips it from the concept
19:40:58 <zzo38> Actually I have once designed a schematic diagram for a processor that has only a transfer register to register and jump instruction, although it has a lot of registers with different functions. One of the registers is XORed with the jump destination to determine the actual address of the next instruction.
19:42:01 <zid> xor linked lists are there it's at
19:42:31 <zid> wow, I can't think, or type
19:45:41 <oerjan> <zid> and then a norwegian will show up and call everybody uncultured <-- that is not afaik the common national stereotype at _all_, if anything it's we norwegians who are considered uncultured.
19:46:08 <oerjan> (by the swedes, at least)
19:47:16 <zid> and the reverse :P
19:47:35 <zid> if you're really lucky, you can find someone from iceland to look down on all of them!
19:47:46 <zid> who then gets ran out of town
19:48:09 <oerjan> <Taneb> A Non-Minimalistic OISC <-- add the first argument to the product of the second and third argument, store into the address of the fourth argument, jump to the label in the fifth argument if result negative, the sixth if prime.
19:48:30 <oerjan> er *subtract the first argument from
19:48:39 <kmc> i thought iceland was the comic relief country of scandinavia
19:49:07 <oerjan> kmc: if you believe satw, they all are.
19:49:54 <zid> iceland is your weird uncle
19:50:12 <itidus20> i'm not sure which uncle is my weird uncle
19:50:17 -!- nooga has joined.
19:50:28 <zid> itidus20: The one who didn't molest you
19:50:31 <kmc> there's some real microcontroller where all functional units are memory-mapped
19:50:43 <kmc> to add numbers you mov them to the ALU
19:51:10 <nooga> i wanted to build such thing
19:51:16 <itidus20> im really starting to miss the wonderful meals i had to eat at family gatherings growingup
19:51:23 <itidus20> all manner of wonderful salads and cakes
19:51:27 <nooga> even wrote an emulator
19:51:36 <itidus20> plates with 3 salads and 4 kinds of meat
19:53:33 <itidus20> im just pulling figures out of the air
19:53:48 <itidus20> but turkey, pork, beef, i dunno
19:53:57 -!- mauke has quit (Disconnected by services).
19:54:00 -!- mauke_ has joined.
19:54:48 -!- mauke_ has changed nick to mauke.
19:56:04 -!- nooga has quit (Ping timeout: 258 seconds).
19:56:19 -!- augur has quit (Remote host closed the connection).
19:56:50 -!- nooga has joined.
19:57:07 <Taneb> What I meant to say before I remembered the kind of people that frequent this channel, myself included:
19:57:39 <Taneb> Don't have a two lists of thousands of floats in Python.
19:57:49 <Taneb> And if you do, close it as soon as possible.
19:58:13 <Taneb> And if you don't, turn off your computer
19:58:37 <Taneb> And if you don't do that in time, don't decide to switch OS half way through the recovery process
19:58:41 <zid> This can be simplfied to: Don't have python
19:58:58 <Taneb> And if you do, make sure you know who to call.
19:59:03 <zid> ghostbusters
19:59:36 <Taneb> BF Joust is a finite-state automaton
19:59:51 <Taneb> Irrelevant but true
20:00:17 <zzo38> Do you think the Monad class in Haskell ought to be defined that it requires to be also a Functor and that join is a member of Monad, and that you can define in terms of unit/join/fmap or return/bind and it does the other way by itself?
20:00:58 -!- nooga has quit (Ping timeout: 240 seconds).
20:01:29 <kmc> i kind of want Functor < Pointed < Applicative < Monad
20:01:37 <kmc> each one adds only one method
20:01:55 <zid> haskell needs a bit more work to be a good esoland, it's almost there
20:02:21 <oerjan> zzo38: making it also a Functor is discussed all the time, but it requires changing the class system to be backwards compatible
20:05:25 <Taneb> Catching up on the IWC I've missed
20:05:26 <oerjan> kmc: someone pointed out (heh) that Pointed perhaps should not be a subclass of Functor
20:10:47 <zzo38> For example, the list monad makes more sense when defined in terms of unit/join/fmap.
20:17:21 <zzo38> Probably they should allow something like this: http://www.haskell.org/haskellwiki/User:Zzo38/Proposal_about_classes
20:17:55 <Taneb> I now seem to be on a binge of the Popcorn instrumental
20:19:09 -!- augur has joined.
20:20:05 <oerjan> zzo38: see http://www.haskell.org/haskellwiki/Superclass_defaults
20:21:48 <Taneb> I'm listening to the third version of the tune tonight
20:25:08 <oerjan> "Hot Butter's version became the first primarily electronic-based piece of music to reach the American popular music charts, peaking at number nine on the Billboard Pop Singles and number four on the Adult Contemporary Chart."
20:30:05 <Taneb> I just watched the one by the group fronted by that annoying anaatomically hypercorrect amphibian
20:32:27 <oerjan> anatomically hypercorrect?
20:32:48 <zid> It wants your love
20:33:30 <olsner> oh, these subtitles are quite bad
20:34:34 <Taneb> oerjan: In the absolute opposite way that Ken dolls are incorrect
20:35:22 <oerjan> hypercorrect as in not correct at all
20:35:46 <Taneb> Hypercorrect as in taking a common error and correcting it where it wasn't wrong
20:35:49 <zzo38> Now I put all proposal in subpage of http://www.haskell.org/haskellwiki/User:Zzo38 and added the wiki categories for proposals, and See Also for link to other articles such as "Superclass defaults" article.
20:36:29 <olsner> "The uncle of the functional disability of how serious it?"
20:36:38 <Taneb> Frikkin family computer
20:36:43 <Taneb> IE is default browser
20:36:55 <Taneb> And I clicked that link without thinking
20:37:23 <oerjan> i suspect zzo38's links are rather harmless.
20:37:54 <Taneb> Especially on a slow machine
20:38:11 -!- augur has quit (Remote host closed the connection).
20:38:37 <Taneb> I need to learn Haskell.
20:38:50 <Taneb> Well, I don't, but I would really like to
20:39:23 <zzo38> If you have any question/comment/complaint about those articles, you can write it directly on those pages or on talk pages. You can also write on IRC, too.
20:39:30 <Taneb> Never tell me to drop everything
20:40:57 <Taneb> I don't like the phraase.
20:41:06 <oerjan> <Taneb> Never tell me to drop everything <-- Taneb is genetically engineered to follow orders literally
20:41:29 <Taneb> Also, I will be Arby
20:42:26 <olsner> "Springs, I was A leaf springs"
20:43:03 <oerjan> i will file it together with "never damn ais523"
20:43:15 <olsner> they've probably google translate'd the chinese subtitles ... I think leaf and springs are supposed to be names
20:44:38 <lambdabot> [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946...
20:46:11 <lambdabot> [1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,177...
20:46:15 <Taneb> oerjan: a phonetic pun, that's what
20:47:04 <oerjan> i don't get it even when carefully not pronouncing the r
20:47:25 <Taneb> I think the r should be there
20:47:54 <Taneb> The pun's multidialectal!
20:49:27 <Taneb> You know, before I even knew of the existence of the wiki, I wrote a draft spec for Ook!++
20:49:41 <Taneb> It introduced the keyworkd Eek
20:49:58 <oerjan> i assume it had extended library support
20:50:11 -!- hiato has joined.
20:50:11 -!- hiato has quit (Client Quit).
20:50:22 <Taneb> It was back when I sucked even more at programming
20:50:32 <Taneb> I had barely heard of brainfuck
20:50:50 <Taneb> I don't even think I had heard of C
20:51:22 -!- azaq231 has quit (Quit: Leaving.).
20:53:01 <Taneb> That would have been a good thing, except...
20:53:43 <Taneb> IT WASN'T A BRAINFUCK DERIVATIVE
20:53:55 <Taneb> IT WAS AN OOK! EXTENSION
20:53:56 <Sgeo> Brainfuck second derivative?
20:53:57 -!- nooga has joined.
20:54:57 <ais523> take a BF derivative that just reverses the commands
20:55:00 <ais523> then reverse the commands again
20:55:07 <Taneb> let b be the goodness of a brainduck derivative
20:55:18 <ais523> has the name "brainduck" been used yet?
20:55:20 <Taneb> By duck I probably mean fucj
20:55:21 <ais523> I refuse to believe it hasn't
20:55:34 <Taneb> My fingers don't seem to want to swear
20:55:41 <Taneb> You know what I mean
20:56:04 <Taneb> b is obviously very lo
20:56:28 <Taneb> If it is negative, b ^2 is positive
20:57:02 <Taneb> Now we need a measure of goodness
20:57:25 <CakeProphet> goodness is measured in terms of number of Perl-like syntax constructs.
20:57:36 <Taneb> I suggest the theresa, defined as a Hellen/metres squared
20:58:49 -!- Sgeo has left ("Leaving").
20:58:54 -!- Sgeo has joined.
20:59:05 -!- KingOfKarlsruhe has quit (Quit: ChatZilla 0.9.87 [Firefox 6.0.1/20110830092941]).
20:59:19 <Sgeo> I keep hearing about a Java thing called Spring, and I can only assume it's an enterprisey version of what Newspeak does naturally
21:00:03 -!- ais523 has quit (Remote host closed the connection).
21:00:32 <Sgeo> http://pchat-irc.com/blog/ wow
21:02:00 <oerjan> Taneb: some people will claim the theresa has been ...wrongly measured.
21:02:14 -!- sllide has quit (Ping timeout: 240 seconds).
21:02:20 <Taneb> People claim the same of the kilogram
21:02:57 <oerjan> or rather, the measure was fine, then someone made a calculation error
21:04:59 <Taneb> I'VE GOT AN ADVERT AND I DO NOT KNOW WHERE FROM
21:06:09 <CakeProphet> for some reason youtube keeps recommending shitty MSPA fan videos.
21:07:09 <zid> microsoft.. penis.. analysis?
21:07:31 <Taneb> I'm not sure which conclusion to leap to here
21:11:24 <oerjan> just check the penal code
21:17:21 <Sgeo> zid, Microsoft Paint Adventures
21:17:30 <Sgeo> CakeProphet, there are shitty MSPA fan videos?
21:17:40 <Sgeo> All of them are good!
21:17:44 * Sgeo is clearly insane
21:17:58 <Taneb> Same as Caledfwlch
21:18:01 <Phantom_Hoover> Logreading elliott proceeds to complain about this at length to me.
21:18:35 <CakeProphet> Sgeo: they are all bad everyone has huge troll boners.
21:22:25 <zzo38> Did I write Huffman program good? Is anything missing that I should add?
21:23:01 <zzo38> (I really intended it for using with GHCi, although you can modify it to make a compiled program too if you like to do that)
21:25:50 <zzo38> What kinds do you think Haskell ought to have? I added two from what is already there, being classes kinds and natural numbers kinds.
21:26:29 <zzo38> http://www.haskell.org/haskellwiki/User:Zzo38/Proposal_for_additional_kinds
21:27:20 <CakeProphet> [x] -- If x is a kind, [x] is the kind of classes of types of kind x
21:27:20 * Sgeo quickly joins #haskell to watch
21:27:43 <zzo38> Look at the example, will it help?
21:27:47 <copumpkin> zzo38: both of those are being implemented already
21:27:52 <CakeProphet> noepI don't see how typeclasses fit into kinds.
21:28:41 <Lymee> @hoogle [String] -> String
21:28:41 <lambdabot> Prelude unlines :: [String] -> String
21:28:41 <lambdabot> Prelude unwords :: [String] -> String
21:28:41 <lambdabot> Data.List unlines :: [String] -> String
21:28:46 <Lymee> @hoogle [String] -> String -> String
21:28:46 <lambdabot> Data.List intercalate :: [a] -> [[a]] -> [a]
21:28:46 <lambdabot> System.FilePath.Posix (<.>) :: FilePath -> String -> FilePath
21:28:46 <lambdabot> System.FilePath.Windows (<.>) :: FilePath -> String -> FilePath
21:28:49 <copumpkin> zzo38: although I'm not sure why you have a special construct for classes
21:28:52 <zzo38> CakeProphet: How is that?
21:28:54 <copumpkin> instead of just making it a regular old kind
21:29:11 <Lymee> > intercalate "a" ["b","c","d"]
21:29:13 <copumpkin> Monad would be (* -> *) -> Constraint
21:30:06 <Lymee> @hoogle Num a => a -> a
21:30:07 <zzo38> copumpkin: Example: [* -> *] is the kind of the Monad class, but * -> [*] is something that takes a type as a parameter to make up a class, and [*] -> [*] transforms a class to make a new class.
21:30:15 <Lymee> Guess it only shows 3.
21:30:23 <lambdabot> Data.List intercalate :: [a] -> [[a]] -> [a]
21:30:29 <copumpkin> zzo38: why have a separate kind construct for that?
21:31:09 <Lymee> @pl \b -> a where a = b+b
21:31:09 <lambdabot> expecting variable, "(", operator or end of input
21:31:39 <copumpkin> (* -> *) -> Constraint, * -> * -> Constraint, and (* -> Constraint) -> (* -> Constraint)
21:32:14 <CakeProphet> so I don't see why they would have a kind, which is the type of a type/
21:32:34 <copumpkin> this stuff is already being implemented anyway
21:32:50 <copumpkin> TypeNats by Iavor Diatchki at Galois gives the Nat kind
21:32:55 <CakeProphet> constructors make sense but what does the kind of a class mean
21:33:11 <copumpkin> and Max Bolingbroke and a few others are working on a kind of constraints
21:33:11 <copumpkin> so you can have associated constraints for classes
21:33:13 <zzo38> copumpkin: O, like that. I still don't quite like that syntax, but OK
21:33:22 <copumpkin> (type families with a codomain of classes)
21:33:30 <zzo38> copumpkin: Mostly to allow you to write more things relating to classes using type family, also allows you to do something like this: (X Int) a => a b => b -> b;
21:34:17 <CakeProphet> is X a typeclass variable or just any typeclass?
21:34:19 <copumpkin> class Monad m where type Constrs m :: * -> Constraints; return :: forall a. Constrs m a => a -> m a; (>>=) :: forall a b. (Constrs m a, Constrs m b) => m a -> (a -> m b) -> m b
21:34:29 <zzo38> Do existing proposals for natural number do some things like what I mentioned?
21:34:56 <copumpkin> yeah, I don't really understand what you mean there, but http://hackage.haskell.org/trac/ghc/wiki/TypeNats
21:35:01 <copumpkin> that explains more or less how it works
21:35:06 <copumpkin> I'm still not entirely convinced I like it
21:35:14 <copumpkin> because the solver is trying to solve an impossible problem :)
21:35:29 <copumpkin> if they'd left multiplication out, we'd have presburger arithmetic and I'd approve
21:35:38 <lambdabot> Couldn't match expected type `[a]' against inferred type `(t, t1)'
21:35:48 <copumpkin> but with multiplication, I'd want some way of instructing GHC with a proof that my types are correct
21:35:54 <copumpkin> since the solver will invariably fail in some situations
21:35:55 <Lymee> @hoogle (a->b) -> (a,a) -> (b,b)
21:35:55 <lambdabot> Data.Graph.Inductive.Query.Monad (><) :: (a -> b) -> (c -> d) -> (a, c) -> (b, d)
21:35:55 <lambdabot> Data.Graph.Inductive.Query.Monad mapSnd :: (a -> b) -> (c, a) -> (c, b)
21:35:55 <lambdabot> Data.Graph.Inductive.Query.Monad mapFst :: (a -> b) -> (a, c) -> (b, c)
21:36:13 <copumpkin> Lymee: you can send private messages to lambdabot, you know :)
21:36:19 <CakeProphet> copumpkin: okay so the idea with the class kinds is to have constraints other than typeclasses.
21:36:31 <zzo38> CakeProphet: X is of kind (* -> [[*]]) and a of kind ([*]) and b of kind (*), I think. (Maybe I made a mistake)
21:36:36 <copumpkin> CakeProphet: yeah, variable constraints
21:36:45 <copumpkin> CakeProphet: so I can make Set into a valid Monad instance, finally
21:36:51 <oerjan> <Lymee> @pl \b -> a where a = b+b <-- expressions need to use let ... in not where
21:37:01 <CakeProphet> copumpkin: er, set isn't a valid monad instance?
21:37:18 <zzo38> copumpkin: On one of my other user subpages I mentioned something like that too, but failed to put enough details unfortunately
21:37:25 <lambdabot> http://hackage.haskell.org/package/rmonad
21:37:31 <copumpkin> that allows Set to be an RMonad instance today
21:37:46 <copumpkin> because you have to match on a data family constructor before you can use the Ord instance
21:38:09 <copumpkin> zzo38: it's definitely lots of people have wanted for ages now :) I hope this time around it actually catches on
21:38:21 <CakeProphet> copumpkin: how does the syntax distinguish the class variable from a regular typeclass?
21:38:29 <CakeProphet> X could easily be the name of a typeclass.
21:39:19 <copumpkin> this is max bolingbroke's idea, before he started implementing it recently: http://blog.omega-prime.co.uk/?p=61
21:39:52 <copumpkin> http://hpaste.org/50576 that's code that he has working on a GHC fork right now
21:40:10 <oerjan> <Lymee> > map id (1,2) <-- join (***) does what you probably want with your map
21:41:16 <lambdabot> forall (a :: * -> * -> *) b c b' c'. (Arrow a) => a b c -> a b' c' -> a (b, b') (c, c')
21:41:35 <CakeProphet> copumpkin: that's interesting but it seems to make the case where you don't need a context in the instance declaration a bit more cumbersome
21:41:43 <CakeProphet> i.e. you have to do context RMonadElem a = ()
21:42:01 <CakeProphet> so perhaps it could just be empty if unspecified
21:43:26 <CakeProphet> but that's cool. I definitely like the idea of making Num a class synonym
21:44:13 -!- nooga has quit (Ping timeout: 264 seconds).
21:44:24 <CakeProphet> but you'd need to redefine Prelude. Perhaps make a package called Overture. :D
21:45:49 -!- nooga has joined.
21:46:31 <zzo38> I also think "join" should be part of the Monad class so that you can define a monad in terms of unit/join/fmap or using the way it already is, and both ways can be done. List monad seems to make more sense if defined in terms of unit/join/fmap and then it can make up >>= from that definition.
21:46:37 <CakeProphet> I'd imagine there's even more overhead with constraint families than there is regular typeclasses
21:47:34 <zzo38> I think there should be some way to specify a type taking natural numbers by defining it for zero and them for a successor, so that it applies for all natural numbers.
21:48:16 <copumpkin> associated types have no overhead whatsoever
21:48:27 <copumpkin> this is just another instance of an associated type
21:48:31 <CakeProphet> copumpkin: well actually I guess it would be the same overhead as typeclasses
21:48:52 <copumpkin> yes, but the associated type aspect of them doesn't
21:49:07 <copumpkin> and if the associated type constraint resolves to the empty constraint, as most will still do
21:49:07 <zzo38> In fact, this is what I think type-level natural numbers should do in general. Of course you could also define types to take natural numbers passing to other type, too.
21:49:26 <copumpkin> the empty constraint would be represented as nothing at all
21:49:34 <copumpkin> CakeProphet: class C a where type T a :: *
21:50:06 <zzo38> And due to being kind of classes, there would also be able to make classes using type-level natural numbers in the same way.
21:51:30 <CakeProphet> copumpkin: what you linked me didn't use that syntax, btw
21:51:54 <copumpkin> well, it doesn't associate the type in the class
21:52:08 <copumpkin> type family RMonadCtxt m a :: Constraint
21:52:13 <copumpkin> type instance RMonadCtxt S.Set a = Ord a
21:52:28 <CakeProphet> I think the constraint family stuff looks cleaner, but eh.
21:54:12 <copumpkin> this is more consistent with existing stuff
21:54:57 <Taneb> A push-down automaton can calculate any positive integer
21:55:27 <Taneb> A turing machine can calculate any pattern of positive integers
21:56:02 <CakeProphet> Turing machines can also spew inane babble, like fungot
21:56:22 <Taneb> It has a pattern, however convoluted
21:56:54 <Taneb> I'm just working with positive integers because I don't want to think about other things
21:57:07 <Taneb> It's merely one way of expressing the machine's data state
21:57:45 <Taneb> You'd need something more computationally powerful than a turing machine to calculate any infinite sequence of positive integers
21:57:54 <Taneb> Some of which have no pattern at all
21:58:58 <Taneb> This is from someone who woke up in a different country this morning
21:59:34 <zzo38> I added a few more things to [[User:Zzo38/Proposal for additional kinds]] page.
22:00:37 <Taneb> I'm annoyed because I have no hat
22:01:26 <fizzie> A thundarrrstorm-or-something broke the 'lectricity, forgot to start it; it's not installed in a servicey way.
22:01:36 <zzo38> I added one new kind and two new examples of kind of classes.
22:01:39 -!- Taneb has quit (Read error: Connection reset by peer).
22:02:19 <zzo38> Is it good? Or is it misunderstand? Or complain? Or no good? Or something else?
22:02:44 -!- copumpkin has quit (Ping timeout: 252 seconds).
22:03:09 -!- copumpkin has joined.
22:04:52 -!- fungot has joined.
22:07:54 <oerjan> ^ul ((0)(1)):!S(~:^:S*a~~*a*~:^):^
22:07:54 <fungot> (0)(1) ...out of stack!
22:07:54 <lambdabot> fungot: You have 1 new message. '/msg lambdabot @messages' to read it.
22:07:55 <fungot> lambdabot: public fields can rapidly become bad juju to touch because it's reserved for like the entire works of the beatles
22:08:15 <oerjan> ^ul ((0)(1)):^!S(~:^:S*a~~*a*~:^):^
22:09:04 <oerjan> ^ul ((0)(1)):^!S(~:^:S*a~^~*a*~:^):^
22:09:04 <fungot> 011010011001011010010110011010011001011001101001011010011001011010010110011010010110100110010110011010011001011010010110011010011001011001101001011010011001011001101001100101101001011001101001011010011001011010010110011010011001011001101001011010011001011010010110011010010110100110010110011010011001011010010110011010010110 ...too much output!
22:09:36 <fungot> Available: agora alice c64 ct darwin discworld europarl ff7 fisher homestuck ic irc* jargon lovecraft nethack pa sms speeches ss wp youtube
22:10:01 <lambdabot> CakeProphet said 2d 17m 7s ago: that sword alone
22:10:47 <fizzie> ^ignore ^(EgoBot|HackEgo|toBogE|Sparkbot|optbot|lambdabot)!
22:10:52 <fizzie> Oh ho, that wasn't on the list.
22:11:19 <oerjan> fizzie: it wasn't? i thought it was...
22:11:29 <fizzie> oerjan: Well, I don't really have "a list".
22:11:42 <fizzie> oerjan: I just reuse the first thing I see in the backscroll in the fungot query window.
22:11:43 <fungot> fizzie: it means very different things. numbers can be expressed in scheme. i am a bit
22:12:07 <fungot> CakeProphet: sarahbot tell yome duh you cant use match.php without going to species.php phenomenal
22:12:19 <olsner> something something fungot
22:12:19 <fungot> olsner: i'm working on
22:12:20 <oerjan> fizzie: in any case lambdabot did not say anything for fungot to react to
22:12:20 <fungot> oerjan: physicists rarely say anything that besides what you want
22:12:45 <fungot> oerjan: the power of the continuum is fnord
22:12:46 <lambdabot> fungot: You have 1 new message. '/msg lambdabot @messages' to read it.
22:13:14 <oerjan> CakeProphet: I AM SO TO
22:13:27 <CakeProphet> only I will have the glory of having fungot triggered by lambdabot
22:13:28 <fungot> CakeProphet: try the smetana or intercal problem. in my looking around on the web was very young. and playing a very stereotypical character.
22:13:44 <CakeProphet> it is my precedent and my privilege alone.
22:14:58 <CakeProphet> monqy: in my looking around on the web was very young. and playing a very stereotypical character.
22:14:59 <fizzie> It happened in 2011-04 too.
22:15:40 <CakeProphet> I suppose I am obligated to be melodramatic about that as well.
22:16:01 <EgoBot> Bot prefixes: fungot ^, HackEgo `, EgoBot !, lambdabot @ or ?
22:16:07 <fizzie> (I seem to have not-^save'd that too.)
22:16:17 <fizzie> ^def prefixes ul (Bot prefixes: fungot ^, HackEgo `, EgoBot !, lambdabot @ or ?)S
22:16:35 <HackEgo> Bot prefixes: fungot ^, HackEgo `, EgoBot !, lambdabot @ or ?
22:17:15 <fungot> ^<lang> <code>; ^def <command> <lang> <code>; ^show [command]; lang=bf/ul, code=text/str:N; ^str 0-9 get/set/add [text]; ^style [style]; ^bool
22:17:19 -!- augur has joined.
22:17:28 <fungot> CakeProphet: How silly do you think I am?
22:17:42 <fungot> CakeProphet: i suppose it's event driven by using callbacks when certain tokens are found.
22:17:57 <olsner> ^dieyougravysuckingpigdog
22:18:22 <fungot> >,[>,]<[<]>[<++++[>--------<-]+>-[-------[--[<+++[>----<-]+>[<
22:18:36 <fizzie> Oh, the strings were persistent too?
22:18:57 <fungot> Set: cakporphet wuz hear
22:19:27 <fizzie> There's something in 6 too.
22:19:36 <fungot> >,[>,]<[<]>[<++++[>--------<-]+>-[-------[--[<+++[>----<-]+>[<++++[>-----<-]+>[-----------[---[[-]<<[>[-]>+<<-]>>[<<+>>-]+<[->-<<<[[>+<-]<]>>[>]]>[->[>]<[[>+<-]<]<<[[>+<-]<]<[[>+<-]<]>>[>]>[[[>]>+<<[<]>-]<<[[>+<-]<]>>[>]>[>]>[<<[<]<[<]<+>>[>]>[>]>-]<<[<]>]>>[[<+>-]>]<<[<]]]<[->>[>]<[[>>+<<-]<]<<[[>+<-]<]>+>[>]+++++[>++++++++<-]++>-[<+[<]>+[>]<-]]>]<[->>[[<<+>>-]>]<<<[[>+<-]<]]>]<[-<[[<]>.[-]>[[<+>-]>]>>[[<+>-]>]<<[<]<<]>>>[[<+>
22:19:44 <fizzie> I can't seem to count.
22:19:57 <fizzie> (Looked at the state file, but those are not numbered.)
22:21:09 <copumpkin> O CakeProphet, what does my future hold for me?
22:21:31 <fizzie> I'm not sure that actually works for non-^def.
22:21:49 <oerjan> was that the one i made, i wonder. and where did i put it.
22:22:12 <fungot> echo reverb rev rot13 rev2 fib wc ul cho choo pow2 source help hw srmlebac uenlsbcmra scramble unscramble asc ord prefixes tmp
22:22:13 <fizzie> oerjan: The full string is at http://p.zem.fi/4rql
22:22:23 <fizzie> CakeProphet: It continues on from that.
22:22:24 <CakeProphet> so that would be why it is currently not working
22:22:44 <oerjan> fizzie: thank you for thinking i can read my own bf :P
22:23:00 <fizzie> North-Canadian Linear Prediction?
22:23:20 <CakeProphet> those north canadias are quite linear, yes.
22:23:40 <fungot> Usage: ^def <command> <lang> <code>
22:23:59 <fungot> >,[>,]<[<]>[<+4[>-8<-]+>-[-7[-2[<+3[>-4<-]+>[<+4[>-5<-]+>[-11[-3[[-]<2[>[-]>+<2-]>2[<2+>2-]+<[->-<3[[>+<-]<]>2[>]]>[->[>]<[[>+<-]<]<2[[>+<-]<]<[[>+<-]<]>2[>]>[[[>]>+<2[<]>-]<2[[>+<-]<]>2[>]>[>]>[<2[<]<[<]<+>2[>]>[>]>-]<2[<]>]>2[[<+>-]>]<2[<]]]<[->2[>]<[[>2+<2-]<]<2[[>+<-]<]>+>[>]+5[>+8<-]+2>-[<+[<]>+[>]<-]]>]<[->2[[<2+>2-]>]<3[[>+<-]<]]>]<[-<[[<]>.[-]>[[<+>-]>]>2[[<+>-]>]<2[<]<2]>3[[<+>-]>]<2[<]<]>]<[->2[>]<[[>+<-]<]<2[>4[>]<[[
22:24:33 <oerjan> maybe it wasn't something useful anyway.
22:25:09 <CakeProphet> well it appears to take input until it reaches zero
22:26:33 -!- Patashu has joined.
22:26:33 <CakeProphet> so I guess it wants a null-terminated string of some kind.
22:26:42 <zzo38> How many Haskell extensions can you detect by the syntax of the program? (Not explicitly checking for them)
22:27:24 <oerjan> it looks to me like it'll hang up in that [>-8<-] loop unless the first char is divisible by 8
22:28:17 <oerjan> maybe it's actually just randomly generated. but why so few .'s then
22:29:58 <fizzie> It will get a 0 on EOF.
22:30:06 <oerjan> CakeProphet: um i'm pretty sure fungot does that on eof
22:30:06 <fungot> oerjan: you know thats the first time
22:30:19 <fizzie> fungot: The first time what?
22:30:19 <fungot> fizzie: hi all. question about the plt-match module?
22:30:33 <fizzie> fungot: Your #scheme roots are showing there.
22:30:34 <fungot> fizzie: they are significantly less coherent
22:33:43 <fungot> CakeProphet: associated with a string structure the whole way through, which is a language for it to tell me?
22:34:29 <fungot> Available: agora alice c64 ct darwin discworld europarl ff7 fisher homestuck ic irc* jargon lovecraft nethack pa sms speeches ss wp youtube
22:34:38 <fungot> Selected style: europarl (European Parliament speeches during approx. 1996-2006)
22:34:50 <fungot> CakeProphet: mr president, you could say ' jack robinson'. but we must also put on record. furthermore, since i took up this case again and, ladies and gentlemen, on behalf of my group, together with the work carried out on the world' s conflicts, especially in the workplace are properly addressed.
22:35:40 <fungot> CakeProphet: mr president, i would like to congratulate jean-louis bourlanges on the quality of vessels, in their struggle to promote public discussion, for the abolition of the budgetary authority come to agreement on the part of amendment no 21 which seeks to promote the european labour market that is like waiting for fnord. under these, our opportunities, and in my speech which relates to the protection and maintenance of al
22:36:29 <fizzie> I like how it really sounds like a politician in that style.
22:36:36 <fizzie> Well, except maybe for the fnords.
22:38:39 <fizzie> Yes, but fungot's being so open about them.
22:38:40 <fungot> fizzie: mr president, mrs van den burg for an enormously well done job and the responsibility of our successive rulers. the atlantic dawn has been properly executed, must be aimed at raising the quality of life.
22:40:44 <fungot> CakeProphet: mr president, with respect to the establishment of a centralised electronic european union judgment registry, which has been increasing and, above all, an opportunity which we should be able to rely on nuclear energy. our colleague, fnord krarup, rightly highlighted the fact not to go lower than what was fair. the green paper on the different approaches.
22:41:29 <fizzie> The amusement. "our colleague, fnord krarup, --"
22:41:35 <oerjan> fnord krarup, the famous danish parliamentarian
22:42:11 <fizzie> It almost sounds like a title. Grand Fnord Krarup.
22:42:59 <fungot> CakeProphet: mr president, i am bound by article 11 of the 15 countries. there is one other important point you should bear in mind.
22:43:17 <fungot> CakeProphet: the report proposed to us, at member state level. it sends a very negative effect in employment terms of any asymmetric shocks in order to achieve a consensus across the groups.
22:44:24 <fizzie> I should maybe retrain that thing with VariKN and the latest europarl "v6" release. It goes up to end of 2010 now.
22:44:28 <CakeProphet> No I think asymmetric shock treatment is a good way to build consensus, Mr. fungot
22:44:28 <fungot> CakeProphet: the consultation which our colleague mr cunha's proposal for decoupling male beef but not fnord in my constituency.
22:46:07 <CakeProphet> we never talk about the fnords, Mr. fungot. We will form a committee about the beef.
22:46:14 <oerjan> a most fiendish proposal indeed.
22:46:17 <fizzie> The latest release has 54720731 words.
22:46:37 <oerjan> what kind of fungotry is this
22:46:38 <fizzie> No, there's that thing.
22:46:38 <fungot> oerjan: the enthusiasm with which it has carried out, belarus will be the financial burden the agricultural policy to be based on institutional confusion, which will cause us considerable problems in denmark.
22:46:56 <fizzie> Only four consecutive replies to any one person.
22:47:31 <CakeProphet> agricultural policy of institutional confusion.
22:48:00 <oerjan> agriculture is _big_ in denmark
22:48:22 <Phantom_Hoover> http://en.wikipedia.org/wiki/Homosexuality_in_the_Batman_franchise
22:48:47 <fizzie> Phantom_Hoover: Because it's notable, of course.
22:48:53 <fungot> CakeProphet: mr president, there is a saying that the people of lebanon. for some time now. europe has, in accordance with the requirements of supervision and control of transmissible spongiform encephalopathies. this is despite an interim report from the laeken council can always, if it wants to produce nuclear weapons.
22:49:28 <Phantom_Hoover> europarl looks like it should be funny, but it's boring anyway.
22:49:40 <CakeProphet> [x] -- If x is a kind, [x] is the kind of classes of types of kind x
22:49:51 <oerjan> sure it's boring, until you want to produce nuclear weapons.
22:50:07 <Phantom_Hoover> http://en.wikipedia.org/wiki/LGBT_themes_in_American_mainstream_comics
22:50:11 <fizzie> oerjan: Or transmissible spongiform encephalopathies.
22:50:27 <oerjan> zzo38: i think if you use that notation, you might want [x,y,z] for multiparameter type classes
22:51:01 <Phantom_Hoover> "The episode mentioned the word "boner" several times; in the original comic, it meant "blunder", but to present-day readers it is a double entendre which might make them associate to erection."
22:51:49 <oerjan> he made a boner while erecting this building
22:51:56 -!- CakeProphet has set topic: the requirements of supervision and control of transmissible spongiform encephalopathiesIt is the 90s and there is time for Esolang event @ Hel/Finland on 3.10.2011: https://wiki.helsinki.fi/display/lambda/esoteeriset+ohjelmointikielet | I think pointers are considerably more useful than lambda calculus | 12345678 | http://codu.org/logs/_esoteric/.
22:52:06 <Phantom_Hoover> http://en.wikipedia.org/wiki/Alternative_versions_of_Barbara_Gordon
22:52:11 -!- CakeProphet has set topic: the requirements of supervision and control of transmissible spongiform encephalopathies | It is the 90s and there is time for Esolang event @ Hel/Finland on 3.10.2011: https://wiki.helsinki.fi/display/lambda/esoteeriset+ohjelmointikielet | I think pointers are considerably more useful than lambda calculus | 12345678 | http://codu.org/logs/_esoteric/.
22:52:43 -!- Phantom_Hoover has set topic: It is the 90s and there is time for the requirements of supervision and control of transmissible spongiform encephalopathies, also an Esolang event @ Hel/Finland on 3.10.2011: https://wiki.helsinki.fi/display/lambda/esoteeriset+ohjelmointikielet | I think pointers are considerably more useful than lambda calculus | 12345678 | http://codu.org/logs/_esoteric/.
22:53:13 * oerjan swats CakeProphet -----###
22:53:29 <Phantom_Hoover> No, that would violate our disability discrimination rules.
22:53:46 <Phantom_Hoover> We must show sympathy for the plight of people too lazy to get their number keys fixed.
22:53:54 <oerjan> AAAAAAAAAAAAAAAA thorns!
22:54:25 <fizzie> oerjan: Don't you mean "ÞÞÞÞÞÞÞÞÞÞÞÞÞÞ thorns!"?
22:55:18 <fungot> CakeProphet: mr president, and this is not really an appropriate solution. we can see that there was a boxing ring. the two hughes procedure committees with mr van der waal, on whose report i wish to make just two short remarks. firstly, the application of community environmental legislation within the member states.
22:55:32 <fizzie> Yes, it's really not an appropriate solution. I agree.
22:55:49 <CakeProphet> eruoparl has been quite entertaining. More so than other styles.
22:56:36 <fungot> CakeProphet: mr president, madam president-in-office of the council and parliament a thing of the past. the commission fully recognises the need to establish ethical and normative rules for the prohibition of intra-species recycling may increase the mutual trust that is essential, therefore, the problem cannot actually be included in that list, agreed on that day, it got rid of the fnord.
22:56:37 <fizzie> It does go quite ungrammatiks occasionally. Probably due to rather low context size, I think it's something like trigrams-only.
22:57:11 <CakeProphet> "ethical and normative rules" someone call the redundency commission
22:57:42 <fizzie> Is that when you recycle old fish as birds?
22:57:44 <fungot> Available: agora alice c64 ct darwin discworld europarl* ff7 fisher homestuck ic irc jargon lovecraft nethack pa sms speeches ss wp youtube
22:57:50 <fungot> Selected style: pa (around 1200 transcribed Penny Arcade comics)
22:57:56 <fungot> Phantom_Hoover: i didn't know who else is lost the fucking writers.
22:58:22 <fungot> CakeProphet: we hate animals who are also people. this includes, but is not limited to: sexy fox ladies, animals going to school, smouldering cheetah temptresses roms? something really bad, probably!
22:58:23 <fizzie> Phantom_Hoover: I scraped them off a Penny Arcade wiki or something like that.
22:58:42 <fizzie> That one is rather too fond of direct quotations instead.
22:59:18 <fungot> Selected style: ic (INTERCAL manual)
22:59:23 <fungot> CakeProphet: e345 that's too complex for me to check). anyway, the resulting command line number. that cause the bug. there are still intercal operators left in an input intercal file).
22:59:44 <fizzie> And *that* one lacks adequate cleaning up of the source.
22:59:48 <fungot> Selected style: irc (IRC logs of freenode/#esoteric, freenode/#scheme and ircnet/#douglasadams)
22:59:56 <fungot> CakeProphet: http://www.schemers.org/ documents/ startingwithcl.html. nothing else to put it
22:59:59 <fungot> Selected style: fisher (Fisher corpus of transcribed telephone conversations)
23:00:00 <fizzie> fungot: CAN YOU HEAR ME THIS LINE IS REALLY NOISY?
23:00:00 <fungot> fizzie: ( ( yeah)) the one that's a writer laughter
23:00:15 <fizzie> fungot: Yeah, yeah; but what's a writer-laughter?
23:00:16 <fungot> fizzie: that's great ' cause that game i would do
23:00:39 <fungot> CakeProphet: to be in your shorts and stuff noise like noise noise)) and i think
23:00:41 <fizzie> Also cleanup problems; it has those ((foo)) annotations still in place.
23:01:08 <Phantom_Hoover> quintopia, I WARNED YOU ABOUT STAYING OUT OF MY RSS FEED
23:01:11 <fizzie> I think I need to grep to find the actual source of "to be in your shorts and stuff noise like noise noise"; it sounds like quite a conversation.
23:01:17 <kmc> fungot, http://www.youtube.com/watch?v=7VoOXem0fhc
23:01:18 <fungot> kmc: i don't know how you could ever try that in some ways a traditional person so for me it really does
23:01:42 <Phantom_Hoover> quintopia, although at least both times have been you being stupid and Hughes telling you.
23:01:57 <fungot> Selected style: sms (National University of Singapore SMS corpus, 2011-08-20)
23:02:01 <fungot> Lymee: up to dadar completed. theyare out and only will for little time. should i approach... james for studiow rental too, dat long after i spoke to maneesha v. we'd get together. gbu
23:02:14 <Lymee> fungot, Umm... who's maneesha?
23:02:15 <fungot> Lymee: i want to sent mesages. but u'l get to me babe... i miss u so much?muacks.u enjoy ur day today at ktv. later she buy one not i ask de. she wanna go also. hehe
23:02:33 <fizzie> fungot: You sound like an uneducated boob.
23:02:34 <fungot> fizzie: i was just about to do it when i wake up long lol... dun b angry. msg me b4 u call me... tell me where i could i pick up another 8th) has to leave not long ago, the guy
23:03:10 <CakeProphet> fizzie: someone describing a wet dream over sms?
23:03:29 <Lymee> fungot, did you have a wet dream?
23:03:30 <fungot> Lymee: i am in extreme situations: first- before getting it... second- after loosing it." john also has his own gud n he wil pave d way 4 us by. dun angry
23:03:42 <Lymee> fungot, OK WHO IS JOHN NOW
23:03:42 <fungot> Lymee: ten i owe me a treat. must b sleepy. later got midterm. uh... meeting you haha. hmm... i read up while doing tut now
23:03:49 <Lymee> fungot, Please answer me.
23:03:49 <fungot> Lymee: am i that much bad ass !couldnt u chk ur email. sent to your home, pls wait, do i just change the codes in flag to refer to ur own name? ya i also i since 1pm lo even worse. he's not around or just still asleep. i thought my dad wouldwake me up. last min gt reunion. i juz left house leh... ur thing end already
23:04:03 <fizzie> "(( yeah yeah right yeah it was like it was like as hot as hell yesterday i was walking around in my shorts and stuff [noise] like [noise] [noise] ))"
23:04:36 <Lymee> I think we have a youtube comment generator.
23:04:41 <Lymee> That's better than ^style youtube
23:05:13 <Patashu> Here's my youtube comment generator:
23:05:17 <Patashu> 13 people dislike justin beiber
23:05:35 <Lymee> Syntax error: Unexpected token "People"
23:05:45 <Lymee> Syntax error: Unexpected token "Likes"
23:05:53 <CakeProphet> perl -pie "s/ *[()] */ /g;s/\[noise\]/fnord/g" <-- fizzie
23:06:16 <Lymee> fungot, please generate a Youtube
23:06:16 <fungot> Lymee: k d i vil hav abt colleges ,growin technology,which field of his natural gift frm god... b4 u gt bles frm d first
23:07:34 <fungot> Selected style: youtube (Some YouTube comments)
23:07:34 <Phantom_Hoover> fizzie, wait did you see that Scottish people in a lift video it would be a valuable addition to your research.
23:07:44 <Lymee> Add a style to fungot which uses chain comments.
23:07:50 <fungot> Patashu: i think you never intend to try for a child
23:07:53 <fungot> Patashu: i've been ' refuted' zero times, and are seemingly brainwashed to vote for obama
23:08:25 <Lymee> fungot, make sense
23:08:25 <fungot> Lymee: i think timothy olyphant would have found out they're wrong. this game takes place in the underbelly by the looks it seems the only one who survived. your right
23:08:40 <fizzie> Phantom_Hoover: That description rings a bell, but I can't really recall.
23:08:42 <Lymee> fungot, What no, I don't think you make sense. Stupid bot.
23:08:42 <fungot> Lymee: avril is so terrible!
23:08:47 <fungot> Lymee: huh... and who said you had to go around with shite graphics!... this video is
23:08:58 <fungot> Lymee: 2 words, small testicles. max payne trailer article, read description :) ( maybe i suck at english as u suck
23:10:28 <fungot> CakeProphet: careerbuilder wins in my holidays but i can say
23:11:03 <fungot> Available: agora alice c64 ct darwin discworld europarl ff7 fisher homestuck ic irc jargon lovecraft nethack pa sms speeches ss wp youtube*
23:11:06 <fungot> Selected style: wp (1/256th of all Wikipedia "Talk:" namespace pages)
23:11:16 <fungot> CakeProphet: conservative liberalism is defined as a philosophyphilosophical view. sometimes documented examples are in error or simply lacking broader knowledge. i good example of a language or dialect. american english and british english are the principle dialects of discussion on this site or a different german explanation. fnord 15:06, 2005 mar 20 ( utc)
23:11:42 <fungot> CakeProphet: fnord coverage: jesus and fnord word and the witness" ( 2004)
23:12:26 <fungot> Lymee: to insert a section with a solid paragraph dealing with attacks on israelis, and at least a b article. user:yamarayamara 13:34, 13 may 2007 ( utc)
23:12:31 <Lymee> fungot, [citation needed]
23:12:32 <fungot> Lymee: as it is adjacent to cadboro bay as well even though it is of course possibly to have dissenting views, which don't seem particularly theological to me.
23:12:36 <Lymee> fungot, [citation needed]
23:12:37 <fungot> Lymee: i've put in the nazism article. yet, when i pass the places... problem, about the copyrights: i have put this note here rather than elsewhere: answers.com
23:12:51 <fungot> Selected style: youtube (Some YouTube comments)
23:12:55 <Lymee> fungot, justin bieber
23:12:55 <fungot> Lymee: read the comment. " shift at the end...nice!! unfortunately, a flyby at an airshow in 1988. i know
23:12:58 <Lymee> fungot, justin bieber
23:13:02 <Lymee> fungot, justin bieber
23:13:04 <Lymee> fungot, justin bieber
23:13:12 <fungot> CakeProphet: great job nalts, wow the haters are trolling today. loonywing, he can sing in a short. if that's so, treldman. thanks for speaking for me
23:13:52 <Lymee> fungot, I am NOT a troll!
23:13:52 <fungot> Lymee: the last minute. he was gonna win, nalty? or the pilot and this shit up fast, and see how you are taking it out on little kids on youtube
23:14:02 <Lymee> fungot, no u r the little kid
23:14:02 <fungot> Lymee: the lmao commercial was halarious video on worlds most amasing videos and depositions given. type " airbus sucks" comments included... budweiser ones with the crystal ball on his face! haha
23:14:23 <fungot> CakeProphet: captain asseline was sentenced to 6 months to get over themselves and do some break, but it is
23:14:57 <fungot> Lymee: your mind about that video is shit.... w.t.f lol
23:15:14 <fungot> Lymee: i pissed off. this is not a320, a poorly researched sensationalist us tv-show has caused a crash at the very first good video-game movie. mark walberg is going to land an aircraft crashes.
23:15:25 -!- nys has quit (Quit: movie).
23:22:12 -!- FireFly has quit (Quit: FireFly).
23:50:46 <kmc> @tell fungot hi there
23:50:47 <fungot> kmc: please no tanks or helicopters... no matter what she'll do mhoooooa show it off, it wasn't. holy cow, i never needed lol.
23:50:47 <lambdabot> fungot: You have 1 new message. '/msg lambdabot @messages' to read it.
23:53:01 -!- nooga has quit (Ping timeout: 240 seconds).
23:56:52 <atehwa> oklopol: feel free to add your comments there... or does it requ
23:57:01 <atehwa> ire some kind of registration for that, too?
23:57:31 <CakeProphet> any have any spare money they don't need anymore?