←2011-07-03 2011-07-04 2011-07-05→ ↑2011 ↑all
00:00:15 <oerjan> elliott_: since 32 has so many factors, the gcd rule is likely to cut that down more than 34 which is twice a prime. i think.
00:01:23 <elliott_> oerjan: would it be possible to make some sort of progress report output? :P
00:01:35 <oerjan> probably?
00:02:27 <oerjan> dunno
00:03:32 <elliott_> oerjan: well i could always report progress through the original list passed, right?
00:03:36 <elliott_> that would be rather non-finegrained though
00:04:45 <oerjan> um but those are done in parallel...
00:05:04 <elliott_> oerjan: oh right :D
00:05:54 <elliott_> [[Two things - firstly: "Every time you do any string handling with C's native string types and functions, you need to make sure you have allocated enough memory for each string" - that's right, and experienced C developers write the correct code naturally and without thinking.]]
00:05:55 <elliott_> hehehe
00:06:00 <elliott_> humans are infallible and busywork is good
00:06:49 <oerjan> as i've almost said before, with perfect people everything works, even nazism
00:07:16 <pikhq> oerjan: Even sparks can be destroyed by overhead, but 99% of the time, it "just works".
00:07:44 <pikhq> (those suckers are *really* cheap)
00:08:01 <oerjan> mhm
00:08:22 <zzo38> Understanding probability can help to play at pokemon card!
00:09:01 <elliott_> oerjan: indeed
00:10:01 <elliott_> "That's silly - almost all programs use strings heavily, considering that they're really the most natural way for programs to take input from and produce output for humans."
00:10:09 <elliott_> and that's why everyone uses text UIs, without even colour or cursor control
00:11:11 <zzo38> I am playing CLEFAIRY [Lv15] against DARK CLEFABLE [Lv33] and I think my chance of hitting them is 50%. Their chance of hitting me is probably lower, but I don't know the exact amount. It is not greater than 50% though.
00:12:42 <ais523> Pokémon names aren't officially always-uppercased nowadays
00:12:59 <coppro> zzo38: link?
00:13:00 <coppro> win 4
00:13:02 <ais523> although it's a relatively recent change
00:13:18 <zzo38> coppro: No link, sorry.
00:13:40 <ais523> Bulbapedia has most of the older Pokémon cards, but they're sorted by expansion, rather than zzo38's naming scheme
00:13:42 <zzo38> ais523: I am uppercased the names of all the cards
00:14:07 <zzo38> ais523: Do you know how to play pokemon card?
00:14:12 <ais523> yes
00:14:24 * coppro braces
00:14:28 <zzo38> See if you understand my puzzle games.
00:14:47 <elliott_> Cords are a nice structure; I wonder if they're efficient when implemented purely functionally.
00:14:59 <coppro> yup, there it was
00:15:02 <zzo38> elliott_: Can you try it and figure out?
00:15:06 <ais523> it'll be complicated by the fact that zzo38 likely plays a mix of old rulesets
00:15:16 -!- CakeProphet has quit (Read error: Connection reset by peer).
00:15:19 <elliott_> zzo38: I'm trying to.
00:15:44 <zzo38> http://zzo38computer.cjb.net/textfile/miscellaneous/pokemon_card/puzzle.1
00:15:46 <zzo38> http://zzo38computer.cjb.net/textfile/miscellaneous/pokemon_card/puzzle.2
00:15:51 -!- CakeProphet has joined.
00:15:51 -!- CakeProphet has quit (Changing host).
00:15:51 -!- CakeProphet has joined.
00:16:43 <ais523> ah, DARK CLEFABLE [Lv33] is more commonly called Dark Clefable (Team Rocket's Ambition) or Dark Clefable (GB 2)
00:16:55 <ais523> so that was easy enough to find: http://bulbapedia.bulbagarden.net/wiki/Dark_Clefable_%28GB_2%29
00:17:05 <zzo38> Yes it is the GB 2 version.
00:17:09 <elliott_> newtype Cord a = Leaf ![a]
00:17:09 <elliott_> | Branch !Int !(Maybe (Cord l a)) !(Maybe (Cord l a))
00:17:11 <elliott_> kind of ugly, but oh well
00:17:31 <zzo38> Calling it [Lv33] should still be unambiguous, though. Also, the puzzle games list all the card texts.
00:17:44 <ais523> and hmm, is exclusive to one of the Game Boy games, rather than being an actual physical card
00:18:44 <elliott_> oerjan: still running, btw
00:19:07 <zzo38> Yes it is, although it could be played with physical cards too I think, if the chance os 1/3 for -0, 1/3 for -1, 1/3 for -2, then you can use a dice however, which is not part of the standard game.
00:19:35 <zzo38> (These are also the numbers I used to estimate my probability of hitting)
00:21:12 <oerjan> huh
00:22:10 <oerjan> elliott_: your newtype has some spurious l's
00:22:23 <elliott_> oerjan: indeed, remnants from a previous, more general attempt that I'm delaying
00:22:28 <elliott_> oerjan: ([a] is not a very efficient short-string structure)
00:23:04 <elliott_> "Leaf nodes (as well as some single-child internal nodes) also contain a short string."
00:23:07 <elliott_> i love that unexplained as-well-as
00:23:42 <elliott_> "Seen from another perspective, the binary tree of a rope can be seen as several levels of nodes. The bottom level contains all the nodes that have a short string. Higher levels have fewer and fewer nodes, until finally there is just one root node in the top level. We can build the rope by putting all the nodes with short strings in the bottom level, then randomly picking half those nodes in order to form parent nodes in the next level. Nodes with no p
00:23:42 <elliott_> arent (for example, the two nodes storing the strings "my_" and "me_i" in the diagram above) become the right child of the node located immediately to their left, thus forming a chain. In this way, we can build higher levels one level at a time. We stop when there is only one node remaining."
00:23:43 <elliott_> this is stupid
00:23:51 <elliott_> it's like it's purposefully trying not to be an actual algorithm
00:24:00 <zzo38> The GameBoy computer opponents seem to be bad at defensive play and average at offensive play, and often do stupid things.
00:24:15 <zzo38> ais523: Can you figure out my puzzle games? Can you understand it?
00:24:36 <coppro> zzo38: Referring to cards by level is a bad approach
00:24:46 <coppro> zzo38: The cards are much more well-known by name
00:25:16 <elliott_> oerjan: hmm, looks like finger trees are actually pretty close to this
00:25:20 <zzo38> The card texts of the puzzles are typed on there
00:25:30 <zzo38> And anyways I only know them by level anyways
00:25:38 <elliott_> oerjan: hm but wait
00:25:43 <elliott_> oerjan: finger trees have O(n) indexing, right?
00:25:50 <elliott_> oh, O(log(min(i,n-i))), weird
00:26:00 <elliott_> i guess because it tries from the end too
00:26:03 <elliott_> or something
00:26:05 <ais523> zzo38: I haven't looked at it, I'm watching a Pokémon Blue TAS at the moment
00:26:56 <oerjan> elliott_: finger trees have O(1) indexing at the end, is the major difference i think
00:27:24 <elliott_> oerjan: that's actually quite useful, for strings
00:27:32 <oerjan> yeah
00:27:42 <coppro> a pokemon TAS? oh dear
00:27:56 <elliott_> oerjan: the problem is that you don't want (Seq Char), you want (Seq AboutSixteenOrSoChars)
00:28:00 <elliott_> oerjan: which just complicates every algorithm
00:28:09 <elliott_> sufficiently so that I think reinventing the wheel might be more expedient
00:28:39 <oerjan> elliott_: the O(1) also keeps holding a*ly as you traverse inwards
00:28:55 <elliott_> yes, that is definitely a sentence that makes sense.
00:29:04 <elliott_> good job for making it.
00:29:08 <oerjan> a* is here the word i keep forgetting
00:29:08 <elliott_> i am proud of you.
00:29:21 <zzo38> What is a Pokemon TAS?
00:29:24 <elliott_> oerjan: asymptomatically?
00:29:25 <elliott_> er oh er
00:29:29 <elliott_> a....stigma
00:29:33 <elliott_> apex
00:29:35 <elliott_> aperture
00:29:40 <oerjan> argh :P
00:30:47 <elliott_> i know what you mean :D
00:31:29 <oerjan> good, good
00:31:49 <elliott_> http://hackage.haskell.org/packages/archive/simple-rope/0.1/doc/html/Data-Rope.html ;; TYPE FAMILIES: TOTALLY SIMPLE
00:31:53 <oerjan> anyway, the first 16 chars take 16*O(1) to traverse
00:32:36 <Sgeo> elliott_ hates history
00:32:41 <Sgeo> and historical stuff
00:33:43 <elliott_> oerjan: hmm, http://upload.wikimedia.org/wikipedia/commons/c/c2/Rope_example.jpg confuses me
00:33:51 <elliott_> apart from being tilted for no apparent reason, the lengths of the strings all vary wildly
00:33:59 <elliott_> is it because of inserting "s" somewhere that there's a one-char "s"?
00:34:02 <oerjan> elliott_: one hour
00:34:06 <elliott_> oerjan: :D
00:37:08 <oerjan> and the numbers only apply to the part vertically below ignoring the tilting...
00:38:01 <elliott_> oerjan: I know
00:38:07 <elliott_> oerjan: I just mean, why would all the strings not be equally-sized?
00:38:10 <elliott_> (Or one off from that)
00:38:15 <elliott_> So presumably it isn't a newly-created string, but a modified one
00:38:30 * oerjan doesn't actually know ropes
00:38:48 <oerjan> i think i briefly considered if they were useful for implementing dupdog
00:39:24 <oerjan> ok i guess if there isn't more to them than that, i know them
00:39:36 <zzo38> It is impossible to pull the ropes regardless of the number of your tentacles, I think.
00:40:28 <oerjan> maybe zzo38 is a great old one
00:41:20 <zzo38> Actually I am not one million years old. Nobody lives that long, I think.
00:44:17 -!- ralc has quit (Quit: Leaving).
00:47:24 <elliott_> hmm, I wonder what I should use as the target length of the small strings in a rope
00:47:32 <elliott_> there is probably some obvious answer based on keeping the tree shallow
00:47:34 <elliott_> but I don't know what it is
00:47:43 <elliott_> well, shallow but still... foresty enough
00:50:54 <elliott_> oerjan: still giong
00:50:54 <elliott_> going
00:51:53 <Sgeo> RIP Bonobo Conspiracy
00:52:59 -!- azaq23 has quit (Quit: Leaving.).
00:53:52 * elliott_ was hoping oerjan would answer :D
00:54:01 <elliott_> 4004 elliott 20 0 48740 3984 1260 S 109 0.1 124:00.04 nsearch.optim
00:54:02 <elliott_> two hours
00:55:01 <oerjan> wat
00:55:07 <elliott_> <kmc> only in Haskell would you rotate a list by extending it to be infinitely long and then throwing out most of it ;P
00:55:08 <elliott_> oerjan: ?
00:55:41 * Phantom_Hoover → sleep
00:55:49 -!- Phantom_Hoover has quit (Quit: Leaving).
00:56:15 <oerjan> > let rot n l = take (length l) . drop n $ cycle l in rot 5 "abracadabra"
00:56:16 <lambdabot> "adabraabrac"
00:56:19 <elliott_> LinuxJournal: Is there a world outside of computers?
00:56:19 <elliott_> -- http://www.linuxjournal.com/article/5048
00:56:25 <elliott_> "No."
00:56:39 <oerjan> elliott_: * elliott_ was hoping oerjan would answer :D
00:56:52 <elliott_> oerjan: <elliott_> hmm, I wonder what I should use as the target length of the small strings in a rope
00:56:53 <elliott_> <elliott_> there is probably some obvious answer based on keeping the tree shallow
00:56:53 <elliott_> <elliott_> but I don't know what it is
00:56:53 <elliott_> <elliott_> well, shallow but still... foresty enough
00:57:02 <elliott_> oerjan: also, the reason no haskell compiler does automatic memoisation is because of space leaks, right?
00:57:14 <oerjan> i think so
00:58:52 <elliott_> http://www.reddit.com/r/programming/comments/ifq59/a_regular_expression_matcher_in_30_lines_of_c/c23fz1d?context=3 hey oerjan, tell me whether my response is bullshit or not :P
00:58:55 <elliott_> ;D ;D ;D
01:00:05 -!- jcp has joined.
01:01:39 <oerjan> sounds fair. although i vaguely recall at one time reading that main = putStrLn "hello" >> main
01:01:40 <elliott_> ?hoogle Int -> a -> [[a]]
01:01:40 <lambdabot> Prelude replicate :: Int -> a -> [a]
01:01:40 <lambdabot> Data.List replicate :: Int -> a -> [a]
01:01:40 <lambdabot> Control.Monad replicateM :: Monad m => Int -> m a -> m [a]
01:01:46 <elliott_> ?hoogle Int -> [a] -> [[a]]
01:01:47 <lambdabot> Control.Monad replicateM :: Monad m => Int -> m a -> m [a]
01:01:47 <lambdabot> Prelude drop :: Int -> [a] -> [a]
01:01:47 <lambdabot> Prelude take :: Int -> [a] -> [a]
01:01:49 <elliott_> grr
01:01:52 <oerjan> does leak space
01:02:01 <oerjan> elliott_: how dare you paste in the middle of my broken line
01:02:03 <elliott_> oerjan: hmm, I don't think so
01:02:05 <elliott_> main is shared, after all
01:02:13 <elliott_> anyway, it won't blow the stack
01:02:14 <oerjan> elliott_: er, *did leak space
01:02:16 <elliott_> even if it does eat all your ram
01:02:18 <elliott_> at
01:02:19 <elliott_> [asterisk]ah
01:02:31 <oerjan> this was in some ancient version
01:03:02 <oerjan> elliott_: what do you want for that ?hoogle function?
01:03:20 <elliott_> oerjan: group into lists of length N
01:03:32 <elliott_> "abcdefgh" grouped by three -> ["abc","def","gh"]
01:03:35 <elliott_> :t chunks
01:03:36 <oerjan> elliott_: Data.Split, i think
01:03:36 <elliott_> :t chunk
01:03:36 <lambdabot> Not in scope: `chunks'
01:03:37 <lambdabot> Not in scope: `chunk'
01:03:40 <elliott_> oerjan: yeah :(
01:03:53 <oerjan> not in standard libraries
01:04:58 <oerjan> > takeWhile (not.null) . map(take 3) . iterate(drop 3) $ "abcdefgh"
01:04:59 <lambdabot> ["abc","def","gh"]
01:09:49 -!- Sgeo has quit (Ping timeout: 255 seconds).
01:10:33 -!- Sgeo has joined.
01:11:30 <elliott_> algorithms suck
01:13:58 <elliott_> ?pl \d -> f d . g
01:13:58 <lambdabot> (. g) . f
01:15:10 <elliott_> http://hackage.haskell.org/packages/archive/ListLike/3.1.1/doc/html/Data-ListLike.html#t:ListLike ugliest typeclass
01:15:28 <pikhq> elliott_: Should I feel bad for having made sabotage build dynamically?
01:15:34 <elliott_> pikhq: yes
01:15:40 -!- Sgeo has quit (Ping timeout: 255 seconds).
01:15:49 <pikhq> Well, that was straightforward.
01:15:56 <elliott_> oerjan: still going, btw
01:16:42 <pikhq> elliott_: It also seems to have cut the size of X11 by 95%.
01:17:59 <zzo38> Does the Linux kernel have support for error emulation?
01:19:48 -!- jcp|other has joined.
01:19:55 -!- jcp|other has quit (Read error: Connection reset by peer).
01:20:14 -!- jcp|other has joined.
01:23:48 -!- Sgeo has joined.
01:26:58 -!- CakeProphet has quit (Ping timeout: 260 seconds).
01:33:04 <elliott_> oerjan: COUGH COUGH
01:33:07 <oerjan> eek
01:33:12 <oerjan> TWO HOURS
01:33:32 <elliott_> oerjan: that was actually to answer my implicit question IN RETURN FOR ALL MY CPU TIME
01:33:32 <oerjan> also you beat me by seconds there
01:33:44 <elliott_> <elliott_> oerjan: <elliott_> hmm, I wonder what I should use as the target length of the small strings in a rope
01:33:44 <elliott_> <elliott_> <elliott_> there is probably some obvious answer based on keeping the tree shallow
01:33:44 <elliott_> <elliott_> <elliott_> but I don't know what it is
01:33:44 <elliott_> <elliott_> <elliott_> well, shallow but still... foresty enough
01:33:44 <oerjan> oh hm
01:34:01 <oerjan> i think i can say with some confidence that i dunno
01:34:06 <elliott_> I dunno whether you want it to be some fraction of the total initial string length or some constant :D
01:34:08 <elliott_> oerjan: >:(
01:34:29 <oerjan> elliott_: square root or logarithm perhaps?
01:34:40 <oerjan> hm but you want a lower limit too
01:34:44 <elliott_> yes, let's just throw random functions at the problem :D
01:34:58 <oerjan> RANDOM, THAT'S IT!
01:35:11 <oerjan> gaussian, to be precise
01:35:21 <elliott_> oerjan: :D
01:35:25 <elliott_> you are joking right
01:35:40 <elliott_> defaultChunkSize :: Int
01:35:40 <elliott_> defaultChunkSize = 64
01:35:40 <elliott_> pack :: (StringLike a) => Int -> a -> Rope a
01:35:40 <elliott_> pack cs s | size s < 2*cs = Leaf cs s
01:35:40 <elliott_> | otherwise = let (a,b) = splitAt cs s in pack cs a <> pack cs b
01:35:42 <elliott_> HMMMMMMMmmmmmmmmmmmmmmmmmm
01:35:47 <oerjan> _finally_ elliott_ is getting a clue
01:35:53 <elliott_> :(
01:36:31 <elliott_> -- | O(n) Convert a list of 'Word8' into a 'Rope'
01:36:32 <elliott_> pack::[Word8]->Rope
01:36:32 <elliott_> pack s=
01:36:32 <elliott_> if Prelude.length s<=leafSize then unsafePerformIO $ do
01:36:32 <elliott_> contents<-mallocForeignPtrArray leafSize
01:36:34 <elliott_> i0<-mallocForeignPtr
01:36:36 <elliott_> withForeignPtr i0 $ \i->poke i $ Prelude.length s
01:36:38 <elliott_> withForeignPtr contents $ \c->fillPtr c s
01:36:40 <elliott_> return $ String { contents, i0, offset=0, length_=Prelude.length s }
01:36:42 <elliott_> else
01:36:44 <elliott_> let (a,b)=Prelude.splitAt leafSize s in
01:36:46 <elliott_> append (pack a) (pack b)
01:36:48 <elliott_> where
01:36:50 <elliott_> fillPtr::Storable a=>Ptr a->[a]->IO ()
01:36:52 <elliott_> fillPtr _ []=return ()
01:36:54 <elliott_> fillPtr ptr (h:t)=do
01:36:56 <elliott_> poke ptr h
01:36:58 <elliott_> fillPtr (plusPtr ptr 1) t
01:37:00 <elliott_> cool
01:37:04 <elliott_> \end{code} Il n'est pas clair qu'on ne puisse pas faire beaucoup mieux que ce pack. Par exemple, vu qu'on calcule la taille de la liste, on pourrait sortir un arbre directement \'equilibr\'e. Vu qu'on ne fait jamais pack avec des 'ByteString's (sauf ghc quand il compile des IsString), \c ca ne vaut sans doute pas le co\^ut. Par contre, append est utilise presque partout. Il est crucial que son implementation soit extremement efficace. \begin{code}
01:37:09 <elliott_> cool
01:37:11 <elliott_> ok its leaf size is 65,536
01:37:13 <elliott_> so the ideal chunk size is between 64 and 65536
01:37:15 <elliott_> :D
01:39:56 <oerjan> wait this is the kind of "you need no know cache" stuff, isn't it.
01:40:01 <oerjan> *to know
01:40:27 <elliott_> oerjan: i'm not sure :D
01:40:32 <elliott_> HEY VOOOOORPAAAAAAAAAL
01:40:35 <elliott_> HEY GREEEEEGOOOOOOOOOR
01:41:33 <Sgeo> Newspaper works as a mousepad!
01:41:41 <elliott_> Sgeo: Warren considers my ardent anti-historism beautiful.
01:43:31 <Sgeo> lol
01:43:52 <elliott_> oerjan: 208:18.92 nsearch.optim
01:46:22 <oerjan> are you _sure_ you didn't accidentally write 43 or something
01:51:02 <elliott_> main = print (nsearch 34 1 0 [1..33])
01:51:34 <elliott_> oerjan: heh, fromList is a painful function to write :(
01:51:42 <elliott_> because just getting a list of chunks isn't enough, i have to all spindly them down into a tree
01:51:43 <elliott_> im lazy
01:55:02 -!- Lymia has changed nick to Lymee.
01:56:19 <oerjan> :t Node
01:56:20 <lambdabot> forall a. a -> Forest a -> Tree a
01:57:11 <elliott_> oerjan: what of it
01:57:52 <oerjan> :t Leaf
01:57:52 <lambdabot> Not in scope: data constructor `Leaf'
01:58:14 <oerjan> > return True :: Tree Bool
01:58:15 <lambdabot> Node {rootLabel = True, subForest = []}
01:58:27 <oerjan> aha
02:00:44 <oerjan> hm that's annoying
02:01:06 <elliott_> 234:22.89 i give up
02:01:14 <elliott_> $ time ./nsearch.optim +RTS -N
02:01:14 <elliott_> ^C
02:01:14 <elliott_> real146m53.288s
02:01:14 <elliott_> user208m42.860s
02:01:14 <elliott_> sys25m50.830s
02:01:15 <oerjan> NOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
02:01:23 <elliott_> two seconds later: OMG ITS FOUND
02:01:48 <oerjan> > undefined :: [Int]
02:01:49 <lambdabot> *Exception: Prelude.undefined
02:02:02 <oerjan> why doesn't it print the initial [, anyway
02:02:23 <elliott_> for undefined
02:02:29 <oerjan> yeah
02:02:29 <elliott_> [undefined] would produce [<exception>
02:02:43 <oerjan> well sure
02:02:51 <oerjan> > [undefined] :: [Int]
02:02:51 <lambdabot> [*Exception: Prelude.undefined
02:03:01 <oerjan> but even without the brackets
02:03:26 <oerjan> > undefined :: String
02:03:27 <lambdabot> "*Exception: Prelude.undefined
02:03:44 <elliott_> hm
02:03:57 <oerjan> that's the reason why fix show works
02:04:26 <monqy> > fix show
02:04:27 <lambdabot> "\"\\\"\\\\\\\"\\\\\\\\\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"\\\\\\\\\\\\...
02:06:01 <oerjan> :t var
02:06:02 <lambdabot> forall a. String -> Sym a
02:06:30 <oerjan> > fix (return.var.show) :: [Sym ()]
02:06:31 <lambdabot> [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[...
02:10:19 <oerjan> > fix (return.var.show) :: Maybe (Sym ())
02:10:21 <lambdabot> Just Just Just Just Just Just Just Just Just Just Just Just Just Just Just ...
02:10:43 <oerjan> hm
02:11:00 <oerjan> > Just (Just (Just True))
02:11:00 <lambdabot> Just (Just (Just True))
02:16:05 -!- pikhq_ has joined.
02:16:09 -!- pikhq has quit (Ping timeout: 240 seconds).
02:16:16 <oerjan> elliott_: have you tried timing the parallel one for smaller values? that was some leap from 32 to 34...
02:16:37 <elliott_> yes i tried thirty
02:16:50 <oerjan> how long did that take?
02:19:53 -!- copumpkin has joined.
02:19:53 -!- copumpkin has quit (Changing host).
02:19:53 -!- copumpkin has joined.
02:20:39 <oerjan> <elliott_> realI1m31.738s
02:20:45 <oerjan> was that for 30?
02:20:52 <elliott_> yes
02:21:25 -!- copumpkin has quit (Client Quit).
02:21:31 <oerjan> that's more than 100 times up to when you stopped 34 :(
02:21:44 <oerjan> er, *almost
02:21:54 <elliott_> its obviously massively exponential
02:21:55 <elliott_> or worse
02:22:03 <oerjan> perhaps factorial
02:22:32 <oerjan> or rather, i cannot see how it could be _more_ than factorial. well maybe some of the large artithmetic on n.
02:22:44 <oerjan> *-t
02:23:22 <ais523> wow, Slashdot has given me a total of 30 moderator points in a week
02:23:36 <oerjan> well you are a very moderate guy
02:24:52 <ais523> according to the FAQ, it implies I'm in the top percentile of moderators, or something like that
02:25:16 <ais523> (moderator selection is random, but apparently when you're selected, you get to do more moderation if the metamoderators think you've been doing well)
02:25:18 <coppro> I mostly read via rss now
02:25:28 <ais523> as far as I can tell, it just means most Slashdotters are really biased
02:25:38 <ais523> and I read Slashdot for the comments
02:26:58 <zzo38> I have sometimes read the comments on Slashdot, too.
02:26:59 <zzo38> Are you able to read pokemon card puzzle by now?
02:27:06 <ais523> ah, I forgot about it
02:27:11 <ais523> let me look
02:27:45 <ais523> I don't understand your notation for energy
02:28:08 <ais523> does @ mean purple/psychic energy?
02:28:13 <ais523> and if so, what is %?
02:28:57 <zzo38> ais523: What part are you having trouble with about the energy? Yes, @ means purple/psychic energy although you can still solve it without that information (all the card texts use the same notation too, in that file). % means leaf energy (green)
02:28:57 <ais523> also, how many Prizes does each player have? are they called something else?
02:29:10 <zzo38> "Side cards remaining".
02:29:54 <zzo38> Also called Prizes also the name "side cards" is also used sometimes, and that is what I am using there.
02:29:58 <ais523> and numbers on their own in Pokémon descriptions are damages in multiples of 10?
02:30:06 <zzo38> Yes.
02:30:23 -!- copumpkin has joined.
02:32:30 <zzo38> What is called ten damage is called 1 here; it is more logical.
02:32:32 <ais523> you need to point out that the opponent has at least one card in draw pile
02:32:43 <ais523> otherwise you can win by passing the turn :)
02:32:52 <ais523> you have [irrelevant] there atm
02:36:10 <zzo38> I don't think it is necessary but OK I will change that
02:37:50 <zzo38> I fixed it.
02:38:12 -!- zzo38 has quit (Quit: Unfortunately I have to leave now, sorry).
02:40:18 <ais523> I'm not convinced the first puzzle is possible; there seems to be no way to get a draw from the deck other than itemfindering Bill in any of the cards there, and if you do that, you have no way to refill your deck with Nightly Garbage Run
02:40:28 <ais523> other than that, it's reasonably obvious what you have to do
02:41:45 <coppro> ais523: it's not possible according to modern rules
02:42:06 <coppro> it /may/ have been possible according to older rules, although I don't recall them well enough
02:42:20 <coppro> in any case, I'd forgotten the rule that makes it impossible
02:42:21 <ais523> coppro: under zzo38's ruleset, weakness is almost certainly *2 damage rather than a fixed bonus amount of damage like it is nowadays
02:42:56 <ais523> I'm assuming you're meant to hit a weakness (using goop gas attack) in order to deal 60 damage to get one prize, and 10 to a benched to get the other
02:43:30 <ais523> oh, you can just itemfinder for goop gas attack and ignore all the other cards in the discard
02:44:28 <ais523> move a counter from dark muk to porygon, retreat Gengar for Spearow, GoW Dark Muk, retreat Spearow for Hypno, itemfinder for Goop Gas Attack, play it, then hit for 60+10 benched damage for the double KO
02:44:45 <ais523> normally it's bad style to write a puzzle that has that much irrelevant stuff in...
02:46:00 <coppro> ais523: I cannot find any evidence to support your assertion that weakness is not *2 damage nowadays, and that is the correct solution although it's illegal under modern rules as you can only retreat once per turn
02:46:10 <coppro> note that I define 'modern rules' as 'the rulebook on the website'
02:46:15 <ais523> you can only retreat once per turn nowadays?
02:46:19 <ais523> I stopped playing before that was introduced
02:46:33 <ais523> and nowadays, weakness is printed on the cards; it's sometimes *2, but more commonly +20 or +30
02:46:43 <coppro> ah ok
02:46:57 <ais523> whereas in the first few sets, weakness was always printed as *2, making it look like a rules reminder rather than actually necessary
02:47:03 <coppro> quick scan shows that most recent expansion is almost always *2
02:48:31 <coppro> although it appears to be relatively simple cards generally
02:48:35 <ais523> hmm, so it's changed again?
02:48:44 <ais523> as I said, I'm a little out of the loop
02:48:53 <ais523> I play the videogames competitively, but not the cards
02:48:59 <coppro> ah ok
02:49:13 <ais523> the videogames are much cheaper, a sort of one-off £40 or so for each version, and they come out once every few years
02:49:25 <coppro> right
02:49:38 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
02:49:53 <coppro> I suspect that the TCG adopts a similar approach to Magic of making on expansion a year much simpler
02:50:19 <coppro> although it looks like they've been revising the rules a lot too
02:50:25 <ais523> Magic's reason is also because there are a lot of boring cards that are nonetheless necessary to round out decks
02:50:37 <ais523> and yes, I coincidentally quit Magic at the time of the latest big rules change
02:50:59 <ais523> not because of the rules change itself (although I don't really see the point of some of the more controversial changes, and think they're mostly negative), but because I disliked the sets that they'd been making
02:51:25 <coppro> The core sets were never really about printing utility cards
02:51:48 <coppro> They need to be in every set since otherwise the limited format would be impossible to play
02:52:08 <coppro> The new core set model is very awesome
02:52:16 <ais523> yep
02:52:31 <ais523> but it was the difference between core sets using basic utility cards everyone gets, and expansion sets having quirky ones
02:52:57 <ais523> and often the basic ones were a better fit if you weren't going heavily themed
02:59:14 <coppro> It appears that the Pokemon TCG has redone supporters and stadia again; now they are subtypes of Trainer
02:59:48 <ais523> supporters were always subtypes of trainer, weren't they?
02:59:51 <ais523> just with a 1/turn restriction?
03:00:16 <coppro> yeah
03:00:23 <coppro> except for a while when they were a card type
03:00:42 <coppro> but they were originall cobbled on with annoyingly-present reminder text
03:00:58 <ais523> the reminder text was needed
03:01:07 <coppro> the new Trainer template has room for Item/Supporter/Stadium in the top-right corner and has a nice box at the bottom for the reminder text
03:01:12 <ais523> because people kept trying to bring them to people using only old-style cards, when they first came out
03:01:49 <ais523> the invention of supporters was needed, anyway; under the original rules, there was never a reason not to play 4x Bill and 4x Professor Oak
03:01:56 <coppro> yeah
03:02:10 <coppro> definitely agree there
03:02:43 <ais523> (bill was completly safe, professor oak was a gamble but one that had incredibly good return)
03:02:47 <coppro> there's now also basic metal and dark energy, but without the special effects
03:02:53 <ais523> that was needed too, I think
03:03:02 <coppro> Just wait until your hand is low, then play Oak
03:03:14 <ais523> coppro: I mean, you might draw Oak at a time when it isn't useful
03:03:23 <ais523> worst case is getting two Oaks from Bill
03:03:27 <coppro> suppose
03:03:34 <coppro> but then you just play one and the problem goes away
03:03:46 <ais523> yep, it's just a waste more than anything else
03:03:50 <ais523> it's a very good worst case :)
03:09:11 -!- copumpkin has joined.
03:09:11 -!- copumpkin has quit (Changing host).
03:09:11 -!- copumpkin has joined.
03:21:33 -!- jcp|1 has joined.
03:21:54 -!- jcp has quit (Ping timeout: 258 seconds).
03:23:28 -!- jcp|other has quit (Ping timeout: 255 seconds).
03:27:19 -!- jcp|other has joined.
03:29:25 -!- jcp|1 has quit (Ping timeout: 264 seconds).
03:29:27 -!- TeruFSX has quit (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.).
03:29:34 -!- jcp has joined.
03:29:41 -!- BeholdMyGlory has quit (Remote host closed the connection).
03:38:08 -!- pikhq has joined.
03:41:10 -!- pikhq_ has quit (Ping timeout: 244 seconds).
03:41:51 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
03:45:40 <elliott_> hi
03:53:39 -!- quintopia has quit (Ping timeout: 250 seconds).
03:55:38 -!- jcp|1 has joined.
03:56:19 -!- jcp has quit (Ping timeout: 255 seconds).
03:56:58 -!- jcp|other has quit (Ping timeout: 258 seconds).
03:58:58 -!- zzo38 has joined.
03:59:35 -!- quintopia has joined.
03:59:41 <zzo38> If it says "irrelevant" it means those cards are not important for the puzzle.
04:00:03 <zzo38> ais523: Did you figure it out?
04:03:32 <ais523> <ais523> move a counter from dark muk to porygon, retreat Gengar for Spearow, GoW Dark Muk, retreat Spearow for Hypno, itemfinder for Goop Gas Attack, play it, then hit for 60+10 benched damage for the double KO
04:04:02 <ais523> there were a lot of things shown in that puzzle that weren't necessary, though
04:04:05 -!- jcp has joined.
04:04:10 <ais523> as in, you only need to involve half the things on the field
04:30:30 <coppro> yeah
04:30:51 <coppro> I'd say card game puzzles should not include irrelevant game state
04:31:34 <elliott_> purely functional card g- oh wait that's this year's ICFP
04:34:59 <monqy> no it isnt
04:35:12 <elliott_> isn't it
04:35:13 <monqy> doesn't that game have so much state
04:35:14 <monqy> it's crazy
04:35:20 <elliott_> well every game has state :P
04:35:24 <elliott_> but it's manipulated with pure functions
04:35:29 <elliott_> which are the things stored
04:37:30 -!- myndzi\ has quit.
04:55:16 -!- hagb[4]rd has quit (Ping timeout: 255 seconds).
05:24:57 <zzo38> I included some irrelevant thing I think it should sometimes contain some. Even in chess puzzle they sometimes do. But in tsume shogi they usually do not contain irrelevant things.
05:25:19 -!- myndzi has joined.
05:25:56 <elliott_> hmm, I was going to code something
05:26:00 <elliott_> ah, probably a nice esointerpreter
05:26:05 <zzo38> ais523: You did it good. Now try second one too.
05:26:28 <elliott_> oh, but then suddenly most esolangs are bad? :(
05:27:01 <zzo38> elliott_: Please do code something. Code everything.
05:27:07 <elliott_> i can't code all the things.
05:27:10 * pikhq wonders how easy would it be to get GHC working with musl.
05:27:10 <elliott_> there would be nothing left to not code.
05:27:19 <elliott_> pikhq: it works on windows, so ... trivial?
05:27:26 <elliott_> well
05:27:27 <elliott_> cygwin
05:27:29 <elliott_> well
05:27:30 <zzo38> ais523: Do you know how to make up another pokemon card puzzle, too? I would like to see.
05:27:30 <elliott_> not cygwin
05:27:31 <elliott_> but
05:27:31 <elliott_> uh
05:27:33 <monqy> is zepto good is zepto esolangs
05:27:33 <elliott_> point is it works with newlib
05:27:37 <monqy> is zepto interpreter
05:27:39 <elliott_> monqy: zepto is so fucking good, you have no idea.
05:27:45 <elliott_> it's the most gooderest.
05:27:51 <elliott_> im crying over how good zepto is.
05:27:57 <elliott_> this is the saddest day of my life.
05:27:58 <pikhq> elliott_: Okay, then it'd more just be the pain of building it at all.
05:28:09 <zzo38> zepto?
05:28:12 <monqy> ill never be as good as zepto
05:28:15 <elliott_> zzo38: zepto
05:28:17 <elliott_> monqy: kill yourself
05:28:35 <elliott_> http://killyourself.org/ "killyourself.org - All about the Consideration to Kill Yourself"
05:28:38 <pikhq> zzo38: zepto is that property which most software lacks.
05:28:41 <elliott_> "in suck as hell..!!!!! kill your self if u play like this..!"
05:28:45 <elliott_> this is a good site
05:29:21 <zzo38> Zepto- (symbol z) is a prefix in the metric system
05:29:36 <elliott_> HOW TO KILL YOUR SELF ON BIG DIRT BIKE
05:29:36 <elliott_> THE MAD SAILORS HAVE CHANGED FROM WATER TO WHEELS. WHAT NEXT
05:30:09 <elliott_> Just came accross the following post on care2.com – Female Veterans More Likely To Commit Suicide and wanted to share it here with you on killyourself.org ...
05:30:18 <elliott_> zzo38: yes
05:30:23 <elliott_> zzo38: it's also an adjective, and also an adverb
05:30:25 <elliott_> example,
05:30:32 <elliott_> oh it is also a verb and a noun
05:30:33 <elliott_> so
05:30:43 <elliott_> i zepto zepto with my zepto zepto. it was zepto.
05:30:50 <monqy> zepto
05:30:55 <elliott_> it can also replace other words if you want e.g.
05:31:05 <elliott_> zepto zepto zepto zepto zepto zepto zepto. it zepto zepto.
05:31:09 <monqy> zepto
05:31:12 <elliott_> this makes thinking easier.
05:31:41 <oerjan> there is no true or false. there is only zepto
05:31:49 <elliott_> exactly.
05:31:55 <elliott_> the boolean type in zepto has one value
05:31:56 <elliott_> zepto
05:32:31 <oerjan> "One zeptomole (zmol) of substance contains 602 particles."
05:32:59 <elliott_> yes. this is why integers literals in zepto are base 602
05:33:34 <elliott_> hmm
05:33:37 <elliott_> now i gotsa implement zepto
05:33:42 <elliott_> but do i do it in C or Haskell
05:33:45 <elliott_> obviously Final Zepto must be in C
05:33:49 <elliott_> but this it not Final Zepto, oh no
05:33:58 <oerjan> no, final zepto must be in zepto, duh
05:34:06 <elliott_> this is but a meandering zepto on the zepto path to the one true zepto zepto which zepto zepto, and thus becometh the final zepto.
05:34:11 <zzo38> Now I am confused of it.
05:34:22 <elliott_> zzo38: me too. tip: try and not understand it and instead zepto.
05:34:29 <elliott_> oerjan: ah. you would think. but a failed bootstrapping is not very zepto.
05:34:43 <elliott_> and if you lose the binary, as zepto people are wont to do, then that would make it a very un-zepto situation.
05:34:55 <elliott_> also, compilers are un-zepto, so that's just too recursive for the universe to handle.
05:35:02 <monqy> zepto in haskell, then make a zepto program to generate the final zepto
05:35:02 <elliott_> although that, in itself, is very zepto, we are unfortunately constrained.
05:35:05 <elliott_> we cannot achieve true zepto.
05:35:05 <zzo38> elliott: OK. But are you going to write in esolang wiki or what else? How can you do?
05:35:08 <elliott_> we can only achieve universal zepto.
05:35:14 <elliott_> zzo38: i think it might get deleted as spam :D
05:35:51 <oerjan> elliott_: well there's only one final solution then, we must ki^W implement hardware zepto.
05:36:05 <zzo38> Then post it in your own computer
05:36:20 <pikhq> AAAAGH
05:36:26 <pikhq> GHC's autoconf.
05:36:30 <pikhq> BEAT BEAT BEAT
05:36:39 <elliott_> oerjan: yes we must ki^W implement it.
05:36:40 <pikhq> Thou shalt not ignore CC
05:36:48 <pikhq> Thou shalt not override CC.
05:37:07 <zzo38> Zepto is the property most software lacks. Then should you say all software lacks it?
05:37:08 <pikhq> I shall feel compelled to beat you.
05:38:18 <pikhq> It is using autoconf and somehow making it ignore CC.
05:38:33 <pikhq> That is impressive and I feel compelled to murder those responsible.
05:38:47 <elliott_> zzo38: No; zepto is zepto.
05:39:01 <elliott_> In fact if you have zepto on your system, there is very little reason not to just delete all the other software on it.
05:40:20 <zzo38> elliott_: Same thing.
05:41:05 <elliott_> zzo38: As to what?
05:41:40 <zzo38> elliott_: As to zepto.
05:41:42 <pikhq> "--with-gcc"
05:41:43 <pikhq> MURDER
05:41:53 <pikhq> MURDER SAYS I
05:42:19 <coppro> pikhq: wtf
05:42:26 -!- Sgeo_ has joined.
05:42:46 <elliott_> zzo38: As zepto to.
05:42:50 <zzo38> Can you make up any new pokemon card puzzles? I would like to see it, too.
05:42:55 <pikhq> coppro: It seems that most compilers supporting normal, cross, and Canadian cross builds using autoconf fuck it up.
05:42:57 <zzo38> elliott_: .
05:43:04 <elliott_> zzo38: To what zepto is?
05:43:10 <zzo38> elliott_: ..
05:43:17 <oerjan> pikhq: maybe it's a leftover from the evil mangler age
05:43:31 <pikhq> PCC and CINTERCAL are the only ones that seem to do it right that I know of.
05:43:41 <pikhq> (TCC also does it right, but it doesn't use autoconf.)
05:44:20 <pikhq> ghc-cabal: Bad header file: HsBase.h
05:44:20 <pikhq> The header file contains a compile error. You can re-run configure with the
05:44:20 <pikhq> verbosity flag -v3 to see the error messages from the C compiler.
05:44:31 <pikhq> I... Blimble... What the... Fuuuck?
05:44:46 -!- Sgeo has quit (Ping timeout: 255 seconds).
05:45:39 -!- elliott_ has quit (Read error: Connection reset by peer).
05:45:51 -!- elliott has joined.
05:45:59 <elliott> monqy: would you like the greatest privilege
05:46:08 <monqy> is it zepto
05:46:15 <monqy> i like zpto
05:46:17 <monqy> e
05:46:19 <elliott> monqy: yes
05:46:20 * pikhq sees if that fails without --with-gcc=musl-gcc...
05:46:41 <pikhq> If not, then I suppose I'll have to bother building a proper cross compiler.
05:46:49 <elliott> monqy: you could have a part in the designing of the initial zepto revision/derivative/variant/exoskeleton, ante-zepto
05:46:51 <elliott> YES
05:46:53 <elliott> YOU
05:46:54 <pikhq> Aside from PCC, that is.
05:46:57 <elliott> YOU ARE _SO_ _LUCKY_
05:47:31 <monqy> zeptoskeleton
05:47:37 <elliott> yes.
05:47:40 <oerjan> zeptoplasma
05:47:40 <monqy> whats my part
05:47:50 <elliott> monqy: moral support. also, implementation details.
05:47:55 <elliott> also, design.
05:47:58 <elliott> also, zepto.
05:47:59 <elliott> zepto.
05:48:02 <monqy> sounds zepto
05:48:18 <oerjan> you may also have to provide a few inessential vital organs.
05:48:22 <pikhq> Meeeh, fuck GHC.
05:48:26 <elliott> pikhq: try jhc
05:48:29 <elliott> it will be teh hots
05:48:59 <elliott> monqy: also you get to supply bignum algorithms that i'm too lazy to write, or maybe i could just be really really un-zepto
05:49:00 <elliott> and make it
05:49:01 <elliott> not have bignums
05:49:11 <elliott> yes, that means that + would fail for no reason and you would have to be all oh :(
05:49:12 <elliott> and fix it and oh
05:49:13 <elliott> and
05:49:14 <elliott> yeah
05:49:19 <monqy> whats bignums whats algorithms
05:49:24 <elliott> zepto
05:49:35 <pikhq> Strange, it seems to be missing some Haskell dependencies.
05:49:41 <pikhq> I have the effing Platform.
05:49:53 <elliott> haskell platform: literally contains every haskell library
05:49:55 <monqy> somehow i've never learned how to implement bignums
05:50:17 <elliott> prim
05:50:17 <elliott> cons
05:50:18 <elliott> intg
05:50:18 <elliott> symb
05:50:21 <elliott> what other types do we need monqy
05:50:33 <pikhq> Hmm, it actually doesn't have readline.
05:50:43 <oerjan> elliott: padic
05:50:49 <monqy> padic is not four letters
05:50:56 <oerjan> darn
05:50:57 <elliott> oerjan: whats padic
05:51:04 <oerjan> p-adic numbers
05:51:31 <elliott> p-adic numbers are nice they make me smile
05:51:34 <elliott> i want to hug them
05:51:41 <elliott> //hugs p-adic numbers//
05:52:17 <monqy> are characters zepto so long as there is no worry about messy things like encoding
05:52:39 <elliott> monqy: you just use symbols
05:52:46 <elliott> symbols are words, strings are words, what is the difference
05:52:57 <monqy> i guess this works
05:53:00 <elliott> i GUESS there can be a function to get the nth codepoint in a symbol as an integer
05:53:19 <elliott> anyway we don't need non-primitive functions of course
05:53:28 <elliott> we just define the application of e.g. ((x) x) instead
05:55:55 <elliott> monqy: oh yeah previously zepto was dynamically scoped but I guess it can be lexical now???
05:56:27 <monqy> all i remember about zepto is i had no idea what was going on
05:57:13 <elliott> (def lambda '(e fn '(e* arr . (apply e fn (eval arr e*)))))
05:57:13 <elliott> hmm
05:57:40 <elliott> pikhq: oh right jhc requires a haskell compiler
05:57:42 <elliott> pikhq: try hugs :P
05:58:46 <pikhq> Y'know what? Haskell is insufficiently sane. :P
05:59:23 <pikhq> Thus far, there has been only one language implementation that has "just worked" with musl.
05:59:26 <pikhq> Tcl.
05:59:37 <coppro> :(
05:59:41 <pikhq> ./configure&&make&&make install
06:00:13 <pikhq> ... Of course, this is a language that only recently dropped its support for the PocketPC and the Palm Pilot.
06:00:30 <elliott> pikhq: tried hugs yet
06:00:35 <pikhq> elliott: Not yet.
06:01:01 <monqy> are any languages sufficiently sane
06:01:06 <pikhq> monqy: Not really.
06:01:31 <elliott> petzo
06:01:33 <monqy> my experience as well; I was hoping for a different answer :(
06:01:41 <pikhq> Okay, well, I suppose that PCC was relatively sane...
06:01:53 <pikhq> Only had to futz with config.sub and the path to the dynamic linker.
06:01:57 * Lymee hugs elliott
06:02:02 * Lymee hugs pikhq too
06:02:12 <pikhq> elliott: Guess what doesn't work?
06:02:26 <pikhq> It seems to be assuming glibc overincluding.
06:02:41 <elliott> monqy: hmm oh quote is not the same thing as lambda if I make things lexically scoped
06:02:54 <pikhq> ... I... And... Defuck?
06:03:27 <elliott> we need a vau s.t. (vau args . fn) in environment e === (cons (cons e args) fn)
06:03:28 <oerjan> no defuck. or phantom_hoover will massacre you.
06:03:33 <elliott> i.e.
06:03:35 <monqy> mm vau
06:03:44 <pikhq> *siiiigh*
06:03:54 <elliott> (vau x . x) ==> ((<environment> . x) . x)
06:03:55 <pikhq> IT'S TIME.H NOT SYS/TIME.H
06:03:59 <oerjan> elliott: wait are you basing this on that vau idea?
06:04:00 <elliott> where <environment> is an environment object
06:04:02 <elliott> so I guess,
06:04:06 <oerjan> or wait
06:04:14 <elliott> oerjan: well yes, it is basically fexpr construction
06:04:25 <elliott> oerjan: and if one represents lambdas as lists, and wants lexical scoping, then you need to include the environment in
06:04:32 <elliott> so vau basically becomes a convenience
06:05:05 <elliott> oh hm wait
06:05:10 <elliott> it needs to take the environment as an operator too
06:05:36 <elliott> (vau env args . fn) in environment e === (list e env args . fn)
06:05:46 <elliott> meh,
06:05:50 <elliott> so hmm
06:06:07 <elliott> (vau e x (eval e x)) ==> (<environment> e x (eval e x))
06:06:16 <elliott> right
06:06:17 <elliott> I think
06:06:19 <elliott> dflgjdfgk
06:06:23 <elliott> monqy: this is becoming unzepto :(
06:06:28 <monqy> :(
06:07:51 <elliott> monqy: i guess we could go dynamically scoped again
06:08:35 <monqy> how does dynamic scoping work with things like not feeling messy
06:08:37 <newsham> it worked out so well the first time
06:08:40 <monqy> I've never really studied it
06:08:45 <monqy> at all
06:09:34 <elliott> monqy: its great exclamation marks
06:09:41 <elliott> here's a schemeish example
06:09:42 <elliott> (define x 9)
06:09:46 <elliott> (define (f) x)
06:09:52 <elliott> (define (g) (let ((x 0)) (f)))
06:09:54 <elliott> (g) ==> 9
06:09:58 <elliott> erm
06:09:59 <elliott> (g) ==> 0
06:10:08 <elliott> sorry for momentarily misleading you into thinking that dynamic scoping was sane in any way
06:10:31 <newsham> if you wanna relive bad programming decisions, just use perl
06:10:36 <zzo38> How much do you know of the Lesser Key?
06:10:49 <monqy> is there a perl lisp
06:11:42 <monqy> perl of lisps, perl with lisp syntax and benefits thereof, others???
06:11:46 <newsham> ". Perl is another language with dynamic scoping that added static scoping afterwards"
06:11:50 <newsham> wikipedia
06:12:09 <monqy> is php dynamically scoped or did they fix that or was I dreadfully misinformed
06:12:21 <monqy> hehe php
06:12:24 <coppro> lolphp
06:12:49 <elliott> php is a good joke
06:12:51 <newsham> ph urine
06:13:41 <elliott> oh i turned into a goat
06:13:44 <elliott> THIS HAPPENS OFTEN
06:19:40 <Nisstyre> monqy: php has no dynamic scoping
06:20:15 <monqy> grats masterful php designers
06:22:03 <oerjan> > let ?x = 9; f = x; g = let ?x=0 in f in g
06:22:03 <lambdabot> <no location info>: parse error on input `f'
06:22:11 <oerjan> darn
06:22:14 <oerjan> hm
06:22:19 <oerjan> :t let ?x = 9; f = x; g = let ?x=0 in f in g
06:22:20 <lambdabot> parse error on input `f'
06:22:30 <elliott> monqy: oh cool my environments are immutable :slowpoke:
06:22:47 <monqy> what did you do
06:22:58 <monqy> emphasis on do
06:23:04 <elliott> monqy: i failed to make them mutable, this is haskell
06:23:04 <elliott> hmm
06:23:09 <elliott> should conses be immutable y or n
06:23:28 <elliott> bear in mind that if conses are immutable, there is exactly one kind of mutable object, environments
06:23:31 <oerjan> > let {?x = 9; f = x; g = let {?x=0} in f} in g
06:23:32 <lambdabot> <no location info>: parse error on input `f'
06:23:53 <oerjan> > let {?x = 9; f = x; module g = let {?x=0} in f} in g
06:23:53 <lambdabot> <no location info>: parse error on input `f'
06:24:00 <oerjan> hm
06:24:13 <monqy> there would still be a way to define cyclic things right
06:24:22 <elliott> monqy: nope
06:24:24 <oerjan> > let ?x = 9 in x
06:24:24 <lambdabot> x
06:24:33 <monqy> :'(
06:24:36 <oerjan> er
06:24:39 <monqy> a tough choice
06:24:42 <oerjan> ah
06:24:54 <oerjan> > let {?x = 9; f = ?x; module g = let {?x=0} in f} in g
06:24:54 <lambdabot> <no location info>: parse error on input `f'
06:25:02 <monqy> cycles are my bro but so is immutability
06:25:06 <oerjan> > let ?x = 9 in ?x
06:25:07 <lambdabot> 9
06:25:08 <monqy> im torn
06:25:34 <oerjan> > let {?x = 9; f = ?x} in f
06:25:35 <lambdabot> <no location info>: parse error on input `f'
06:25:48 <oerjan> wtf is that an error
06:26:12 <oerjan> > let {?x = 9; g = ?x} in f
06:26:13 <lambdabot> <no location info>: parse error on input `g'
06:26:58 <oerjan> > let ?x = 9 in let f = ?x; g = (let ?x = 0 in f) in g
06:26:59 <lambdabot> 0
06:27:05 <oerjan> whew
06:27:41 <monqy> :(
06:28:05 <oerjan> > let ?x = 9; ?y = 2 in let f = ?x; g = (let ?x = 0 in f) in g + ?y
06:28:06 <lambdabot> 2
06:28:29 <oerjan> hm is it forbidden to let both ? variables and others in the same block?
06:31:17 <elliott> :t liftM
06:31:17 <lambdabot> forall a1 r (m :: * -> *). (Monad m) => (a1 -> r) -> m a1 -> m r
06:31:28 <elliott> ?hoogle (a -> b -> m c) -> m a -> m b -> m c
06:31:29 <lambdabot> Control.Monad zipWithM :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m [c]
06:31:29 <lambdabot> Control.Monad zipWithM_ :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m ()
06:31:29 <lambdabot> Control.Monad foldM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a
06:31:35 <elliott> ?hoogle (a -> m b) -> m a -> m b
06:31:35 <lambdabot> Prelude (=<<) :: Monad m => (a -> m b) -> m a -> m b
06:31:35 <lambdabot> Control.Monad (=<<) :: Monad m => (a -> m b) -> m a -> m b
06:31:35 <lambdabot> Prelude (>>=) :: Monad m => m a -> (a -> m b) -> m b
06:31:41 <elliott> meh
06:33:12 <oerjan> :t \f x y -> (f <$> x) =<< y
06:33:13 <lambdabot> forall a (m :: * -> *) b a1. (Monad m) => (a -> m b) -> (a1 -> a) -> m a1 -> m b
06:33:24 <oerjan> wat
06:33:30 <oerjan> oh hm
06:33:49 <oerjan> :t \f x y -> (f <$> x <$> y)
06:33:49 <lambdabot> forall a b a1 (f :: * -> *). (Functor f) => (a -> b) -> (a1 -> a) -> f a1 -> f b
06:34:33 <oerjan> :t \f x y -> (f <$> x) <*> y
06:34:34 <lambdabot> forall a a1 b (f :: * -> *). (Applicative f) => (a -> a1 -> b) -> f a -> f a1 -> f b
06:34:57 <oerjan> :t \f x y -> join (f <$> x <*> y)
06:34:58 <lambdabot> forall a a1 (m :: * -> *) a2. (Applicative m, Monad m) => (a -> a1 -> m a2) -> m a -> m a1 -> m a2
06:35:06 <oerjan> elliott: ^
06:35:29 <elliott> duh. i know that.
06:35:31 <elliott> but uh thanks :P
06:35:33 <Deewiant> ?ty \f ma mb -> ma >>= \a -> mb >>= \b -> f a b
06:35:34 <lambdabot> forall (m :: * -> *) a a1 b. (Monad m) => (a -> a1 -> m b) -> m a -> m a1 -> m b
06:35:52 <Deewiant> For your non-Applicative Monad needs
06:36:11 <elliott> Deewiant: Such monads don't exist
06:36:25 <oerjan> ?pl \f ma mb -> ma >>= \a -> mb >>= \b -> f a b
06:36:25 <lambdabot> flip ((.) . (>>=)) . flip ((.) . (>>=))
06:36:27 <Deewiant> They might
06:36:29 <oerjan> ouch
06:36:34 <elliott> Deewiant: There are no monads that are not applicative functors
06:36:44 <oerjan> ?pl ma >>= \a -> mb >>= \b -> f a b
06:36:44 <lambdabot> (mb >>=) . f =<< ma
06:36:45 <Deewiant> elliott: The instance might not be defined
06:37:02 <elliott> Deewiant: instance Applicative M where pure = return; (<*>) = ap
06:37:17 <elliott> Better three lines than writing ugly code for the sake of a lie
06:37:19 <Deewiant> elliott: An extra line of code, and potentially inefficient
06:37:27 <elliott> "Potentially"
06:37:28 <Deewiant> Meh
06:37:37 <Deewiant> -funroll-loops
06:37:40 <elliott> Got any benchmarks for applicative code being slow? :-P
06:38:19 <Deewiant> I didn't mean the applicative-ness of it, just that defining <*> via a helper like ap might end up doing unnecessary work
06:38:23 <Deewiant> shrug
06:38:46 <elliott> ?src ap
06:38:46 <lambdabot> ap = liftM2 id
06:38:55 <elliott> ?unpl liftM2 id
06:38:55 <lambdabot> (\ d e -> d >>= \ b -> e >>= \ a -> return (b a))
06:39:17 <elliott> Deewiant: instance Applicative M where pure = return; f <*> x = f >>= \f' -> x >>= \x' -> return (f' x'), if you're into ugliness
06:39:53 <fizzie> What a best ending for a vacation. They're doing a bathroom renovation thing in the apartment downstairs from us; we walk in with suitcases and so on, and the people doing it go: "Hey, do you live in the apartment above?" Sure, why? "We just accidentally drilled into your sewer and now you can't use your bathroom until it's fixed."
06:39:55 <elliott> Deewiant: Have I mentioned that my hypothetical GHC extension would make this unnecessary?
06:39:57 <Deewiant> ?src Applicative
06:39:57 <lambdabot> class Functor f => Applicative f where
06:39:57 <lambdabot> pure :: a -> f a
06:39:57 <lambdabot> (<*>) :: f (a -> b) -> f a -> f b
06:40:17 <elliott> instance Applicative M where
06:40:17 <elliott> pure = return
06:40:17 <elliott> f <*> x = do f' <- f; x' <- x; return (f' x')
06:40:20 <elliott> relatively unugly
06:40:32 <elliott> Deewiant: What I'm saying is: Woo, GHC extensions that don't yet actually exist
06:40:52 <Deewiant> elliott: Woo
06:40:56 <Deewiant> t
06:41:11 <elliott> Deewiant: You were meant to ask what it is, but fine, ruin my flow like that
06:41:41 <Deewiant> w00t
06:42:03 <elliott> MY FLOW IS STILL RUINED
06:42:07 <elliott> I MIGHT KILL MYSELF
06:42:46 <monqy> wait why not (<*>) = ap
06:42:48 <monqy> im confused
06:42:53 <elliott> monqy: omg optimised
06:43:02 <monqy> daaaagn
06:43:30 <zzo38> Someone told me that MISSINGNO actually has four attacks: FIREBALL, ICEBALL, THUNDERBALL, and SUPERBALL. The SUPERBALL attack does no damage but makes the screen look like a pinball game. However, I do not believe any of this is true.
06:43:32 <monqy> I read that gentoo is for ricers thing yesterday and it was amazing. this reminds me of that.
06:43:45 <elliott> Deewiant: ASK ME WHAT THE EXTENSION IS
06:43:50 <elliott> sadfghjkl;'[
06:43:55 * elliott hyperventilates.
06:44:00 * elliott foams at the mouth a bit.
06:44:17 <pikhq> zzo38: Strange, considering that none of those attacks exist in the game.
06:44:54 <zzo38> pikhq: Yes, I know.
06:45:01 <coppro> monqy: funroll-loops?
06:45:04 <monqy> yes
06:45:12 <coppro> yeah, that site is awesome
06:45:24 <coppro> elliott: you know of funroll-loops.info, right?
06:45:58 <elliott> elliott@katia:~/logs$ grep -r funroll-loops\.info ????-??-??.txt | grep 'tusho\|ehird\|elliott\|alise'
06:45:58 <elliott> 2008-06-23.txt:18:18:25: <tusho> ais523: http://funroll-loops.info/
06:45:58 <elliott> 2009-01-07.txt:15:55:01: <ehird> I am so tempted to link to http://funroll-loops.info/ here. Oh wait I just did
06:45:58 <elliott> Hmm
06:46:02 <elliott> I swear I've linked it a lot more than that
06:46:04 <coppro> oh
06:46:05 <coppro> ok
06:46:06 <elliott> Oh well: yes, I know
06:46:06 <elliott> :P
06:46:20 <coppro> my favorite line there is "If the reviewers had been serious they would have used an optimised distributions such as Gentoo, which would have taken far fuller advantage of the extra 32bits in each register to provide a much fuller experience, more than any current Linux distribution possibly could."
06:46:28 <elliott> Man, I wonder how long that site has just been up unchanged
06:46:38 <coppro> good question
06:46:49 <elliott> coppro: This is the best one, IMO: "I don't think that Debian can really compete with Gentoo. Sure it might be okay, but when it comes to dependencies, you probably are still going to have to get them all on your own. Or is there something like portage in the Debian world as well?"
06:46:52 <monqy> too much of it is my favorite
06:47:02 <monqy> that one's one of them
06:47:42 <Deewiant> 2009-10-31 02:59:02( ehiird) "I don't think that Debian can really compete with Gentoo. Sure it might be okay, but when it comes to dependencies, you probably are still going to have to get them all on your own. Or is there something like portage in the Debian world as well?" -- funroll-loops.info
06:48:01 <elliott> Deewiant: Huh, clog incompleteness?
06:48:05 <elliott> Oh, "ehiird"
06:48:07 <Deewiant> 2011-01-27 00:42:41( elliott) Vorpal: from a thread about funroll-loops.org on the Gentoo forums, circa 2004: "One week later: this is on the Arch forums. One month later: the Arch people get the joke."
06:48:16 <elliott> Fuck it, I need a database of my nicknames
06:48:22 <Deewiant> And the latest
06:48:25 <Deewiant> 2011-07-02 00:21:53( elliott) oblig. http://funroll-loops.info/
06:48:33 <elliott> Yes but that was what caused monqy to read it.
06:48:35 <elliott> SO THAT DOESN'T EVEN COUNT
06:48:42 <Deewiant> Yeah, I figured
06:49:32 <ais523> [Tuesday, November 30, 2010] [04:07:07 pm] <elliott>Phantom_Hoover: We're talking -O3 -funsafe-math -fomit-function-pointer -funroll-loops -fadvanced-maths -fcrazy-maths -fyour-mother-and-a-horse -fit-never-happened -flanguid-squids ...
06:49:46 <elliott> I still use -flanguid-squids in all my programs
06:49:49 <ais523> not a direct reference, though
06:50:01 <Deewiant> I searched for "funroll-loops."
06:50:06 <ais523> I just searched for funroll
06:50:13 <ais523> in my own personal logs
06:50:23 <elliott> Also -fit-never-happened; it lets you detect _|_ values without resulting in _|_ (impossible with any other method), and optimises all computations to run in 0 ms
06:51:05 -!- augur has quit (Remote host closed the connection).
06:51:16 <zzo38> What are _|_ values?
06:51:24 <coppro> bottom
06:52:08 <zzo38> Are you allergic to bullets?
06:52:08 <elliott> zzo38: any failing/non-halting computation, e.g. infinite loops and errors
06:52:15 <oerjan> > let (_|_) = undefined in (_|_)
06:52:16 <lambdabot> <no location info>: parse error on input `|'
06:52:20 <oerjan> darn
06:52:21 -!- augur has joined.
06:52:29 <elliott> oerjan: you can do it with the unicode bottom symbol
06:52:34 <elliott> it still needs to be an operator though :(
06:52:36 <Deewiant> Except not with lambdabot
06:53:21 <oerjan> > let _I_ = undefined in _I_
06:53:22 <lambdabot> *Exception: Prelude.undefined
06:53:26 <coppro> 'void' in C is actually bottom as well
06:53:36 <coppro> although 'void*' is not a pointer to bottom
06:53:40 <elliott> coppro: untrue
06:53:45 <elliott> you can return from a function that returns void
06:53:48 <elliott> void is not really one type in C
06:53:54 <elliott> as a return type, it signifies the unit type
06:54:01 <elliott> it is not a valid variable type
06:54:16 <coppro> of course it isn't a variable must have a value
06:54:18 <elliott> but as a pointed-to type, it's... it's (void *)
06:54:41 <monqy> (void *) is spooky
06:54:47 <elliott> coppro: you are confused. if void was the type _|_, then no function declared as "void f();" would ever be able to return
06:55:07 <elliott> it is instead the _unit_ type as a function return type, e.g. ()
06:55:08 <zzo38> LLVM also has 'void' type, but not 'void*' type. But it also has nonreturning type which is separate.
06:55:10 <elliott> [asterisk]i.e. ()
06:56:22 <elliott> monqy: (eof? getc putc close) -- List of functions: BEST INTERFACE?
06:56:30 <elliott> It's, like, objects, man.
06:57:44 <monqy> what good is close without open
06:58:12 <elliott> monqy: open is how you get that list duh
06:58:18 <elliott> a handle is literally represented as the functions operating on it
06:58:19 <zzo38> If it is existing object, then open gives you the object.
06:58:24 <elliott> stdin is (<function> <function> <function> <function>)
06:58:33 <monqy> oh that's nifty
06:58:57 <coppro> elliott: I actually really like that model
06:59:02 <monqy> me too
06:59:03 <monqy> it's nifty
06:59:13 <monqy> well at least I think I like it
06:59:46 <Deewiant> elliott: Now if it were opaque and thus type-safe
06:59:52 <newsham> void * is the opposite of bottom
06:59:55 <monqy> so is this a quadruple or a list
07:00:50 <elliott> coppro: Well, sure, it's BASICALLY a record of functions
07:01:02 <elliott> coppro: It's just that having it as an arbitrarily ordered list with no names or anything is dumb dumb dumb :P
07:01:04 <elliott> HEYY WAIT OH MY GOD
07:01:07 <elliott> I could use an ENVIRONMENT
07:01:12 <elliott> Oh my god
07:01:14 <elliott> That is so perfect
07:01:17 <elliott> It's basically a dictionary type
07:01:21 <monqy> first-class environments?
07:01:21 <elliott> Except you could merge it in with your environment
07:01:27 <elliott> And thus get a global "current stream"
07:01:28 <elliott> monqy: Yes
07:01:30 <coppro> elliott: OR EVEN BETTER, YOU COULD CREATE A POLYMORPHIC... WAIT NO THAT'S OBJECT-ORIENTED
07:01:31 <monqy> mmm
07:01:37 <elliott> Oh man, that is so the best, objects as literal scopes.
07:01:43 <elliott> I am a genius. This is the most zepto thing ever.
07:04:08 <coppro> elliott: perl?
07:04:18 <elliott> coppro: No, it's way better than that.
07:04:38 <pikhq> -af scaletempo -speed 3
07:04:41 <monqy> proof: zepto is zepto. perl isnt. qed.
07:04:43 <pikhq> The solution to RPG TASes.
07:04:44 <pikhq> :)
07:04:44 <elliott> coppro: Every function can look at the environment it gets called in, right? So environments are first-class. So you can poke around looking at various variables in your environment, enumerating them, blah blah blah.
07:05:04 <elliott> coppro: So if we represent, e.g. a file as an environment with _only_ the bindings get-char, put-char, eof?, etc.,
07:05:05 <coppro> elliott: ohgod
07:05:11 <elliott> coppro: Then we can read these in and call them,
07:05:14 <elliott> coppro: Modify them (with set),
07:05:19 <elliott> coppro: And even bring them into scope:
07:05:32 <elliott> coppro: (with-env stdin (put-char 'c'))
07:05:50 <elliott> coppro: So this means that we can have an implicit "current default output stream" without even doing anything!
07:06:01 <elliott> And it is basically equivalent to an object as a hash table.
07:06:05 <elliott> This is genius.
07:06:25 <coppro> elliott: I want you to write me up a formal specification so that I can present this at a conference
07:06:59 <elliott> coppro: YOUR SARCASM MAY STING BUT MY GENIUS WILL SHINE THROUGH WHEN I AM DEAD
07:07:07 <elliott> Or maybe it isn't sarcasm and you just really like frightening people :P
07:07:39 <elliott> First-Class Environments as Objects: or, Let: The Ultimate Overloader
07:07:40 <elliott> I CAN SEE IT NOW
07:08:12 <monqy> turn it into a paradigm
07:08:18 <monqy> sell books
07:08:35 <elliott> I just want you all to know that I literally just got up and did a ridiculous dance around the room while waving my hands and doing the most insane cackle I could muster at the same time.
07:08:44 <elliott> FEAR ME, PROGRAMMING WORLD
07:08:45 <elliott> FEAR ME
07:08:47 <oerjan> get crushed when oleg points out it's just simple syntactic sugar over delimited continuations
07:08:52 <elliott> :D
07:09:30 <oerjan> then continue to sell books as no one outside #haskell understands oleg
07:09:59 <elliott> coppro: oh, it's even better; you can make mutations of object members work with plain "set" just by making the object itself the top-level environment of all the functions inside
07:10:50 <coppro> :D
07:11:11 <elliott> hmm the with-env thing doesn't /quite/ work since environments are based on _static_ scope, i.e. a piece of code's default handle is based on the context around it, rather than dynamic scope... but I'm sure I can fix that
07:11:17 <elliott> oh, it's just dynamic variables, except I want a dynamic /added scope/
07:11:29 <elliott> that sounds perfectly reasonable and logical, now I just have to figure out what it even _means_
07:11:46 <monqy> then turn it into papers, books
07:11:54 <elliott> monqy: the whole world is exploding into little ribbons of zepto
07:11:59 <elliott> i'm going to take some zepto in celebration
07:12:49 <coppro> elliott: and infinitely recursive functions can be used to make changes 'permanent'
07:13:01 <elliott> coppro: wat :D
07:13:24 <coppro> elliott: Use the Erlang model of events
07:13:45 <coppro> every handler ends with a tail recursive call
07:13:55 <coppro> so that you have a 'loop'
07:14:31 <elliott> i think you have invented another model that's just as crazy :D
07:14:37 <monqy> two books
07:18:43 <zzo38> "noreturn" is a function attribute and not a type in LLVM, although it could work even if it was a type (because if it doesn't return, it shouldn't be necessary to specify another return type anyways)
07:18:46 <elliott> *Main> env <- defaultEnv
07:18:46 <elliott> Loading package array-0.3.0.2 ... linking ... done.
07:18:46 <elliott> Loading package containers-0.4.0.0 ... linking ... done.
07:18:46 <elliott> *Main> code <- anteList [AnteSymbol "eval", AnteEnv env, AnteSymbol "eval"]
07:18:46 <elliott> *Main> eval env code
07:18:46 <elliott> *** Exception: AnteException <AnteValue>
07:18:48 <elliott> monqy: im pro
07:19:48 <monqy> what just happened
07:19:54 <elliott> monqy: something went wrong in the evaluation
07:20:03 <monqy> but what
07:20:11 <oerjan> something unAnteCipated
07:20:15 <elliott> monqy: dunno, I can't display values yet
07:20:22 <monqy> :(
07:22:09 <coppro> elliott: No, it's your regular event loop in functional programming
07:22:46 <coppro> you make a change of "state" by calling back into the event loop with a different argument
07:22:54 <coppro> but if the "state" is the scope...
07:23:22 <monqy> what happens if you call somewhere that isn't (directly) back into the event loop
07:23:25 <monqy> what then
07:23:36 <coppro> then the loop terminates
07:26:19 <elliott> *Main> test
07:26:19 <elliott> Error: (bad-function eval)
07:26:21 <elliott> swoot
07:26:40 <elliott> *Main> test
07:26:41 <elliott> Error: (bad-function #<environment>)
07:26:41 <elliott> swiit
07:26:56 <elliott> ...wait what
07:27:54 <elliott> monqy: what if i removed cons pairs
07:27:57 <elliott> what if i replaced cons pairs
07:27:59 <elliott> with environments
07:28:03 <elliott> just containing the keys "car" and "cdr"
07:28:04 <elliott> what then
07:28:06 <monqy> zepto
07:28:25 <elliott> coppro: WHAT THEN
07:28:38 <elliott> Set! the Ultimate
07:29:21 <elliott> monqy: and then instead of a meaningless list a function could be
07:29:33 <coppro> elliott: I have no ability to compensate for the presence of zepto
07:29:51 <elliott> #{env: ...; envName: 'e; argName: 'x; code: ...}
07:31:02 <monqy> instead of function application you have some weird sort of environment mangling (of which function application is a special case)
07:31:20 <monqy> where by special case I mean
07:31:22 <monqy> instance
07:31:25 <monqy> not special at all
07:31:32 <monqy> unless you sugar it up
07:31:34 <elliott> monqy: im starting to feel like this might not be lisp any more at all
07:31:45 <coppro> elliott: it's not in kansas either
07:31:46 <monqy> one time I had a language idea sort of like this. I forget what happened to it.
07:32:05 <elliott> i think im going to be a wimp for now and keep cons cells being, you know, still a thing that exist
07:32:17 <elliott> but I might change functions into environments rather than a meaningless list
07:32:18 <elliott> we will see
07:32:22 <elliott> although
07:32:33 <elliott> it is tempting to make applying an environment to an argument look that argument up in the environment
07:34:01 <coppro> yes
07:34:04 <coppro> doit
07:34:17 <coppro> we should call this language "greenparty"
07:34:45 <monqy> yes that was part of my dead language i think. and all functions were environments with rewrite rules or something else special like that.
07:34:53 <monqy> it was a few years ago so the details are very hazy
07:35:12 <elliott> coppro: im sorry, its called zepto
07:35:22 <elliott> any language that has the zepto nature should, by rights, be called zepto
07:35:26 <elliott> although it can have another name, too
07:35:27 <elliott> for instance
07:35:30 <elliott> it could be called greenparty-zepto
07:35:34 <elliott> all lowercase
07:35:35 <coppro> ok
07:35:35 <monqy> zeptoparty
07:35:37 <elliott> exactly as printed
07:35:42 <coppro> or greenzepto
07:35:54 <elliott> no, finding the zepto languages must be a painless (zepto) process for the programmer
07:36:00 <coppro> ah ok
07:36:04 <coppro> I apologize
07:36:07 <elliott> so it must always be clearly delineated from the other name
07:36:09 <coppro> I zeptofailed
07:36:16 <elliott> it is ok. we all sometimes zepto-fail.
07:36:26 <elliott> in fact, that which is zepto is not zepto without zepto-fail.
07:36:28 <coppro> side not
07:36:31 <coppro> *side note
07:36:38 <coppro> is it wrong to mount things directly onto /media or /mnt?
07:36:41 <elliott> the very definition of zepto may even be learning to accept zepto-failing in your heart.
07:36:48 <elliott> coppro: mounting into /mnt is done by the debian-installer
07:36:51 <elliott> its kind of gross though
07:36:52 <elliott> why do you want to?
07:36:54 <coppro> elliott: not into
07:36:55 <coppro> onto
07:36:58 <elliott> I think doing it in /media is totally unacceptable
07:37:00 <elliott> coppro: what do you mean then
07:37:07 <elliott> debian-installer mounts the target system as /mnt
07:37:07 <coppro> elliott: I plug a usb drive in
07:37:15 <coppro> sudo mount /dev/sdb1 /media
07:37:28 <elliott> yeah that's no good make a directory you bum
07:38:40 <elliott> monqy: ok so im not sure what this bug is so im considering just calling it a feature?
07:38:44 <elliott> application being broken is a feature
07:38:56 <elliott> maybe i should sleep, sleep would be unzepto because zepto is to be optimised for sleep-deprived zepto programmers
07:38:57 <elliott> but
07:38:59 <elliott> im not writing in zepto
07:38:59 <monqy> whats wrong with ap;plication
07:39:00 <elliott> im writing in haskell
07:39:04 <elliott> and that requires an unzepto frame of mind
07:39:07 <elliott> monqy: i dunno you tell me
07:39:11 <elliott> punque
07:39:19 <elliott> oh
07:39:19 <elliott> OH
07:39:20 <elliott> im dum
07:39:23 <elliott> dum as an shits
07:39:25 <elliott> :/
07:41:47 <elliott> *Main> test
07:41:47 <elliott> #<primitive>
07:41:48 <elliott> monqy: O YA
07:42:07 <monqy> too cool to derive Show
07:42:40 -!- Sgeo_ has quit (Ping timeout: 255 seconds).
07:43:04 <elliott> monqy: whats that supposed to mean
07:43:09 <elliott> monqy: i lit. can't derive show
07:43:11 <elliott> there's IORefs
07:43:13 <monqy> oh
07:43:18 <monqy> iorefs are scary
07:43:28 <elliott> monqy: im thinking about making zepto stm
07:43:30 <elliott> and using TVars
07:43:32 <elliott> but
07:43:33 <elliott> yeah
07:43:54 <elliott> monqy: http://sprunge.us/HWMi
07:43:55 <elliott> enjoy
07:44:03 <elliott> this is ante-zepto initial
07:45:33 <oerjan> an ante-paste
07:45:34 <Deewiant> instance Show a => Show (IORef a) where showsPrec d r = showParen (d>10) $ showString "unsafePerformIO (newIORef " . showsPrec 11 $ unsafePerformIO (readIORef r)
07:45:50 <monqy> this makes me uncomfortable
07:46:04 <elliott> Deewiant: i
07:46:06 <elliott> Deewiant: dont like you
07:46:09 <elliott> Deewiant: please...stop existing...
07:46:13 <elliott> :(
07:46:19 <elliott> im really not happy that you exist
07:46:20 <Deewiant> I forgot to add the ")" at the end
07:46:28 <elliott> thats not the bad part
07:49:28 <elliott> monqy: the world is becoming unzepto i need another breakthrough like environment objects
07:49:53 <monqy> im tired this may or may not help
07:50:13 <elliott> monqy: im sleep deprived how can you possibly imrpove on that
07:50:34 <monqy> this is the best i can do
07:51:26 <elliott> monqy: btw did you note how i cunningly avoided so many unzepto feelings by not using a monad stack
07:51:29 <elliott> thats expert
07:51:49 <elliott> i understand its quite hard to read code when its not all in nice rainbow colours in your editor, this is why pastebin sites are the devil
07:51:56 <monqy> i avoid monad stacks too
07:52:12 <monqy> if it means what i think it means
07:53:11 <elliott> monqy: things that look like BlahT (BluhT (BlingT IO)))
07:53:16 <monqy> yeah those
07:53:30 <elliott> http://sebfisch.github.com/haskell-regexp/regexp-play.pdf this is a nice paper it has a bunch of people talking who are nice people and, also, the code is all in nice colours and also it has nice fancy symbols
07:53:31 <monqy> juggling lifts makes me uncomfortable
07:53:40 <elliott> i recommend it to every sleep-deprived haskell programmer it is making me happy
07:53:47 <elliott> monqy: well that's kind of what the various typeclasses are for
07:53:49 <elliott> MonadIO, MonadState etc.
07:53:57 <monqy> I guess those help yes
07:53:57 <oerjan> more like monad stuck
07:54:09 <elliott> Using sym, we can translate every regular expression into a
07:54:09 <elliott> weighted regular expression in a canonical fashion:
07:54:10 * elliott claps
07:54:19 <elliott> im happy for them
07:54:29 <monqy> woo colours
07:54:55 <monqy> when im tired my eyes skip around and it's hard to read
07:55:08 <monqy> wow is this paper a play
07:55:20 <olsner> weighted regexps? sounds heavy.
07:55:45 * oerjan swats olsner -----###
07:56:07 <elliott> monqy: yes its great
07:56:24 <elliott> monqy: i suggest zooming in by the way, zooming in is nice because everything gets bigger
07:56:26 <elliott> so its easier to see
07:56:43 <monqy> less room for my eyes to skip
07:58:22 <elliott> 1
07:58:22 <elliott> By x
07:58:23 <elliott> n
07:58:23 <elliott> Cody means a sequence of n copies of x
07:58:39 <elliott> i really like how everyone understands each other in this
07:59:08 <monqy> i want to see this acted out
07:59:19 <elliott> oh my god
07:59:22 <elliott> i want to voice act it now
08:00:58 <elliott> "CODY (getting excited)"
08:04:04 <pikhq> Welp, that was fun. And absurd.
08:04:09 <pikhq> 151 mon run of Pokemon.
08:04:28 <pikhq> 3:20, only tolerable at ~3x speed.
08:04:37 <pikhq> Utterly ridiculous.
08:04:46 <elliott> HAZEL I told you about Google’s new library. They implemented
08:04:46 <elliott> an algorithm in C++ with similar worst case performance as our
08:04:46 <elliott> algorithm. Do you know any C++?
08:04:46 <elliott> CODY Gosh
08:04:57 <elliott> [exclamation mark]
08:06:11 <elliott> monqy: hey is it just me or is ungetc an unzepto kind of function
08:06:20 <pikhq> Actually, a 152 mon run, really; shame Missingno doesn't count on the Pokédex in-game.
08:06:25 <pikhq> elliott: Utterly unzepto.
08:06:35 <monqy> ungetc is what
08:06:54 <elliott> monqy: you can put the character you just read back into a stream
08:06:57 <elliott> so it will be read again next time
08:06:59 <elliott> but its only one character
08:07:03 <elliott> constant size buffer of one
08:07:03 <elliott> :(
08:07:03 <monqy> i meant what in the sense that
08:07:06 <elliott> and its built in to stdio
08:07:07 <elliott> oh
08:07:08 <elliott> right
08:07:09 <elliott> yeah
08:07:46 * pikhq wonders how that is usually implemented
08:07:50 <elliott> -- A handle has the keys: (foo) means only foo type handles
08:07:51 <elliott> -- is-eof? (read)
08:07:51 <elliott> -- get-char (read)
08:07:51 <elliott> -- put-char (write)
08:07:51 <elliott> -- close
08:07:53 <elliott> DO I NEED ANYTHING ELSE PIKHQ
08:07:57 <elliott> also, usually implemented: char keep;
08:07:59 <elliott> i think
08:07:59 <elliott> well
08:08:01 <elliott> int keep;
08:08:04 <elliott> negative one if theres nothing to buffer
08:08:14 <elliott> or it just integrates into the regular buffer i guess
08:08:19 <elliott> with some special code to break it if you call it more than once
08:08:39 -!- Phantom_Hoover has joined.
08:08:46 <elliott> ACT III
08:08:46 <elliott> SCENE I. INFINITE REGULAR EXPRESSIONS
08:08:48 <elliott> oh yes
08:08:58 <pikhq> Hmm. Well, musl appears to just directly write it into the read buffer.
08:09:14 <elliott> THEO I like our work as well, although it is always difficult to work
08:09:14 <elliott> with practitioners. (Rolls his eyes.)
08:09:16 <elliott> theo thats not nice
08:09:18 <elliott> we're all friends here
08:11:29 <elliott> THEO Ok, fine (tired of the practitioners’ conversation).
08:11:30 <elliott> theo
08:11:33 <elliott> you're being very nasty
08:12:17 <pikhq> It seems that how it handles ungetc is by being clever enough that ungetc itself is easy. :P
08:12:28 <monqy> i like the part where theo writes some formal definitions to the whiteboard: seman-
08:12:31 <monqy> tic brackets, Greek letters, languages as sets, etc.
08:12:48 <monqy> i am imagining this takes him a while and the others just sit and watch him intently
08:12:51 <zzo38> Perhaps turn off ligatures, they are not very good for fixed-pitch text
08:13:05 <elliott> monqy: he literally just writes those words
08:13:08 <elliott> SEMANTIC BRACKETS
08:13:09 <elliott> GREEK LETTERS
08:13:11 <elliott> LANGUAGES AS SETS
08:13:12 <elliott> ETC.
08:13:18 <monqy> brilliant
08:13:32 <monqy> can easily be coded in haskell
08:13:41 <elliott> HAZEL Well, we have a cute program, elegant, efficient, concise,
08:13:41 <elliott> solving a relevant problem. What else do you want?
08:13:49 <elliott> THEO A friend who I'm not a sarcastic piece of shit to.
08:13:57 <elliott> HAZEL You know you can never have that, Theo.
08:14:00 <elliott> CODY God I hate you.
08:14:10 <elliott> thats my fanfiction
08:14:29 <monqy> T HEO But how do we make our story a fun essay?
08:14:29 <monqy> The three turn to the audience, bright smiles on their
08:14:29 <monqy> faces!
08:15:12 <elliott> type ReadTable = Map Char AnteValue -- function from handle -> object
08:15:13 <elliott> monqy
08:15:15 <elliott> monqy oh my god
08:15:16 <elliott> its a map
08:15:16 <elliott> that means
08:15:18 <elliott> its an environment
08:15:23 <elliott> I just need to let environments have arbitrary objects as keys
08:15:30 <elliott> rather than just symbols
08:15:55 <monqy> are environments good keys
08:17:17 <oerjan> WHO'S A GOOD KEY?
08:18:25 <zzo38> You need the appropriate key! The red door is locked!
08:18:44 <elliott> monqy: fdk glkkobgfnldmgdf
08:18:59 <elliott> monqy: should quote be used as (quote . x) => x or (quote x) => x
08:19:07 <elliott> picolisp does former, most things do latter
08:19:14 <elliott> zeptoability in question of both
08:20:18 <elliott> "British website owners could face extradition to the US on piracy charges even if their operation has no connection to America and does something which is most probably legal in the UK, the official leading US web anti-piracy efforts has told the Guardian."
08:20:19 <monqy> the . is a little bizarre there does it mean the same thing as it does in scheme
08:20:35 <monqy> good job usa
08:20:39 <elliott> <monqy> the . is a little bizarre there does it mean the same thing as it does in scheme
08:20:40 <elliott> yes
08:20:47 <elliott> pico does it because it means quote is faster, its just cdr rather than cadr :P
08:21:00 <elliott> but since like
08:21:05 <elliott> (quote a b) has no useful meaning afaik
08:21:11 <elliott> it seems like (quote . a) is more...
08:21:17 <elliott> clean?
08:21:19 <elliott> but then
08:21:22 <elliott> no other form acts like that
08:21:22 <elliott> so
08:22:22 <monqy> keeping it like other forms sounds nice to me
08:22:35 <elliott> /home/elliott/Code/ante/ante.hs:150:34: Not in scope: `liftMtwo'
08:22:56 <monqy> 2
08:23:02 <monqy> use wisely
08:23:06 <elliott> im unwise
08:23:26 <elliott> ?undo do dfjg <- read e h; dd <- cons dfjg AnteNil; cons (AnteSymbol "quote") dd
08:23:26 <lambdabot> read e h >>= \ dfjg -> cons dfjg AnteNil >>= \ dd -> cons (AnteSymbol "quote") dd
08:23:31 <elliott> ?pl read e h >>= \ dfjg -> cons dfjg AnteNil >>= \ dd -> cons (AnteSymbol "quote") dd
08:23:31 <lambdabot> cons (AnteSymbol "quote") =<< flip cons AnteNil =<< read e h
08:23:41 <elliott> ?pl \e h -> cons (AnteSymbol "quote") =<< flip cons AnteNil =<< read e h
08:23:41 <lambdabot> (((cons (AnteSymbol "quote") =<<) . (flip cons AnteNil =<<)) .) . read
08:23:43 <elliott> nice
08:23:47 <elliott> very zepto
08:24:10 <elliott> oh damn I need to call read anteRead
08:24:15 <monqy> . sections are scary
08:24:39 <monqy> all the more zepto i guess
08:24:51 <zzo38> What do these "Ante" things mean anyways?
08:25:30 <oerjan> @pl \a b c d e f g h -> a (b (c d e) (f g)) h
08:25:31 <lambdabot> (. (((((.) .) .) .) . (.) . (.))) . (.) . (.) . (.) . (.) . (.)
08:25:39 <oerjan> *MWAHAHAHA*
08:26:03 <monqy> dying from spook
08:30:39 <elliott> oerjan: thats not nice
08:30:42 <elliott> zzo38: yes
08:31:18 <elliott> monqy: oh this is going to be hard are
08:31:24 <elliott> do IORefs implement Eq
08:31:27 <elliott> or
08:31:28 <elliott> Ord
08:31:59 <monqy> instance Eq (IORef a) -- Defined in GHC.IORef
08:32:10 <elliott> oh im good
08:32:34 <elliott> monqy: but Ord??
08:32:54 <zzo38> Please join my TeXnicard project so that we can make something TeXnicard.
08:32:59 <elliott> no
08:33:09 <monqy> maybe in caleskell
08:33:13 <monqy> ?info IORef
08:33:14 <lambdabot> IORef
08:33:20 <monqy> how do you do the info thing
08:33:23 <elliott> ask oerjan
08:33:23 <zzo38> elliott: I don't mean you.
08:33:27 <oerjan> you don't
08:33:29 <elliott> zzo38: then who
08:33:40 <monqy> when I did :i in ghci it only gave Eq
08:33:44 <zzo38> Someone else.
08:34:01 <elliott> monqy: yeah ditto
08:34:03 <elliott> thatk ind of
08:34:04 <zzo38> Someone else who doesn't mean "no".
08:34:04 <elliott> sucks though
08:34:05 <oerjan> :t newIORef "Boo!"
08:34:06 <lambdabot> Not in scope: `newIORef'
08:34:11 <elliott> im surprised its even Eq
08:34:12 <elliott> why is it Eq
08:34:17 <monqy> oh there's a Typeable1 instance too??
08:34:25 <elliott> monqy: yes its the height of luxury
08:34:55 <oerjan> presumably GC can move it about?
08:35:26 <oerjan> so Ord may not be safe
08:35:47 <monqy> -- explicit instance because Haddock can't figure out a derived one
08:35:48 <monqy> instance Eq (IORef a) where IORef x == IORef y = x == y
08:35:51 <monqy> what is this nonsense
08:36:06 <elliott> ?src IORef
08:36:06 <lambdabot> newtype IORef a = IORef (STRef RealWorld a)
08:36:08 <monqy> oh it depends on the STRef Eq instanced
08:36:11 <elliott> ?src STRef
08:36:11 <monqy> yeah
08:36:11 <lambdabot> data STRef s a = STRef (MutVar# s a)
08:36:14 <elliott> nooo
08:36:16 <elliott> hashes already
08:36:20 <elliott> ?src MutVar#
08:36:20 <lambdabot> Source not found.
08:36:35 <elliott> MutVar# is primitive i think
08:36:44 <oerjan> hm data so MutVar# is probably unboxed
08:36:52 <monqy> -- Just pointer equality on mutable references:
08:36:52 <monqy> instance Eq (STRef s a) where STRef v1# == STRef v2# = sameMutVar# v1# v2#
08:37:19 <elliott> oerjan: well # implies unboxed...
08:37:21 <elliott> it's magic, after all
08:37:36 <oerjan> i'm not sure of that...
08:37:39 <elliott> oerjan: remember, different kind
08:37:42 <elliott> Foo# :: #
08:37:59 <oerjan> um the # in names has no automatic meaning :P
08:38:12 <zzo38> Anyone programming in C or CWEB or Plain TeX or understanding these kind of card game or anything else relevant to the project, can join, if you want to, please.
08:38:35 <elliott> oerjan: are you sure? I think it does for types
08:38:41 <elliott> oerjan: you can't define your own Foo# type
08:39:00 -!- yorick_ has joined.
08:39:06 <oerjan> elliott: um you need MagicHashes, of course
08:39:18 <oerjan> but afaik that only extends syntax
08:40:22 <oerjan> !haskell {-# LANGUAGE MagicHashes #-} data Foo# = Foo# Int deriving Show; main = print $ Foo# 0
08:40:30 <Deewiant> ptrEq :: a -> a -> IO Bool
08:40:31 <EgoBot> ​/tmp/input.6121.hs:1:13: unsupported extension: MagicHashes
08:40:31 <Deewiant> ptrEq x y = do nx <- makeStableName x ny; <- makeStableName y; return (nx == ny)
08:40:36 <oerjan> oops
08:40:42 <oerjan> !haskell {-# LANGUAGE MagicHash #-} data Foo# = Foo# Int deriving Show; main = print $ Foo# 0
08:40:47 <EgoBot> Foo# 0
08:40:57 <oerjan> elliott: works perfectly
08:41:25 <elliott> hm, fair enough then
08:41:34 <oerjan> it's just for things they don't want people to muck about with needlessly
08:41:38 <oerjan> imo
08:42:14 <elliott> oerjan: i think it's because it's non-standard, dude :P
08:42:42 <oerjan> well yeah
08:42:50 <olsner> also, for translating shootout benchmarks from C to Haskell
08:42:59 <oerjan> :P
08:43:41 -!- yorick has quit (*.net *.split).
08:47:48 -!- cheater_ has joined.
08:52:58 <elliott> oh for _crying out loud_
08:53:15 <elliott> oerjan: i would like to mark down on the record how much IORefs in ADTs sucks in haskell
08:53:33 <oerjan> O KAY
08:53:34 <monqy> but records suck too.......
08:53:45 <elliott> got a function somewhere? or an IORef? wanna use your value as a Map key?
08:53:49 <elliott> ha ha ha oh boy, HAVE FUN WITH THAT
08:54:40 -!- cheater_ has quit (Ping timeout: 255 seconds).
08:54:48 <Deewiant> Writing an Ord instance that ignores them isn't exactly a huge pain
09:04:49 <elliott> yay it all works now
09:04:57 <elliott> Deewiant: um such an Ord instance won't work for Map will it?
09:04:58 <elliott> I ended up doing
09:05:03 <elliott> data Ref a = Ref !Int !(IORef a)
09:05:03 <elliott> instance Eq (Ref a) where Ref i _ == Ref j _ = i == j
09:05:03 <elliott> instance Ord (Ref a) where compare (Ref i _) (Ref j _) = compare i j
09:05:03 <elliott> instance Show (Ref a) where show = const "<Ref>"
09:05:09 <elliott> with a global unsafePerformIO'd ioref to keep track of the top index
09:05:21 <Deewiant> elliott: Why not?
09:05:43 <elliott> Deewiant: good point :P
09:05:43 <Deewiant> Also, globall unsafePerformIO'd ioref: and you don't like my code...
09:05:49 <Deewiant> -l
09:06:05 <elliott> Deewiant: It's completely encapsulated, and only exists because GHC is dumb and doesn't have its own ioref IDs :P
09:06:45 <elliott> I don't know what you mean by "your code", though, unless I've complained at your HIDEOUS SINS AGAINST PROGRAMMING before in which case probably feel bad
09:07:36 -!- yorick_ has changed nick to yorick.
09:09:13 <oerjan> Deewiant: <elliott> Deewiant: please...stop existing...
09:09:31 <oerjan> er *elliott:
09:09:39 <elliott> oh right
09:09:41 <elliott> yes that was bad
09:09:49 <monqy> wasnt this the one that wasnt that one
09:09:52 <elliott> ok i need to go unconscious for some hours now bye
09:09:53 <monqy> something about stablenames
09:09:57 <monqy> have fun
09:09:59 <elliott> monqy: unsafeperformio for showing ioref
09:10:07 <monqy> mm :(
09:10:07 <elliott> monqy: ok i will ill try and hallcuating
09:10:12 <elliott> tomorrow: ante-zepto
09:12:12 <oerjan> monqy: apparently StableNames don't have Ord either
09:14:26 -!- elliott has quit (Ping timeout: 246 seconds).
09:17:08 <fizzie> oerjan: "Stable, not sorted"; isn't that how James Bond likes his drinks?
09:17:18 <oerjan> MAYBE
09:22:10 -!- Lymee has quit (Ping timeout: 240 seconds).
09:23:31 -!- Lymee has joined.
09:36:19 -!- cheater_ has joined.
09:38:20 -!- Vorpal has joined.
09:38:26 <zzo38> Is the random number generator algorithm in TeXnicard OK? Is there anything wrong with it?
09:38:35 <Phantom_Hoover> fizzie, no, Bond likes his drinks unstable.
09:38:42 <Phantom_Hoover> He lives on the edge.
09:40:34 -!- cheater_ has quit (Ping timeout: 255 seconds).
09:40:39 -!- monqy has quit (Quit: hello).
09:44:01 -!- oerjan has quit (Quit: Good night).
09:51:06 -!- augur has quit (Read error: Connection reset by peer).
09:53:01 -!- augur has joined.
10:16:04 -!- zzo38 has quit (Quit: Unstable cards.).
11:35:40 -!- ineiros has quit (Ping timeout: 240 seconds).
12:05:16 -!- ais523 has quit (Remote host closed the connection).
12:10:06 -!- CakeProphet has joined.
12:10:07 -!- CakeProphet has quit (Changing host).
12:10:07 -!- CakeProphet has joined.
12:16:18 -!- boily has joined.
12:20:24 -!- boily has quit (Client Quit).
12:21:27 -!- boily has joined.
12:33:28 -!- BeholdMyGlory has joined.
12:58:02 -!- azaq23 has joined.
14:43:45 -!- adam____ has joined.
14:48:31 -!- CakeProphet has quit (*.net *.split).
14:56:09 -!- Sgeo has joined.
14:57:25 -!- cheater_ has joined.
15:01:53 -!- cheater_ has quit (Ping timeout: 255 seconds).
15:02:07 -!- copumpkin has joined.
15:02:07 -!- copumpkin has quit (Changing host).
15:02:07 -!- copumpkin has joined.
15:13:33 -!- Sgeo has quit (Read error: Connection reset by peer).
15:14:28 -!- Sgeo has joined.
15:19:48 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
15:40:49 -!- Sgeo_ has joined.
15:42:34 -!- Sgeo__ has joined.
15:43:44 -!- Sgeo has quit (Ping timeout: 255 seconds).
15:45:32 -!- Sgeo_ has quit (Ping timeout: 255 seconds).
15:47:20 -!- Sgeo__ has quit (Ping timeout: 255 seconds).
15:49:07 -!- monqy has joined.
15:55:56 -!- Sgeo has joined.
15:56:11 -!- Sgeo has quit (Client Quit).
16:17:19 <quintopia> hello
16:17:29 <quintopia> that ks a lot of coming and going
16:17:41 <quintopia> are you alive?
16:21:51 <pikhq> Nope.
16:29:05 -!- Cocytus has joined.
16:29:56 <Cocytus> sorry guys this is my room. it's for Esoteric Philosophy...programming language is of course one avenue of Philosophy so you are welcome to stay and discuss amongst everyone.
16:31:18 <Cocytus> that being said........Ave.
16:31:24 -!- Cocytus has left.
16:31:36 <fizzie> Oh no, we're in his room. :/
16:40:54 <pikhq> Also, birds.
16:57:54 -!- cheater_ has joined.
17:00:35 -!- ineiros has joined.
17:23:15 <cheater_> you are standing at the end of a road before a small brick building.
17:23:21 -!- zzo38 has joined.
17:28:35 -!- cheater_ has quit (Ping timeout: 255 seconds).
17:29:59 -!- cheater_ has joined.
17:30:48 <quintopia> >go building
17:33:23 -!- copumpkin has joined.
17:33:23 -!- copumpkin has quit (Changing host).
17:33:23 -!- copumpkin has joined.
17:38:31 <Phantom_Hoover> ineiros!
17:51:09 -!- esowiki has joined.
17:52:05 -!- esowiki has joined.
17:52:50 -!- esowiki has joined.
17:52:50 -!- glogbot has joined.
17:52:50 <?unknown?> [freenode-info] please register your nickname...don't forget to auto-identify! http://freenode.net/faq.shtml#nicksetup
18:01:26 -!- cheater_ has quit (Ping timeout: 255 seconds).
18:03:28 -!- cheater_ has joined.
18:22:35 -!- cheater_ has quit (Ping timeout: 255 seconds).
18:33:20 -!- pikhq_ has joined.
18:33:49 -!- cheater_ has joined.
18:34:10 -!- pikhq has quit (Ping timeout: 240 seconds).
18:41:18 -!- pikhq has joined.
18:43:44 -!- cheater_ has quit (Ping timeout: 240 seconds).
18:43:52 -!- pikhq_ has quit (Ping timeout: 240 seconds).
18:44:59 -!- cheater_ has joined.
18:46:27 -!- KingOfKarlsruhe has joined.
18:50:40 -!- cheater_ has quit (Ping timeout: 250 seconds).
18:51:41 -!- cheater_ has joined.
18:55:03 -!- quintopia has quit (Ping timeout: 252 seconds).
18:56:20 -!- cheater_ has quit (Ping timeout: 255 seconds).
18:58:33 -!- quintopia has joined.
18:58:34 -!- quintopia has quit (Changing host).
18:58:34 -!- quintopia has joined.
19:16:44 -!- BeedaWeeda has joined.
19:19:32 <Phantom_Hoover> Oh god.
19:19:55 <Phantom_Hoover> I have the choice between YouTube binging on The Chaser, or on Dead Ringers.
19:20:59 -!- MigoMipo has joined.
19:23:59 -!- oerjan has joined.
19:24:31 <Phantom_Hoover> I like the way The Chaser were always able to find John Howard for their stunts.
19:24:37 <Phantom_Hoover> tswett_, you Australians are cool.
19:26:05 <oerjan> while you welsh are cwwl
19:28:03 -!- pikhq_ has joined.
19:28:41 -!- hiato_ has quit (Ping timeout: 258 seconds).
19:30:02 -!- pikhq has quit (Ping timeout: 264 seconds).
19:30:15 * tswett_ bows.
19:34:38 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
19:35:50 -!- hiato has joined.
19:49:51 <oerjan> "Today I want to talk about the status of the question and baseball."
19:50:23 <oerjan> eek a picture
19:50:34 <oerjan> *"Today I want to talk about the status of the P = NP question and baseball."
19:50:58 <Zwaarddijk> is there any progress on it currently?
19:51:04 <Phantom_Hoover> I prefer calling it just... the Question.
19:51:15 <Zwaarddijk> I like the idea of the question
19:51:24 <Zwaarddijk> with double or triple spaces between the article and noun
19:53:11 <oerjan> Zwaarddijk: nothing immediately promising that i know of
19:55:31 <oerjan> although maybe the rest of http://rjlipton.wordpress.com/2011/07/04/getting-on-base-with-pnp/ may count as a little survey of the case
20:09:55 -!- elliott has joined.
20:11:15 <elliott> 16:29:05: -!- Cocytus has joined #esoteric.
20:11:15 <elliott> 16:29:56: <Cocytus> sorry guys this is my room. it's for Esoteric Philosophy...programming language is of course one avenue of Philosophy so you are welcome to stay and discuss amongst everyone.
20:11:15 <elliott> 16:31:18: <Cocytus> that being said........Ave.
20:11:15 <elliott> 16:31:24: -!- Cocytus has parted #esoteric.
20:11:16 <elliott> lol what
20:11:54 <oerjan> should have told him about Malbolge
20:12:04 <olsner> elliott: that was you under a differen nick, wasn't it?
20:12:48 <elliott> no
20:12:54 <oerjan> i do not know elliott to use comcast, but who knows
20:21:02 -!- adam____ has quit (Ping timeout: 264 seconds).
20:23:00 -!- CakeProphet has joined.
20:24:14 <elliott> http://en.wikipedia.org/wiki/List_of_atheists <-- list of famous bisexuals
20:24:51 <Phantom_Hoover> God, how stupid are they.
20:25:11 <Phantom_Hoover> That's a list of lists of atheists.
20:25:35 <olsner> probably more like FixF [] Atheist
20:25:59 <Phantom_Hoover> :t FixF
20:26:00 <lambdabot> Not in scope: data constructor `FixF'
20:26:04 <Phantom_Hoover> -_-
20:26:18 <elliott> data FixF f a = Foo a | Bar (f (FixF f a)), presumably
20:26:47 <Phantom_Hoover> Nope.
20:26:52 <olsner> actually, the FixF I was thinking of would be a bit hard to use since you'd never get to the Atheists
20:26:54 <elliott> unless olsner means a two-argument Mu, in which case it's a very useless type :D
20:29:32 <elliott> monqy: i have sad news
20:29:40 <monqy> is it about zepto
20:29:58 <monqy> antezepto specifically?
20:30:00 <elliott> monqy: yes
20:30:09 <monqy> weeping
20:30:19 <elliott> monqy: i am sorry to report
20:30:25 <elliott> monqy: that .............................................................................................
20:30:31 <elliott> monqy: my impl is broken :(
20:30:39 <monqy> :(
20:30:42 <elliott> its not enough to just compare references by pointer equality, because
20:30:46 <elliott> | AntePair !(Ref AnteValue) !(Ref AnteValue)
20:30:47 <elliott> so as it stands
20:30:54 <elliott> if you have a map with key (a b)
20:31:03 <olsner> I think something like FixF (Either Atheist `O` []) Atheist is more what I meant, i.e. what elliott said
20:31:05 <elliott> only the same object will look it up, pretty much
20:31:34 <elliott> monqy: so what I need is a map where compare and (==) are done in IO?
20:31:43 <elliott> which
20:31:43 <elliott> yeah
20:31:43 <monqy> aaaaaaaaaaaaaaaaaaa
20:31:45 <elliott> i dunno of one
20:32:24 <monqy> is there any way around it
20:33:03 <elliott> monqy: I can't think of one that doesn't involve unsafePerformIO
20:33:08 <olsner> I meant FixF from http://hackage.haskell.org/packages/archive/category-extras/0.53.5/doc/html/Control-Functor-Fix.html and I didn't even remember it right... fail :(
20:33:10 <elliott> <monqy> aaaaaaaaaaaaaaaaaaa
20:33:18 <elliott> olsner: category-extras is deprecated >:|
20:33:50 <olsner> aha, so that's why it's not indexed by hoogle then
20:33:59 <elliott> it's being split up
20:33:59 <olsner> why did it get deprecated?
20:34:03 <elliott> into a bunch of mostly-haskellninetyeight packages
20:34:03 <monqy> is there any way to cleanly encapsulate the unsafePerformIO
20:34:17 <monqy> alternatively, construct everything else in such a way that doing this wackness isn't necessary
20:34:19 <elliott> olsner: I think because it's really huge and unfocused (= big monolithic dependency), plus it relies on like five thousand extensions
20:34:28 <elliott> olsner: so he's trying to separate everything into really portable haskell ninetyeight code
20:34:33 <elliott> and separate out the unportable stuff
20:34:40 <elliott> while putting it all into different packages
20:36:38 <olsner> makes sense, I guess
20:37:34 <elliott> dunno where the replacement for that module is though :D
20:38:19 <Deewiant> ?ty let f _ [] = return Nothing; f p (x:xs) = p x >>= \b -> if b then return (Just x) else f p xs in f -- there's your map in IO
20:38:20 <lambdabot> forall a (m :: * -> *). (Monad m) => (a -> m Bool) -> [a] -> m (Maybe a)
20:38:44 <elliott> Deewiant: Heh :P
20:38:57 -!- CakeProphet has quit (Read error: Operation timed out).
20:39:17 <elliott> monqy: hmm, if you use (0 9) as an environment key, then mutate the car so it's (9 9), should the environment key mutate or should environment keys get copied
20:39:21 <elliott> (answer: the latter)
20:39:32 <elliott> but what if you get (0 9) out of the keys list of the environment, and mutate it, WHAT THEN
20:39:44 <elliott> (answer: it should probably copy keys before giving them back, too)
20:40:12 <monqy> yep
20:41:43 <olsner> functor fixpoints are easy to define when you need one, so if category-extras is deprecated you can just opt not to use it
20:41:52 -!- CakeProphet has joined.
20:50:11 <elliott> monqy: Hmm, I could make map keys be immutable
20:50:16 <elliott> monqy: By making a version of AnteValue with no IORefs
20:50:21 <elliott> Or parameterising it on the type of references
20:50:27 <elliott> monqy: But, ugh, that seems like a Pain
20:50:30 <monqy> would this fix your broken
20:50:41 <elliott> monqy: Maybe
20:55:49 -!- KingOfKarlsruhe has quit (Quit: ChatZilla 0.9.87 [Firefox 5.0/20110615151330]).
21:14:37 -!- cheater_ has joined.
21:33:17 -!- hagb[4]rd has joined.
21:33:21 -!- MigoMipo has quit (Read error: Connection reset by peer).
21:35:20 -!- azaq23 has quit (Quit: Leaving.).
21:39:22 -!- hagb[4]rd has changed nick to hagb4rd.
21:44:05 -!- CakeProphet has quit (Ping timeout: 252 seconds).
21:45:19 -!- CakeProphet has joined.
21:45:19 -!- CakeProphet has quit (Changing host).
21:45:20 -!- CakeProphet has joined.
21:54:51 -!- |||Ksarks||| has joined.
21:56:09 -!- |||Ksarks||| has left.
22:05:49 -!- azaq23 has joined.
22:07:20 -!- CakeProphet has quit (Ping timeout: 276 seconds).
22:07:54 -!- CakeProphet has joined.
22:07:54 -!- CakeProphet has quit (Changing host).
22:07:55 -!- CakeProphet has joined.
22:11:20 <tswett_> `quote 479
22:11:21 <HackEgo> 479) Nobody actually said this; this is just a demonstration.
22:11:27 <elliott> monqy: ugh this is ugly
22:11:27 <tswett_> Now, how do I get rid of it?
22:11:32 <elliott> tswett_: `delquot
22:11:32 <elliott> e
22:11:39 <tswett_> `delquote 479
22:11:41 <HackEgo> ​*poof*
22:11:54 <tswett_> It has now been delled, I guess.
22:12:01 <oerjan> `quote 479
22:12:02 <HackEgo> No output.
22:12:09 <oerjan> SO IT WOULD APPEAR
22:14:07 <monqy> elliott: ughly?
22:14:46 -!- myndzi has quit (Ping timeout: 258 seconds).
22:15:07 <elliott> monqy: yes
22:17:56 -!- cheater_ has quit (Ping timeout: 255 seconds).
22:32:53 <elliott> monqy: i just realised these changes mean you can bind an integer as a variable
22:33:08 <elliott> not that 9 will evaluate to anything, only symbols look themselves up in the environment
22:33:10 <elliott> BUT STILL
22:33:13 <oerjan> that could be a great FORTE
22:33:28 <elliott> oerjan: Funny, I just opened a buffer to implement Forte a few minutes ago.
22:34:21 <oerjan> parallel coding ftw
22:35:44 <oerjan> hm first vau, now integers as variables. is your new language gradually absorbing everything else weird?
22:36:25 <elliott> oerjan: um you realise zepto always had vau? it was just equivalent to quote (and thus not given a name), because it was dynamically scoped
22:36:28 <elliott> i.e., no environment to save
22:36:37 <elliott> so (argname . body) was an acceptable lambda representation
22:36:48 <oerjan> aha
22:36:53 <elliott> ante-zepto is lexically scoped, so it needs an actual operation to store the current environment in too
22:37:08 <elliott> oh, and it has another parameter to name the environment the fexpr is called in
22:37:19 <elliott> which didn't exist, again, in the dynamic version
22:37:28 * oerjan is divided on whether "in too" is a misspelling or not
22:37:45 <elliott> hmm, i dunno what that happened there
22:38:15 <oerjan> gramma bogons
22:39:09 <oerjan> hm could you make a TC language which had hygienic macros and nothing else
22:40:04 <oerjan> i mean something like statically scoped fexprs but with all environments implicit. also this is very vague.
22:42:09 <oerjan> ("this is very vague" is here a synonym for "i'm not sure what i mean there")
22:43:07 <oerjan> someone said recently that hygienic macros are easy to implement if you do it in the base implementation
22:43:13 <oerjan> or something like that
22:45:31 -!- Sgeo has joined.
22:46:50 <Sgeo> Will anyone be irritated if I tend to disconnect and reconnect a lot?
22:47:04 <elliott> Yes.
22:47:53 -!- Sgeo has quit (Client Quit).
22:50:14 -!- foocraft has joined.
22:50:53 -!- CakeProphet has quit (Ping timeout: 276 seconds).
22:51:40 <oerjan> we _almost_ have an established policy that bots will be banned it they do that. which means we might have to administer a turing test to sgeo, and that could get ugly.
22:52:02 -!- CakeProphet has joined.
22:52:14 <Phantom_Hoover> oerjan, suggest we begin as soon as he reënters.
22:53:12 <oerjan> eek, what have i done.
22:58:11 <elliott> `addquote <Sgeo> Will anyone be irritated if I tend to disconnect and reconnect a lot? [...] <oerjan> we _almost_ have an established policy that bots will be banned it they do that. which means we might have to administer a turing test to sgeo, and that could get ugly.
22:58:12 <HackEgo> 479) <Sgeo> Will anyone be irritated if I tend to disconnect and reconnect a lot? [...] <oerjan> we _almost_ have an established policy that bots will be banned it they do that. which means we might have to administer a turing test to sgeo, and that could get ugly.
23:16:26 <elliott> "Any scripting language (Python, Ruby, Perl) will IMO teach bad practices. Start off with something with more structure and less help. C++ or Java.
23:16:26 <elliott> Higher level scripting languages come with conveniences that are not found at other levels of programming. Callback functions, .each loops, dynamic typing, built-in operators, libraries. These are all detrimental to your overall mindset. Limit the comforts available until he can create those comforts himself.
23:16:26 <elliott> Start off dumb. Working in something like C++ or Java that forces you to choose a type for your variable and offers excellent language structure enhances your ability to think like a programmer. Then moving on to "smarter" languages will be easier."
23:16:28 <elliott> HAHAHAHA OH WOW
23:16:34 <elliott> THIS WAS ACTUALLY NOT VOTED DOWN INTO OBLIVION
23:16:54 <elliott> "START WITH A LOW LEVEL LANGUAGE, NOT HAVING TO THINK ABOUT MINUTIAE DAMAGES THINKING ....... SO CLEARLY USE JAVA, THE MOST LOW-LEVEL OF ALL LANGUAGES"
23:16:58 <elliott> PFFAFAPAHAHAHAHAAHAHAHAHAHAHAHAAHAHAHA
23:18:59 <monqy> Start off dumb.
23:19:06 <monqy> (this is dumb)
23:23:11 <monqy> i wonder what that guy would say about starting with a functional language
23:23:38 <elliott> THATS SO MANY STEPS ABOVE JAVA ITS BAD
23:24:04 <newsham> java is a functional language
23:25:13 <newsham> its just a little verbose
23:26:17 <Phantom_Hoover> elliott, link to comment?
23:26:42 <elliott> http://programmers.stackexchange.com/questions/9621/teach-linux-programming-to-home-schooled-15-year-old, found while absent-mindedly traversing the graph of programmers.stackexchange, a terrible place.
23:28:19 <Phantom_Hoover> "If this is a learning experience, something like R is probably the most useful thing. It will teach him problem-solving skills as well as the ability to load and analyze data files, which is also very useful."
23:28:34 <Phantom_Hoover> I have picked up the general impression from here that R is somewhat insane.
23:28:38 <newsham> http://www.thenewsh.com/~chat/j/XXPrelude.java
23:28:54 <newsham> oops, http://www.thenewsh.com/~chat/j/XPrelude.java this one
23:30:00 <elliott> newsham: meh, it's not impressive until you get monads
23:30:05 <elliott> I think http://functionaljava.org/ has them :P
23:30:09 <newsham> not there yet
23:30:21 <newsham> i havent tried to play with typeclasses at all
23:30:31 <elliott> monads have nothing to do with typeclasses.
23:30:40 <elliott> you would want to implement it as
23:30:47 <Phantom_Hoover> newsham, are the Xes for X-rated?
23:30:58 <elliott> data Monad m = Monad { return :: forall a. a -> m a; bind :: forall a b. m a -> (b -> m b) -> m b }
23:31:01 <elliott> i.e. simply an interface
23:31:04 <elliott> Monad<T>
23:31:16 <monqy> who was it that did pattern matching in java
23:31:18 <newsham> phantom: X's for "lets try another approach, maybe i should rename this to preserve the original" :)
23:31:27 <monqy> using exceptions or something like that
23:31:53 <newsham> also you dont need teh monads to be funkshunal
23:32:39 <Phantom_Hoover> newsham, yeah, but without them you lack monad tutorials, a vital part of any functional programming community.
23:33:27 <elliott> newsham: ok then, HLists
23:33:28 <elliott> // A lot of type annotation
23:33:28 <elliott> final HAppend<HNil, HCons<Double, HCons<String, HCons<Integer[], HNil>>>,
23:33:28 <elliott> HCons<Double, HCons<String, HCons<Integer[], HNil>>>> zero = append();
23:33:28 <elliott> final HAppend<HCons<Boolean, HNil>, HCons<Double, HCons<String, HCons<Integer[], HNil>>>,
23:33:29 <elliott> HCons<Boolean, HCons<Double, HCons<String, HCons<Integer[], HNil>>>>> one = append(zero);
23:33:30 <elliott> final HAppend<HCons<Integer, HCons<Boolean, HNil>>, HCons<Double, HCons<String, HCons<Integer[], HNil>>>,
23:33:31 <newsham> the view of half of the community is that not supporting monad tutorials is a feature
23:33:33 <elliott> HCons<Integer, HCons<Boolean, HCons<Double, HCons<String, HCons<Integer[], HNil>>>>>> two = append(one);
23:33:36 <elliott> final HAppend<HCons<String, HCons<Integer, HCons<Boolean, HNil>>>,
23:33:38 <elliott> HCons<Double, HCons<String, HCons<Integer[], HNil>>>,
23:33:42 <elliott> HCons<String, HCons<Integer, HCons<Boolean, HCons<Double, HCons<String, HCons<Integer[], HNil>>>>>>>
23:33:45 <elliott> three = append(two);
23:33:47 <elliott>
23:33:49 <elliott> god bless functionaljava
23:33:58 <Phantom_Hoover> newsham, yeah, but that half is just bitter that they can't write a monad tutorial.
23:34:18 <newsham> whoa.. there are people who havent written monad tutorials?
23:34:20 <newsham> i dont believe you
23:34:29 <elliott> "@rei: Well, I have advanced social skills, [...]" --programmers.stackexchange
23:34:33 <oerjan> i have never written a monad tutorial.
23:34:37 <elliott> oerjan: yet
23:34:41 <newsham> oerjan: perhaps you have and you didnt realize it
23:34:47 <oerjan> ooh
23:34:57 <elliott> oerjan: I believe you've tried to explain them in here before :D
23:34:59 <Phantom_Hoover> oerjan, little do you realise that everything you say and do is part of that great monad tutorial we call life.
23:35:05 <newsham> did you write any tutorials that are isomorphic to monad tutorials?
23:35:08 <elliott> `addquote <Phantom_Hoover> oerjan, little do you realise that everything you say and do is part of that great monad tutorial we call life.
23:35:09 <HackEgo> 480) <Phantom_Hoover> oerjan, little do you realise that everything you say and do is part of that great monad tutorial we call life.
23:35:12 -!- Sgeo has joined.
23:35:47 <newsham> leggo my ego
23:36:13 <oerjan> life, a reverse state monad
23:37:10 <newsham> happy 4th of july, state monad!
23:37:20 <Sgeo> Wired does not, in fact, seem to be faster than wireless
23:38:02 <Phantom_Hoover> newsham, the 4th ended 40 minutes ago.
23:38:10 <newsham> Mon Jul 4 13:34:50 HST 2011
23:38:15 <Phantom_Hoover> At least in civilised timezones.
23:38:27 <monqy> the 4th doesnt matter there
23:38:44 <newsham> typical european response... assume all islanders are uncivilized
23:38:59 <Phantom_Hoover> monqy, sorry who did they declare themselves independent from.
23:39:09 <elliott> newsham: You're all uncivilised, apart from the natives.
23:39:19 <oerjan> ...americans are islanders and brits not, now?
23:39:37 <newsham> we didnt much care for all the taxation without representation, phantom.
23:39:51 <newsham> although these days the radical right seems to be fighting for less representation.
23:39:55 <oerjan> oh hawaii
23:40:04 <monqy> fourth makes me mad
23:40:12 <newsham> fourth makes me drunk
23:40:15 <monqy> loud noises and idiocy makes my head ache
23:40:21 <newsham> but drunk does not make me mad
23:40:45 <elliott> monqy: loud noises are unzepto
23:40:57 <monqy> what about idiocy i hope
23:41:11 <elliott> yes
23:41:43 <oerjan> elliott: have you considered the possibility that zepto may not be implementable in this imperfect world
23:41:55 <Phantom_Hoover> newsham, yeah but the fundamental point is that you were a British colony so you logically declared independence in British time true fact.
23:42:15 <newsham> i was never a british colony
23:42:53 <newsham> most of me was being kicked around eastern europe at the time this all went down
23:42:58 <elliott> 05:34:29: <elliott_> oerjan: ah. you would think. but a failed bootstrapping is not very zepto.
23:42:58 <elliott> 05:34:43: <elliott_> and if you lose the binary, as zepto people are wont to do, then that would make it a very un-zepto situation.
23:42:58 <elliott> 05:34:55: <elliott_> also, compilers are un-zepto, so that's just too recursive for the universe to handle.
23:42:58 <elliott> 05:35:02: <elliott_> although that, in itself, is very zepto, we are unfortunately constrained.
23:42:58 <elliott> 05:35:05: <elliott_> we cannot achieve true zepto.
23:43:00 <elliott> 05:35:08: <elliott_> we can only achieve universal zepto.
23:43:02 <newsham> or at least most of the people who led to me
23:43:02 <elliott> oerjan: caret
23:43:04 <elliott> from yesterday
23:43:06 <oerjan> Phantom_Hoover: but timezones weren't invented back then!
23:43:34 <newsham> didnt ben franklin help come up with daylight savings time? did that happen before ther ewere timezones?
23:43:45 <monqy> daylight savings time is the worst
23:43:56 <Phantom_Hoover> newsham, so you are therefore inextricably tied to eastern European time Q.E.D.
23:44:11 <newsham> phantom: some would say I'm the white devil.
23:45:20 <Phantom_Hoover> newsham, I thought that was a drink.
23:45:43 <elliott> dst is unzepto
23:46:02 <oerjan> <newsham> most of me was being kicked around eastern europe at the time this all went down <-- wait does this mean newsham isn't your real name
23:46:56 <newsham> one out of four of my grandparents were called newsham
23:46:58 <newsham> this much is true
23:47:05 <oerjan> ah.
23:47:43 <Phantom_Hoover> oerjan, what, do you think they didn't have pigs that announced current events in eastern Europe?
23:48:04 <oerjan> Phantom_Hoover: well it _could_ be translated of course.
23:48:06 <newsham> phantom: check out newsham.com
23:48:11 <newsham> (not my site, btw)
23:48:20 <newsham> but you might chuckle anyway
23:48:25 <Phantom_Hoover> Very good.
23:48:40 <oerjan> Moses Neuesschinkel
23:48:49 <newsham> apparently lots of pig farming in the newsham line
23:48:51 <Phantom_Hoover> Is that German?
23:49:30 <elliott> newsham: that isn't real is it?
23:49:36 <newsham> it is
23:49:44 <newsham> pig genetics
23:49:44 <elliott> huh
23:49:47 <elliott> SuperMom™ Maternal Line
23:49:47 <elliott> Your choice for performance and longevity. A proven maternal leader.
23:49:48 <elliott> SuperMom™ 37
23:49:52 <elliott> i want a SuperMom™
23:50:19 <newsham> some of the newsham/newsome coat of arms have pigs on em, too
23:51:22 <Phantom_Hoover> Stop flaunting your fancy family coat of arms.
23:52:01 <oerjan> your SuperMom™ so fat, she can be used in the penrose process
23:52:06 <newsham> not to worry, recent family is all poor working class
23:52:20 -!- Vorpal has quit (Ping timeout: 260 seconds).
23:52:46 <Phantom_Hoover> newsham, yeah, but there are like no interesting people with my last name.
23:53:26 <newsham> you have a low self opinion?
23:54:09 <newsham> i assume you have your last name
23:54:20 <oerjan> <newsham> didnt ben franklin help come up with daylight savings time? did that happen before ther ewere timezones? <-- last i heard he was joking.
23:55:20 <elliott> Phantom_Hoover: your name is cool tho
23:55:22 <elliott> mine is just boring
23:57:02 <oerjan> our family was so poor their coat had no arms
23:57:04 <Phantom_Hoover> newsham, yeah, but I mean actual Googleable people.
23:57:18 * Phantom_Hoover swatpans oerjan --==\#/
23:57:29 <newsham> google, the foundation of all credibility!
23:57:37 <newsham> no google, never happened.
23:59:05 <Phantom_Hoover> Indeed.
←2011-07-03 2011-07-04 2011-07-05→ ↑2011 ↑all