←2012-01-09 2012-01-10 2012-01-11→ ↑2012 ↑all
00:00:09 <shachaf> kmc: Right, it's an actual change.
00:00:13 <elliott> kmc: Well, it's a relatively trivial change, requires no changes to the language itself, and GHC does it...
00:00:15 * shachaf has yet to figure out how to read that smiley.
00:00:17 <kmc> this is "GHC rejects some programs which should be accepted"
00:00:18 <kallisti> what's the name of this new extension we're discussing?
00:00:25 <kmc> kallisti, it doesn't have a name, that's the problem
00:00:27 <elliott> kallisti: -X
00:00:36 <shachaf> Defeated Monster X!
00:00:38 <elliott> (That's -X followed by a segmentation fault.)
00:00:39 <kallisti> ...wat
00:00:48 <kmc> the "extension" is that GHC removed the Eq and Show superclasses on Num
00:00:53 <kmc> regardless of whatever -X flags you specify
00:01:09 <kmc> so it's *not* standards-compliant and code written for Haskell 98 or Haskell 2010 will break
00:01:14 <kmc> and this has already been observed in standard libraries
00:01:33 <kmc> now, I think it might be technically difficult to make this controllable by an -X fla
00:01:35 <kallisti> but it's way better
00:01:36 <kallisti> so cool
00:01:41 <kallisti> good job GHC
00:02:08 <kmc> cause it's bad if some code writes an instance for base:Prelude.Num and other code needs an instance for haskell2010:Prelude.Num
00:02:34 <kmc> but I think this suggests we should live with the problem
00:02:41 <kmc> which after all people have been working around for years
00:02:44 <kmc> it's not hard to work around it
00:03:08 <kmc> kallisti, I'm worried that in a few years, GHC will have fifteen divergences from standard Haskell which can't be disabled
00:03:18 <elliott> kmc: What's the practical difference between GHC springing a breaking change on everybody all in one go, and Haskell 201X doing so?
00:03:26 <kmc> and are undocumented, or mentioned in passing in obscure paragraphs all over the manual
00:03:36 <kmc> elliott, ^^
00:03:55 <kallisti> I don't think it's typically a good idea to perpetuate an existing flaw, building an ever-increasing base of code that will break if any changes occur, all for the sake of "not breaking code"
00:03:57 <elliott> kmc: Well, I think that's a bit of a slippery slope argument.
00:04:07 <kmc> elliott, some slopes are slippery, though
00:04:08 <kmc> shrug
00:04:12 <kmc> i think i've made my case
00:04:15 <elliott> kmc: Are you sure it isn't already in the docs?
00:04:15 <kmc> i don't need to say it over and over
00:04:21 <kmc> elliott, I didn't say it isn't
00:04:31 <elliott> Okay.
00:04:48 <kmc> it might be "nobody's problem" since it's technically in a library, not GHC itself
00:04:53 <kmc> and i mean how many people read the haddocks for Prelude.Num
00:05:14 <kallisti> actually what code would that break.
00:05:15 <kmc> you should not have to read the library documentation for the entire standard library to know the ways it differs from the published spec
00:05:24 <kallisti> removing the superclass constraint on Num
00:05:25 <kmc> kallisti, if you have «f :: (Num a) => ...», and you use Eq or Show constraints within f
00:05:34 <kallisti> ah
00:05:38 <kmc> and it's not "would", this has already been observed in standard libraries, which need patching to compile under GHC HEAD
00:05:47 <kallisti> the solution of course is to never use type signatures in your code. :>
00:05:51 <kallisti> this ensures future compatability.
00:05:55 <kmc> hehe
00:05:56 <kmc> yes
00:06:06 <elliott> I think I would care a lot more about GHC being standards compliant if the Haskell standards process actually moved at a reasonable pace and added in widely-used extensions.
00:06:18 <kallisti> there should be something like a type signature that's ignore. oh wait that's just a comment.
00:06:24 <elliott> Right now, I don't think it's practical to try and get a breaking change in through the standard at all.
00:06:25 <kallisti> from now on I'm going to comment out all of my unecessary type signatures
00:06:36 <kallisti> to prevent my code from breaking due to an explicit type signature that later needs to be changed.
00:06:41 <kmc> elliott, if GHC produced a Haskell Report-quality specification of the language they implement, I think it would remove most of my objections
00:06:46 <kmc> but they don't
00:06:55 <kmc> not that the Haskell Report is super high quality either
00:07:19 <elliott> I think the Report just needs to be less conservative, and come out a lot more often (I think they're already trying to do the latter).
00:07:35 <kmc> but it's much closer to a language description than Section 7 of the GHC Manual
00:08:33 <kmc> i just wanna know what language i'm using
00:08:39 <kallisti> I think that change is simple enough that you could literally just write a script that fixes all the broken code.
00:08:40 <kmc> even if it's specified unilaterally by some compiler writers
00:08:45 <kmc> kallisti, do it
00:10:19 -!- Jafet has quit (Ping timeout: 252 seconds).
00:10:59 <oerjan> <kallisti> to prevent my code from breaking due to an explicit type signature that later needs to be changed. <-- ah but there have _already_ been ghc changes that required you to put signatures where you didn't before (local monomorphism when type families are used)
00:11:17 <oerjan> *didn't need them
00:11:21 <kallisti> oerjan: I believee I said unnecessary type signatures
00:11:27 <kallisti> as in the ones that aren't needed
00:11:29 <kallisti> for anything
00:11:35 <oerjan> kallisti: they _weren't_ necessary before that change
00:11:51 <kallisti> okay.
00:11:55 <kallisti> that's not what I'm saying though
00:12:15 <kmc> at least those changes only apply if you're already using an extension
00:12:27 <kallisti> kmc: there's the Easy but maybe Bad way and then the Technically Correct in EVery Circumstance But Complicated Way
00:13:06 <kallisti> kmc: the easy way would be to substitute every type signature that contains a Num instance with the output from GHC's type inference command
00:14:29 <kallisti> but that's not always the correct thing to do.
00:15:37 <kmc> i didn't ask how to do it
00:15:38 <kmc> i said you should do it
00:16:03 <kmc> i would think the easy way is to translate the context (Num a, ...) to (Num a, Eq a, Show a, ...) everywhere
00:16:34 <kallisti> no.
00:16:36 <kallisti> well
00:16:40 <kallisti> if it's all old code
00:16:41 <kallisti> then yes.
00:16:48 <kmc> yeah, that was my assumption
00:16:58 <kmc> in #haskell it's often declared that X isn't a problem because you could just write library/tool Y
00:17:04 <kmc> but most of those libraries/tools never get written
00:17:36 <kallisti> I thought that was what they say in #perl
00:17:39 <kmc> because most of the effort is all the "trivial engineering" of actually writing the damn code, debugging it, writing a test suite, documenting, packaging, publishing, etc
00:17:47 <kallisti> oh wait
00:17:51 <kallisti> no in #perl it's s/write/use/
00:18:31 <kallisti> kmc: so "trivial"
00:18:36 * oerjan swats kallisti for dangerous play with fire -----###
00:18:58 <kallisti> anyway if I ever have a programming language that people use
00:19:02 <kallisti> the way I'll prevent breaking code
00:19:11 <kallisti> is to just make sure every change has an associated script that fixes all the old code.
00:19:20 <kmc> so hard
00:19:44 <kallisti> either that
00:20:33 <kallisti> or I'll have some insane system whereby you can specify versions of the language and allows a module to be executed as though it were in the past PERFECTLY WITH NO DIFFERENCES AT ALL.
00:20:37 <kallisti> should be trivial to implement
00:20:54 <kmc> haha
00:21:06 <kallisti> well, it would be reasonable with like... "normal" code
00:21:11 <kmc> yes "trivial"
00:21:20 <kmc> "trivial" is just a douchebag way to say "easy"
00:21:28 <kallisti> low-level code would of course be pretty much impossible to accomodate in such a way
00:21:33 <kmc> except the things declared to be "trivial" aren't even easy, they're just theoretically uninteresting
00:21:48 <kmc> a problem is "trivial" if it would take 20 people 2 years to solve that problem, but they won't get a paper out of it
00:22:05 <kallisti> Perl JIT? trivial
00:22:09 <kallisti> (this is my life goal)
00:22:11 -!- rdrp has joined.
00:22:11 <kmc> right exactly
00:22:31 <kallisti> hello #esoteric would you like to be my 20 people and help me develop a perl 5 JIT?
00:22:45 <kallisti> it would basically be the best thing ever.
00:23:05 <kallisti> it would be "okay perl is efficient now I can stop programming in everything else"
00:23:17 <kallisti> (not really but it would be nice)
00:24:22 <kallisti> I wonder what makes LuaJIT so fast.
00:24:24 <kmc> Python is much closer to having a usable JIT
00:24:32 <kallisti> which is that?
00:24:33 <kmc> kallisti, I saw a detailed writeup of that once... but I can't find it anymore :/
00:24:37 <kmc> kallisti, PyPy
00:24:40 <rdrp> anyone wants to build an interpreter or a virtual machine for SumaMoito (see esolangs wiki)
00:24:42 <kallisti> oh right that thing.
00:24:50 <elliott> a perl 5 JIT would be theoretically interesting because it's probably almost impossible
00:24:55 <elliott> rdrp: do you?
00:25:01 <kmc> i doubt it's impossible
00:25:12 <kmc> i mean, why would it be
00:25:15 <kallisti> elliott: well you would need a normal interpreter as well as a JIT compiler.
00:25:19 <elliott> kmc: well, perl 5 is pretty strange :)
00:25:22 <kmc> i know
00:25:25 <rdrp> yes, but i am not an expert
00:25:32 <rdrp> in that codes
00:25:39 <elliott> rdrp: sounds like a learning opportunity :)
00:25:47 <elliott> i think atrapado mentioned having an implementation
00:25:53 <rdrp> yes
00:25:59 <rdrp> i am atrapado
00:26:35 <elliott> oh :)
00:26:42 <rdrp> i left the laptop in the other room
00:26:57 <elliott> atrapado, meet rdrp. rdrp, atrapado
00:27:02 <kallisti> elliott: I think you would have to basically interpret stuff like source filters and BEGIN blocks because they're necessary at compile-time
00:27:11 <rdrp> :)
00:28:53 <kallisti> I'm pretty sure this is what the perl interpreter does. before compile-time finishes (or even begins, in the case of BEGIN blocks) it has to execute Perl code.
00:29:08 <rdrp> well maybe i build something if i have time and motivation
00:31:33 <rdrp> hope it collapses
00:31:57 <kallisti> elliott: maybe one day Perl 6 will have a JIT. after they finish defining the language's syntax almost entirely in Perl 6.
00:32:36 <rdrp> i expect partial optimizations, even optimizations
00:32:41 <elliott> kallisti: WTF do you think Parrot is?
00:33:06 <kallisti> elliott: an interpreted bytecode language?
00:33:37 <monqy> http://esolangs.org/wiki/Parrot of course
00:35:01 <kallisti> the example resembles Python way more than it resembles Perl.
00:35:31 <monqy> but it uses <> and $_ !!!!
00:36:22 <kallisti> ah good they renamed "Parrot magic cookie" to something less stupid sounding.
00:36:33 <kallisti> now it's "polymorphic container"
00:39:15 <monqy> but parrot magic cookie is a good name
00:40:26 <kallisti> is parrot actually good?
00:40:31 <kallisti> I don't know its isntructions
00:41:13 <oerjan> kallisti: polly morphic cracker
00:42:02 <kallisti> they should suddenly switch from Parrot to LLVM
00:42:05 <kallisti> it would be such a good idea
00:42:09 <kallisti> trivial to implement too
00:44:15 <kallisti> elliott: so you have your very own reduceron yet?
00:45:41 <kallisti> I'm guessing it's the target platform for @
00:50:08 <oerjan> no @ uses a nanobot network http://xkcd.com/865/
00:50:50 <kmc> trivial
00:50:59 <kmc> just like google's failed llvm jit for python was trivial
00:52:15 -!- Nisstyre has quit (Ping timeout: 240 seconds).
00:57:31 <elliott> kmc: Trivial trivial trivial.
00:57:41 <elliott> <kallisti> elliott: an interpreted bytecode language?
00:57:52 <elliott> kallisti: Ah, it's one of those things where you're wrong.
00:57:59 <kmc> lols
00:57:59 <kallisti> ???
00:58:38 * elliott wants a tool that's like LMGTFY, but also automatically clicks on an article linked to in the results and highlights a certain phrase.
00:58:45 <elliott> In this case it would be Parrot's Wikipedia article.
01:00:04 <itidus21> so what is hoogle?
01:00:11 <kmc> let me hoogle that for you
01:00:16 <itidus21> i can tell it means haskell google.. but that doesn't quite
01:00:20 <oerjan> @hoogle hoogle
01:00:21 <lambdabot> Can't think of anything more interesting to search for?
01:00:21 <lambdabot> package hoogle
01:00:36 <itidus21> does it search haskell libraries?
01:00:54 <elliott> http://www.haskell.org/hoogle/?hoogle=%28a+-%3E+b%29+-%3E+%5Ba%5D+-%3E+%5Bb%5D
01:00:54 <itidus21> anyway.. it gives me an idea
01:01:10 <kmc> itidus21, http://lmgtfy.com/?q=hoogle
01:01:54 <itidus21> the idea it gives me is
01:02:00 <elliott> kmc: You can't assume if you learn.
01:02:11 <itidus21> a source code search in google and bing
01:02:21 <kmc> google had one; they shut it down
01:02:31 <elliott> Not yet: http://www.google.com/codesearch
01:02:31 <itidus21> oh
01:02:35 <kmc> derp
01:02:40 <elliott> It's up for a few more days.
01:02:46 <kmc> heh
01:02:48 <itidus21> wow
01:03:21 <itidus21> god damn it are there no concepts in the world that have yet to be implemented
01:03:21 <oerjan> does this mean that itidus21 getting ideas actually ends up wiping them out from reality?
01:04:00 <oerjan> itidus21: space elevator
01:04:00 <elliott> itidus21: There are, you just haven't thought of any.
01:04:29 <itidus21> brainfuck on that codesearch would be nice
01:05:27 <kmc> itidus21, well you'd have a better chance coming up with new ideas if you learned more of the existing ones
01:05:35 <kmc> like i think everything i've seen you say about haskell is wrong
01:05:55 <itidus21> http://www.google.com/codesearch#search/&q=%22,[.,]%22&type=cs
01:05:59 <kmc> also you were unwilling to even use google to find out what hoogle is
01:06:13 <kmc> that's a bad sign for the kind of intellectual curiosity needed to come up with new concepts
01:06:45 -!- Nisstyre has joined.
01:06:57 <elliott> kmc: Before Haskell, it was the lambda calculus. Unfortunately, we taught him too much lambda calculus for him to use it as a symbol of whatever he needs a symbol of.
01:07:26 <kmc> haha
01:07:31 <kmc> luckily haskell is a much larger language
01:07:44 <kmc> it's possible to go on not-learning Haskell indefinitely
01:07:58 <Gregor> Argh. "oocalc" (and "socalc") were relatively unambiguous, you could get to them with the characters then [tab], but "localc" is /maximally/ ambiguous, you have to type the whole thing >_<
01:08:03 -!- rdrp has quit (Ping timeout: 268 seconds).
01:08:05 <elliott> local c
01:08:12 <Gregor> INDEED
01:08:13 <kmc> lol cock?
01:08:22 <elliott> dude
01:08:27 <elliott> cock isn't spelled calc
01:08:28 <elliott> and
01:08:30 <elliott> lol has an l on the end
01:08:35 * Gregor nods sagely.
01:08:44 <kmc> there's no i in threesome
01:09:20 <itidus21> i found the most compact language to be unary lambda calculus 11111111111. next in line is binary lambda calculus 0010101010. and next is SK combinatory logic (SK(SKSKSK(S((SS(SSS or something.
01:09:31 <kmc> what about gzipped perl
01:09:42 <pikhq_> kmc: I'm not sure gzip will help.
01:09:46 <itidus21> next i guess is P"
01:09:52 <kmc> i bet i can write a web server in gzipped perl which is shorter than one in unary lambda calculus
01:09:54 <pikhq_> Perl's already pretty high in entropy.
01:10:06 <kmc> pikhq_, bah, it's all ASCII
01:10:21 <kmc> that's a 12.5% waste right there
01:10:22 <monqy> gzipped unary lambda calculus
01:10:23 <pikhq_> Ah, right, so there's some room for Huffman to help.
01:11:16 <kmc> haskell fanboys who don't know the language are probably less annoying than haskell bashers who don't know the language
01:11:22 <kmc> don't know which one is more common
01:11:35 <kallisti> latter I think
01:11:55 <kmc> yeah i think so too
01:12:02 <kmc> but it depends how you define "know the language"
01:12:10 <elliott> <itidus21> i found the most compact language to be unary lambda calculus 11111111111. next in line is binary lambda calculus 0010101010. and next is SK combinatory logic (SK(SKSKSK(S((SS(SSS or something.
01:12:14 <kallisti> unfortunately I'm not knowlegeable enough to discredit them. :P
01:12:15 <elliott> binary lambda calculus is obviously more compact than unary
01:12:26 <kmc> realistically very few programmers will ever see a payoff from learning haskell well enough to write practical production software in it
01:12:35 <itidus21> oh.. i see where i went wrong
01:12:40 <itidus21> i was measuring compact in alphabet size
01:12:50 <kmc> unary gzipped perl
01:13:35 <itidus21> and the SK( one doesn't count since it has a variable length alphabet
01:14:15 <kallisti> base256 flogscript
01:14:22 <oerjan> itidus21: erm there are just 4 letters, S, K, (, )
01:14:29 <itidus21> sure you can choose to exclude variables from your alphabets
01:14:40 <kallisti> http://answers.yahoo.com/question/index?qid=20090312200046AAJkBeI
01:14:41 <itidus21> but deep down you know you need them
01:14:44 <elliott> itidus21: the alphabet is SK()
01:14:58 <elliott> your mistake is thinking that variables like "x" and "y" are part of the SK calculus
01:14:59 <kallisti> I don't think I can imagine what base 256 would even look like. For the 36 years I have been in the computer business, I have seen base 16 (hexadecimal) representation used and on older machines octal (base 8). Base 256 would mean that you would have to come up with 256 unique single characters for each digit of the number.
01:15:03 <elliott> they're not, they're used in reasoning about it
01:15:10 <kallisti> ^, this guy doesn't have much to show for his 36 years.
01:15:11 <elliott> actual SK calculus expressions contain only S, K, and balanced parentheses
01:15:29 <kmc> codepage 437 is printable at almost every codepoint
01:15:40 <itidus21> hmm
01:15:51 <kmc> i think the only confusion is 0 vs 32 vs 255
01:15:54 <monqy> who needs parentheses when you have trees
01:15:54 <itidus21> thats bizzare
01:16:07 <kmc> and it's the default on DOS / PC BIOS stuff
01:16:13 <kmc> which is great
01:16:20 <kmc> because you can just print raw datastructures for debugging
01:16:24 <itidus21> ^bizarre
01:16:28 <elliott> kmc: As long as you're superhuman :P
01:16:29 <kallisti> monqy: who needs trees when you have parentheses
01:16:33 <monqy> :0
01:16:36 <kmc> elliott, hardly
01:16:40 <kallisti> :1
01:16:53 <kmc> in a lot of cases it'll be pretty obvious
01:17:11 <monqy> can parentheses make pears i don't think so
01:17:18 <kallisti> ya
01:17:20 <kmc> pearentheses?
01:17:33 <itidus21> elliott: ahh thats the plunge where it loses the ability to make analogies about it.. when you get rid of variables.. i hate that plunge
01:17:35 <kallisti> ((2)(3)) pears
01:17:48 <elliott> itidus21: It's called learning.
01:17:52 <elliott> You seem to have an aversion to it.
01:19:07 <itidus21> hmm
01:19:30 <kallisti> itidus21: imagine you've got these symbols. now imagine you've got these rules that transform groups of symbols into other symbols.
01:21:43 <kallisti> now repeat those rules over and over a bunch until you can't do them anymore.
01:21:56 * kallisti good at explain
01:22:27 <itidus21> i can imagine that the best reference for lambda calculus is the writings of alonzo church.
01:22:42 <itidus21> but that kind of reference is not usually practical
01:23:01 <itidus21> since its not broken into lessons and exercizes
01:23:16 <itidus21> when will people learn to write white papers as lessons and exercizes :P
01:23:41 <elliott> i don't think your problem is the references
01:24:36 <itidus21> my problem is big. experience in trying to learn things tells me that on some level i'm refusing to work for the understanding
01:25:08 <monqy> maybe you should do some reduction practice to get used to ski; have you tried that?
01:25:20 <monqy> I recommend (S I I (S I I))
01:25:27 <kallisti> IIIIIIIIIIIIIII is good
01:25:32 <itidus21> so really it is more important for me to learn to learn than it is for me to learn lamdba calculus
01:26:14 <kallisti> you can either learn by osmosis (this is what I try to do most of the time), or learn by doing, or learn by people beating you over the head.
01:26:29 <itidus21> it starts with the very small details... like my reluctance to do the dishes
01:27:20 <itidus21> i wont give everyone the run around again on this. :D
01:27:55 -!- pikhq_ has quit (Ping timeout: 240 seconds).
01:28:04 -!- pikhq has joined.
01:28:28 <kallisti> itidus21: I think if you focused as much effort on the actual problem at hand rather explaining to yourself why you can't do something because of X which is like Y ...
01:28:45 <oerjan> itidus21: i have this hunch that on some level there's a part of you that is blocking any action that might improve your self-confidence.
01:29:02 <oerjan> (i think i may have a similar part.)
01:29:04 <elliott> <kallisti> you can either learn by osmosis (this is what I try to do most of the time), or learn by doing, or learn by people beating you over the head.
01:29:10 <elliott> your parenthical ended up in the wrong place
01:29:19 <itidus21> also i think that it is often forgotten how rare knowledge of lambda calculus in the world truely is :D
01:29:25 <kallisti> elliott: the third one is just the one that happens the most often. on this channel.
01:29:46 <monqy> are you sure you don't try it
01:29:48 <elliott> and in #perl, or so i hear
01:30:04 <itidus21> i doubt anyone i have met in my life knows it
01:30:08 <kallisti> no they tried to beat me over the head but I won't let them.
01:30:09 <itidus21> except at school
01:30:33 <kallisti> it's not learning by beating-over-the-head if you're not learning anything.
01:30:59 <kallisti> #perl is just really really really eager to solve my XY problem.
01:32:12 <itidus21> learning, when it comes down to it, requires work and effort. if there is no work and effort there will be no learning
01:32:18 <kallisti> elliott: do I have some kind of reputation now? :P
01:32:48 <elliott> kallisti: Yes; it's 31, which is much lower than mine.
01:32:56 <kallisti> itidus21: I can learn the basics of some things with very little effort. mastery takes much more time.
01:33:09 <elliott> kallisti: You do have a really big X-Y problem, though.
01:33:18 <kallisti> you mean like... in general?
01:33:26 <kallisti> or are you referring to a specific XY problem.
01:33:34 * oerjan wonders if he has a big X-Y problem
01:34:23 <itidus21> i am biding my time until i can incorporate computation into my world view
01:34:45 * kallisti computes his matrix of solidity on a daily basis.
01:34:59 <oerjan> itidus21: are you familiar with the 10000 hour rule
01:35:33 <kallisti> elliott: I don't think it generally makes sense for someone to have a chronic XY problem. it really depends on what they're doing...
01:35:39 <itidus21> according to a wiki page, Platonic abstractions are not spatial, temporal, or mental they are not compatible with the later Idealism's emphasis on mental existence. Plato's Forms include numbers and geometrical figures, making them a theory of mathematical realism; they also include the Form of the Good, making them in addition a theory of ethical realism.
01:35:47 <kmc> people can be chronically bad at identifying root causes
01:36:30 <elliott> oerjan: i don't think you need to spend 10000 hours to learn the lambda calculus.
01:37:01 <oerjan> elliott: well it's mainly that you have to actually use those 10000 hours on _something_
01:37:13 <itidus21> mathematical notations are an application of symbols
01:37:17 <kallisti> kmc: this is not true for all questions I've asked on IRC, but there are many times when people try to solve an XY problem when there is none to solve.
01:37:24 <elliott> oerjan: IRC!
01:37:27 <kallisti> I really just want them to answer my actual question, and leave me alone. :P
01:37:42 <elliott> kallisti: well everything you have said about your irc bot thing's design so far
01:37:44 <elliott> has been terrible
01:37:45 <oerjan> elliott: ooh
01:37:48 <kallisti> elliott: go on
01:37:51 <itidus21> symbols can be percieved through any of the senses
01:38:00 <elliott> so I'm inclined to think that yes, you really do have a problem.
01:38:17 <kallisti> elliott: plugins are bad?
01:38:19 <kmc> this is a weird channel
01:38:25 <itidus21> but symbols are not the world
01:38:40 <kallisti> kmc: what did you expect? :P
01:38:47 <kmc> kallisti, right, it's bad if channels see XY problems where there are none; that was my experience in #python
01:38:58 <kmc> they get a lot of clueless noobs with terrible ideas
01:39:11 <kmc> and so if you ask how to do something weird, they assume you are a clueless noob with a terrible idea
01:39:15 <kallisti> I think some people actually just look for an XY problem to solve because they assume that's the case 99% of the time.
01:39:35 <kmc> in my case i had fairly good reasons for doing the weird thing, which took a while to explain
01:39:45 -!- pikhq_ has joined.
01:39:49 <kmc> (i was asking which Python text-templating library would be best for generating C++ code)
01:39:53 <monqy> itidus21: smell symbols? taste symbols?
01:39:58 <itidus21> monqy: yup
01:40:12 <kallisti> actually many questions I've asked on #perl were asked while in the process of figuring out /what/ I want to do. so I go in, ask some insane question, and they respond with disdain and THEN ask what I'm trying to do.
01:40:16 <kallisti> it should be the other way around.
01:40:26 <kmc> (which is a pretty WTF question, but I had a good reason
01:40:50 <itidus21> as for taste, the army developed a device which can touch the tongue and feed data into the brain from a camera which can be percieved as a black and white image in the visual field
01:40:52 <itidus21> something like that
01:41:08 <kallisti> elliott: so far the only bad idea I've had is attempting to hotswap my code sanely.
01:41:16 <kallisti> er rather
01:41:31 <kallisti> bad idea I've had and mentioned extensively on this channel, about my IRC bot. /anti-lawyering
01:42:07 <elliott> kallisti: also the thing where you used hideous eval tricks to do plugins
01:42:13 <elliott> also the "let's run plugins in their own directory" thing
01:42:22 <kallisti> "hideous eval tricks" = perl's internal import mechanism
01:42:23 <itidus21> monqy: about smell.. if you can discriminate smells then when exposed to a series of different smells you could detect patterns
01:42:24 <kmc> speaking about #haskell because i have experience there, some specific questions are almost always XY problems
01:42:29 <elliott> also the "oh i don't like perl 5's oo system... so instead of like using one of the alternate ones I'll just do more insane metaprogramming" thing
01:42:30 <kmc> like "how do I convert IO Int to Int"
01:42:32 <elliott> also... everything
01:42:39 <kmc> or "how do I do <insane thing> with type classes"
01:42:48 <elliott> s/<insane thing>/<almost anything>/
01:42:52 <itidus21> this i can understand.. but LC is not so easy
01:43:00 <kallisti> elliott: insane metaprogramming is basically what I do with a slightly complicated project in a dynamically typed language.
01:43:03 <kallisti> it's great.
01:43:04 <elliott> "How do I define a typeclass?" "Don't. Whatever you're doing stop."
01:43:09 <kmc> pretty much
01:43:11 <elliott> kallisti: Right. So you have an X-Y problem, and it's yourself.
01:43:12 -!- pikhq has quit (Ping timeout: 268 seconds).
01:43:16 <kallisti> elliott: noep
01:43:46 <kallisti> I am not writing an IRC bot to distribute to people. I am writing an IRC bot to play around with and have fun.
01:44:07 <kallisti> I'm free to do terrible things at my leisure. I might discover something good.
01:44:26 <itidus21> it is quite surprising to me that computation is really just a branch of mathematics..
01:44:45 <itidus21> that is a big mental shift
01:45:05 <elliott> kallisti: that's utterly irrelevant to the question of whether or not you're doing things that you really shouldn't and should instead do <other thing>
01:45:17 <elliott> which is what the X-Y problem is all about; it's not "just for you" if you're asking other people to help with your problems.
01:45:19 <itidus21> something which can be drawn from this is the idea that brains are not necessarily computers
01:45:41 <kmc> itidus21, that's not a justified inference
01:45:41 <kallisti> elliott: sure it is. because what should I do? what is right in a programming situation? in this case something is an XY problem if the thing I'm asking about is actually /incapable/ of solving the problem at hand.
01:46:11 <kallisti> elliott: if it works but disgusts people. I... don't really care.
01:46:17 <itidus21> brains discovered more mathematics than what can be computed
01:46:18 <kallisti> sorry.
01:46:31 <elliott> kallisti: god this is stupid
01:46:34 <itidus21> it suggests to me that minds/brains are beyond computers
01:46:40 <elliott> "I don't have an X-Y problem because I don't care"
01:46:47 <elliott> so nihilist and edgy, man!
01:46:52 <kmc> <itidus21> brains discovered more mathematics than what can be computed <---- false
01:46:53 <kallisti> elliott: no. I also explained why it's not an XY problem.
01:47:03 <elliott> if you say so
01:47:10 <kallisti> because what is the correct thing to do depends on why you are programming something.
01:47:14 <kallisti> there is why as well as a how and a what.
01:47:26 <itidus21> >:-)
01:48:11 <elliott> kmc: who the fuck uses - dashes in an ascii arrow?
01:48:13 <elliott> you're sick
01:48:16 <kmc> haha
01:48:28 <elliott> er
01:48:29 <elliott> *4 dashes
01:48:35 <kallisti> elliott: also I do use OO just not fully. my plugin code is not "eval tricks". and I'm still not really sure why changing the CWD is a bad idea.
01:49:13 <elliott> kallisti: i forget which stage comes after denial but i look forward to it
01:49:26 <kmc> elliott++
01:49:39 <kallisti> ?
01:49:45 <kallisti> anger.
01:49:48 <kallisti> elliott: fuck you
01:50:10 <kallisti> I can't believe you exposed my terrible XY problem.
01:50:12 <elliott> great; i can deal with anger
01:50:51 <kallisti> all these eval tricks and changing of current directory so that plugins can easily refer to state within their directory
01:51:02 <kallisti> all not what I wanted
01:52:19 <kallisti> (next stage is bargaining)
01:52:41 <kallisti> elliott: how about you explain to me what the problem is with changing the CWD and I'll fix it so that it adhers to The Standards of What Is Good.
01:52:41 <elliott> i'll stop bugging you if you give me lots of money
01:52:47 <elliott> no that isn't bargaining
01:52:49 <elliott> i get literally nothing out of that
01:52:58 <kallisti> you get to sleep easy.
01:53:00 -!- itidus20 has joined.
01:53:18 <itidus20> net disconnected
01:54:18 <kallisti> elliott: oh btw the Storable interface is not actually automatically persistent and stuff.
01:54:35 <kallisti> nor is it tie-able or anything like that.
01:54:40 <elliott> I didn't propose Storable, I proposed a tie thing.
01:54:49 -!- itidus21 has quit (Ping timeout: 248 seconds).
01:55:04 <kallisti> yes the last thing you proposed was Storable. I was simply informing you that it doesn't do that.
01:55:12 <kallisti> there are obviously other ways to do it.
01:55:13 <itidus20> ok my view of computers is that they are basically representations of humans by humans for humans
01:56:09 <itidus20> i am curious whether they will ever achieve sentience but i feel it is unlikely
01:57:07 <kmc> why
01:57:20 <kmc> can't you simulate a brain with a computer
01:57:34 <shachaf> Causal powers, man.
01:57:38 <itidus20> like.. if you hollowed out a dead man's brain and replaced it with an electronic device.. theoretically you could have that device send signals to the body to move, just as an action figure moves
01:57:43 <kallisti> depends on if the universe is in general computable, I think.
01:58:00 <kmc> kallisti, even if it's not, why would we assume brains use the magical non-computable parts
01:58:10 <kallisti> yes there's that as well.
01:58:13 <itidus20> but that is still a dead body
01:58:15 <kmc> you can simulate a brain with a computer, unless magic is real and brains are magic
01:58:24 <kmc> itidus20, you are free to define "dead" that way, yes
01:58:28 <shachaf> itidus20: The body-moving isn't really the interesting part of a brain.
01:58:30 <kallisti> presumably you could simulate brain physics.
01:58:34 <elliott> kmc: For bad values of magic
01:58:44 <itidus20> hmm
01:58:50 <elliott> itidus20: You could wire a computer-simulated brain up to a robot.
01:58:51 <kallisti> but then you also have to consider that the brain exists in a biological system. it has to grow and develop from an embryo.
01:58:51 <shachaf> elliott: I think that's as good a value of magic as you're ever going to get.
01:58:55 <kmc> natural processes are predictable and therefore simulatable
01:58:59 <elliott> That's just an engineering problem.
01:59:02 <kmc> therefore anything which cannot be simulated is supernatural
01:59:17 <kmc> now some natural processes can only be simulated stochastically / statistically
01:59:29 <shachaf> Anyway I've already created a conscious entity.
01:59:32 <shachaf> And it's very happy.
01:59:35 <shachaf> elliott knows.
01:59:37 <kmc> which leads to the common "quantum consciousness" loophole argument
01:59:42 <kmc> which i think is bunk for a couple of reasons
01:59:43 <kallisti> elliott: a lot of the state in my bot is things I'd like to be human-editable.
01:59:53 <kallisti> elliott: still, I could write my own tie for it.
02:00:00 <kmc> first of all, why would a stochastically predictable system with randomness be any more "conscious" than a deterministic system
02:00:17 <kmc> second, what exactly physical structure in the brain exhibits unusual / quantum-coherent behavior
02:00:19 <kallisti> oh ho a question for #perl
02:00:33 <kmc> it seems really unlikely that meat at above room temperature would have sophisticated quantum mechanical properties
02:00:48 <itidus20> the main prerequisite of life appears to be the capacity to die forever
02:00:52 <kallisti> is there a library that implements persistent hash tables that serialize to a human-editable file format?
02:01:08 <kmc> itidus20, you sound kinda stoned
02:01:21 <itidus20> i mean once a body truely dies.. its dead
02:01:27 <itidus20> theres no undying
02:01:30 <kmc> itidus20, you have defined the words such that this is true
02:01:34 <itidus20> even if its only a bacteria
02:01:35 <kallisti> itidus20: the main prerequisite to being able to die appears to be being able to be alive.
02:01:38 <kallisti> circular logic is circular.
02:01:41 <elliott> itidus20: Why do you care about bodies?
02:01:53 <itidus20> all life seems to have a body :P
02:01:57 <kmc> itidus20, basically, if I show you a technology that revives a dead bacterium, you will retroactively claim that it was "not really dead"
02:02:12 <elliott> kmc: Well, that _is_ practically the definition of information theoretic death...
02:02:38 <itidus20> kmc: hmmm... i will say that such technology suggests people could be brought back to life :D
02:02:46 <itidus20> if developed enough
02:02:48 <kmc> itidus20, i think they could, with sufficient technology
02:02:53 <Sgeo> itidus20, are the Hela cells alive?
02:02:53 <kmc> wrt our existing definition of "dead"
02:03:14 <itidus20> i dont know what a hela cell is
02:03:18 <elliott> hella cells
02:03:32 <elliott> itidus20: http://en.wikipedia.org/wiki/HeLa
02:03:42 <kmc> itidus20, we should build some kind of global hypertext information network, which could be used to answer questions like "what's a hela cell"
02:04:20 <elliott> kmc: Anyway, I think it's reasonable to claim that anything you can revive isn't dead.
02:04:31 <kmc> elliott, that's not a claim, it is a definition of the word "dead"
02:04:35 <kmc> but it is a reasonable definition
02:04:43 <kmc> i think that's exactly itidus20's problem
02:04:46 <elliott> Right.
02:05:08 <kmc> itidus20, you're making statements about your own definitions of words, but phrasing them as if they were empirically testable facts about the universe
02:05:18 <kmc> the laws of physics don't give a shit whether you are "dead" or not
02:05:21 <itidus20> its a good way to start a religion :P
02:05:33 <kmc> it's an arbitrary term humans have invented in order to efficiently categorize different arrangements of matter
02:05:40 <elliott> kmc: You seem to really enjoy beating your head against a brick wall. You must love #haskell.
02:05:45 <kmc> to predict them more efficiently without knowing microscopic details
02:05:53 <kmc> elliott, itidus20 is the brick wall?
02:06:00 <elliott> kmc: I can't possibly comment.
02:06:21 <itidus20> `searchlog itidus troll
02:06:28 <elliott> kmc: So, yes.
02:06:38 <kmc> so how come y'all hang out in a channel full of crackpots and trolls
02:06:51 <HackEgo> 2011-07-31.txt:10:31:31: <itidus20> partially because you get the sense of control over music... unlike neighbors noise which cannot be controlled
02:06:56 <elliott> kmc: "Full of"?
02:06:58 <itidus20> weird
02:07:05 <shachaf> Who're the crackpots?
02:07:06 <kmc> fsvo
02:07:14 <elliott> kmc: I count one.
02:07:31 <kmc> there are like five people here i've personally seen an accusation of trolling against
02:07:37 <kmc> and i've only been active a few days ;P
02:07:46 <elliott> People who aren't trolls can troll.
02:07:49 <itidus20> i accuse myself of trolling occasionally
02:07:51 <shachaf> I wonder how you make a trollproof IRC channel.
02:07:56 <elliott> For instance, shachaf.
02:07:58 <itidus20> however
02:08:00 <kmc> haha
02:08:12 <shachaf> elliott: Do I troll?
02:08:14 <elliott> Yes.
02:08:36 <shachaf> Hmm. This seems like it could get into another argument about definitions.
02:08:40 <itidus20> even though my methods of arguing use fallacies, and even though i like to argue for arguments sake, i stand by my things
02:08:57 <itidus20> things is a nice vague word
02:08:57 <elliott> The definition of "troll" has been progressively diluted.
02:08:57 <kmc> Is "is" as "is" is? Discuss.
02:09:11 <elliott> But you do deliberately mislead people on #haskell for humorous purposes a lot.
02:09:23 <shachaf> kmc, while elliott had had had had had had had had had had had had had had had had had had had had had had had had had had had had had had itidus20's approval.
02:10:25 <itidus20> given that lambda calculus is a model of computation, and that i refuse to comprehend LC properly, i love the question of whether the mind/brain/nervous system/etc is beyond a computer
02:10:37 <shachaf> This seems pointless.
02:10:58 <itidus20> i know that you are all being your own universes anyway
02:11:00 <kmc> the question of whether the brain is beyond a computer is beyond your brain
02:11:13 <itidus20> it will be a long time before anyone can prove any of these things
02:11:26 <elliott> itidus20: tip: whenever you say "anyone", say "I"
02:11:36 <elliott> and question whether you can really predict everyone else's abilities
02:11:47 * shachaf takes a completely extensional and reductionist view of consciousness. Hence pet.txt.
02:11:52 <shachaf> And elliott being a murderer.
02:11:55 <itidus20> its called prediction :D
02:12:05 <kallisti> elliott: so your basic complaint with my use of CWD was that it would be more sensible for the core code to hand out persistent hash tables and maintain them so that the plugin code doesn't have to worry about it, right?
02:12:05 <kmc> ttants: extensional, existential
02:13:04 <elliott> kallisti: The main reason is that it's really stupid, and there's no reason the current working directory should be privileged over the other trillion pieces of global state a Unix process running Perl has; furthermore that the way to make certain things local to a piece of code is not to rely on mutating a system global all the time to provide the illusion of a scope.
02:13:16 <elliott> What to do instead is another matter.
02:13:27 <itidus20> it also concerns me that computation leads to cubicles instead of frolicing in nature
02:13:36 <itidus20> something is not quite right with that picture
02:13:57 <itidus20> like something is missing
02:14:06 <itidus20> if computers are necessary
02:14:59 <itidus20> ok no that was trolling
02:15:20 <itidus20> KALLISTI KEEP GOING
02:16:04 <elliott> kmc: Does your computer frolick in nature?
02:16:04 <oerjan> well it's too damn cold to frolic in the nature around here, anyway
02:16:11 <elliott> *frolic
02:16:13 <oerjan> despite what those ski freaks say
02:16:14 <elliott> Magicke.
02:16:47 <itidus20> the computers give nothing back
02:17:11 <elliott> itidus20: You anthropomorphise approximately 100% more often than you should.
02:17:22 <kallisti> elliott: it's privleged because it makes it less of a pain to refer to datafiles related to the program. And yes, I want them to be in one directory because I want them to be self-contained modules. the plugin directory can possibly contain anything (you dump in an entire subprogram and then hook it up to the bot with a simple glue script)
02:17:32 <kallisti> elliott: also, the "illusion" is scope is actually not difficult to maintain at all.
02:17:36 <kallisti> *of scope
02:17:50 <kallisti> elliott: what other bits of unix state should I be concerned with?
02:18:00 <oerjan> elliott: don't you mean that he should anthropomorphise 100% _less_?
02:18:18 <kallisti> isn't that... equivalent?
02:18:21 <elliott> oerjan: He anthropomises 100% more than he should.
02:18:42 * oerjan swats kallisti for failing at percentages -----###
02:18:46 <elliott> kallisti: Is there a polite way of telling you that your response indicates to me that I won't be able to convince you you're wrong, and so I really don't think it's worth either of our time for me to bother trying?
02:19:27 <kallisti> elliott: sure. you can do it indirectly as you just did. To me, your lack of a convincing explanation is simply evidence that you don't actually have a good reason to convince me with.
02:20:09 <elliott> kallisti: To quote the Austrian philosopher kallisti, "I... don't really care".
02:20:22 <elliott> s/the //
02:20:46 <elliott> oerjan: I don't really see how what I said was incorrect.
02:21:03 <oerjan> elliott: i was just suggesting an improvement.
02:21:22 <elliott> oerjan: Well, okay.
02:24:53 <kallisti> elliott: so you don't really have a reason other than "it's gross" and "it's stupid". okay cool.
02:25:36 <shachaf> Puzzle: I didn't sleep last night. When is the optimal time to go to sleep so that I wake up at ~08:00 tomorrow?
02:25:58 <kallisti> how often do you normally sleep?
02:26:00 <elliott> kallisti: What response are you exactly trying to solicit in response to that? It's basically just a smarmy "ha ha, you can't convince me, COOL!" so you're not going to get more than a "fuck you"...
02:26:07 <kallisti> and, how often do you stay up late?
02:26:12 <elliott> shachaf: How long do you usually sleep?
02:26:18 <elliott> And what time is it now?
02:26:19 <shachaf> elliott: I don't know.
02:26:23 <elliott> And when did you wake up last?
02:26:23 <shachaf> It's 18:25 now.
02:26:28 <shachaf> I don't remember.
02:26:34 <shachaf> It sometimes takes me a few hours to wake up.
02:26:43 <elliott> OK, when did you get up, roughly.
02:26:45 <elliott> In like a 3 hour window.
02:26:50 <elliott> I'M AN EXPERT DAMMIT.
02:26:57 <shachaf> 11-13?
02:26:58 <shachaf> Maybe.
02:27:02 <kallisti> elliott: I was hoping for perhaps an explanation of a flaw with the current system? an example, for example.
02:27:09 <shachaf> ...I may have stayed in bed a long time after "waking up".
02:27:43 <kallisti> elliott: I don't just prod you because I like to make you suffer. I'm actually looking for improvements but I'm currently unconvinced that this is something that needs changing.
02:27:49 -!- pikhq_ has quit (Ping timeout: 252 seconds).
02:27:52 -!- pikhq has joined.
02:28:07 <kallisti> elliott: if you have like... actual evidence of a flaw then I would be grateful to hear about it.
02:28:32 <elliott> shachaf: 20:00 to 23:00; probably ideally before 22:00. I disclaim this advice even more than any other advice I give because of lack of decent information.
02:29:00 <shachaf> kmc: Did you hear elliott's exciting proposal for MonadZero yesterday?
02:29:02 <elliott> If you don't care about waking up early I'd just go to bed whenever.
02:29:06 <shachaf> You'd like* it.
02:29:16 <elliott> shachaf: HE'LL JUDGE ME.
02:29:20 <shachaf> elliott: I have an appointment at 09:30.
02:29:38 <elliott> shachaf: Yes, so you probably don't care much about waking up early, but don't want to wake up late.
02:29:44 <shachaf> elliott: I just mentioned it in #haskell and now people are asking.
02:29:48 <shachaf> Go join #haskel and tell them.
02:29:53 <elliott> So, 19:00 to 22:00 or something.
02:29:55 <shachaf> #haskell
02:30:38 -!- Jafet has joined.
02:31:00 <shachaf> elliott: They weren't doing that much lambdabot nonsense a few minutes ago!
02:31:21 <elliott> shachaf: I might be able to avoid explaining it!
02:31:29 <shachaf> Nope.
02:31:40 <shachaf> cmccann is there; it's the perfect opportunity.
02:32:24 <elliott> shachaf: Not until somebody who isn't you asks!!!
02:32:34 <shachaf> elliott: Peaker asked right before you joined.
02:32:39 <shachaf> 05:29 < Peaker> shachaf: nope, what was it?
02:32:42 <elliott> Yes, but I didn't hear it.
02:32:43 <shachaf> 05:29 < Peaker> shachaf: where was it?
02:32:47 <shachaf> Now you heard it.
02:32:53 <elliott> No.
02:32:56 <elliott> I am deaf to quotes.
02:33:49 <shachaf> elliott: You gotta do what you gotta do.
02:35:15 <shachaf> elliott: I see. I was just baiting the wrong person.
02:37:02 <kmc> did not hear
02:41:15 <kallisti> dynamic scoping actually works really well with global variables.
02:41:27 <kallisti> it kind of eliminates some of the criticisms of global variables.
02:41:42 <elliott> kmc: Hear what?
02:43:31 <shachaf> I like how quick dolio was to blame me.
02:43:44 <kallisti> for example Data::Dumper has both package configuration variable and instance members that you can set to override the global behavior.
02:43:48 <elliott> shachaf: Well, you *are* awful.
02:44:00 <kallisti> oftentimes it's a huge pain to use the OO interface and set all of the members every time you want to dump something.
02:44:11 <kallisti> so instead you can locally redefine the global variables for your program.
02:44:22 <elliott> shachaf: Did you know that erus` hasn't accepted my answer on SO yet?
02:44:26 <elliott> Truly a scoundrel
02:44:29 <elliott> *.
02:45:00 <shachaf> elliott: Oh. Surely erus` has accepted your answer in erus`'s heart.
02:45:36 <kallisti> also perl has fun features such as "delete local"
02:45:58 <elliott> shachaf: This awkward silence in #haskell is palpable.
02:46:13 <kallisti> !perl $x = 2; local $x = 3; delete local $x; print $x
02:46:15 <EgoBot> delete argument is not a HASH or ARRAY element or slice at /tmp/input.981 line 1.
02:46:19 <kallisti> :o
02:47:56 <kallisti> !perl use v5.10; %x = (1,2); {delete local $x{1}; say $x{1} || "nothing"} say $x{1}
02:47:57 <EgoBot> nothing \
02:48:05 <elliott> 01:27:39 <shachaf> quicksilver: Yep. There should be a foldl' genericLength.
02:48:07 <elliott> shachaf: I think there is.
02:48:12 <shachaf> Oh?
02:48:17 <shachaf> What is it called?
02:48:21 <elliott> Oh, there isn't.
02:48:26 <elliott> But there's specialisations for Int and Integer.
02:48:32 <elliott> {-# RULES
02:48:32 <elliott> "genericLengthInt" genericLength = (strictGenericLength :: [a] -> Int);
02:48:32 <elliott> "genericLengthInteger" genericLength = (strictGenericLength :: [a] -> Integer);
02:48:32 <elliott> #-}
02:48:32 <elliott> strictGenericLength :: (Num i) => [b] -> i
02:48:33 <elliott> strictGenericLength l = gl l 0
02:48:35 <elliott> where
02:48:37 <elliott> gl [] a = a
02:48:39 <elliott> gl (_:xs) a = let a' = a + 1 in a' `seq` gl xs a'
02:48:41 <elliott> strictGenericLength should probably be exported.
02:48:43 <elliott> And be called genericLength' instead.
02:48:52 <shachaf> Or maybe it should be called genericLength.
02:49:02 <shachaf> And genericLength should be called academicGenericLength
02:49:04 <elliott> shachaf: But I want length x < (4::Nat) to work. :(
02:49:28 <shachaf> elliott: Paul Graham says you should just write a function called "length<".
02:49:50 <elliott> shachaf: Gross.
02:50:44 <elliott> shachaf: Can you make grep -i less slow?
02:50:48 <shachaf> elliott: In Common Lisp.
02:50:52 <shachaf> elliott: Yes.
02:50:58 <shachaf> But I want you to suffer.
02:51:11 <shachaf> That's the only reason I disabled the "speed" option in the default Arch distribution of grep.
02:51:16 <shachaf> Are you logrepping?
02:51:40 <kallisti> `searchlog year of tool
02:51:58 <HackEgo> 2012-01-09.txt:10:23:53: <kallisti> no doubt because of my revolutionary searchlog tool of the year.
02:52:04 <kallisti> :)
02:52:13 <shachaf> `searchlog year of the tool
02:52:38 <Sgeo> elliott, kallisti update
02:52:46 <HackEgo> No output.
02:53:01 * Sgeo is not lying.
02:53:08 <elliott> shachaf: I was.
02:53:11 <kallisti> `cat `which log`
02:53:14 <HackEgo> cat: `which log`: No such file or directory
02:53:17 <kallisti> `run cat `which log`
02:53:21 <HackEgo> ​#!/bin/sh \ cd /var/irclogs/_esoteric \ if [ "$1" ]; then \ grep -P -i -- "$1" ????-??-??.txt | shuf -n 1 \ else \ file=$(shuf -en 1 ????-??-??.txt) \ echo "$file:$(shuf -n 1 $file)" \ fi \
02:53:25 <monqy> kallisti really got update guys honest
02:53:28 <shachaf> `run cat run
02:53:32 <HackEgo> cat: run: No such file or directory
02:53:36 <shachaf> `bin/run cat bin/run
02:53:40 <HackEgo> ​/home/hackbot/hackbot.hg/multibot_cmds/lib/limits: line 5: /hackenv/bin/run: No such file or directory \ /home/hackbot/hackbot.hg/multibot_cmds/lib/limits: line 5: exec: /hackenv/bin/run: cannot execute: No such file or directory
02:54:11 <shachaf> elliott: If I go to sleep too early, will I wake up in the middle of the night feeling depressed?
02:54:33 <shachaf> I pretty much am unable to think right now due to sleep deprivation.
02:55:28 <elliott> shachaf: Do you have melatonin?
02:55:32 <kallisti> how do I pop off the first word of a string in bash?
02:55:38 <shachaf> elliott: As a matter of fact, I do!
02:55:40 * elliott just takes melatonin if he wakes up in the night post-sleep-deprivation.
02:55:49 <elliott> That means you might oversleep though.
02:55:57 <elliott> Sucks to be you! Invest in an alarm or something.
02:56:02 <shachaf> elliott: Wait, that's not how you're supposed to use it, is it?
02:56:09 <elliott> shachaf: Probably not, but it works.
02:56:12 <shachaf> I thought it was for taking right before your "regular sleeping hour".
02:56:21 <elliott> I don't like to be dependent on it because it makes me groggy, so I only take it when I really need to get to sleep and can't.
02:56:31 <elliott> shachaf: Anyway, "middle of the night" is relative.
02:56:49 <elliott> If you wake up at 4 am, that's *four whole more hours* before you have to be up!
02:56:57 <elliott> That's like winning the free time lottery.
02:57:10 <shachaf> elliott: I thought it was supposed to be very different from, you know, a sleeping pill.
02:57:29 <elliott> Well, it makes you tired. That's sort of what your body uses melatonin for?
02:57:39 <elliott> I mean, if you're trying to establish a decent sleep pattern, yes, you should take it regularly.
02:58:02 <elliott> But it's not like it can do anything worse than mess up your sleep a bit.
02:59:20 <kmc> elliott, <shachaf> kmc: Did you hear elliott's exciting proposal for MonadZero yesterday?
02:59:41 <shachaf> kmc: It was decided in #haskell that it's not actually exciting.
02:59:50 <shachaf> elliott feels dejected now, I think.
03:00:02 <elliott> I'm quitting the Haskell community FOREVER.
03:00:09 <shachaf> The proposal is: class MonadZero m where { mzero :: m a; mfail :: b -> m a; mfail _ = mzero; mzero = mfail (error "mzero") }
03:00:54 -!- lambdabot has quit (Remote host closed the connection).
03:01:26 <shachaf> This lets you have informative pattern-match failure error strings without leaking source-code position information into non-IO code.
03:02:15 <elliott> @tell oerjan <Cale> Fixed @check
03:02:55 <elliott> shachaf: Come to think of it, mfail should probably be called mpatternfail or something, in that it's not useful for actually reporting errors in general.
03:04:28 <shachaf> @tell elliott <elliott> @tell oerjan <Cale> Fixed @check
03:05:01 -!- lambdabot has joined.
03:05:03 <elliott> @tell oerjan <Cale> Fixed @check
03:05:09 <lambdabot> Consider it noted.
03:05:17 <shachaf> elliott: What if I just go to sleep now?
03:05:27 <elliott> shachaf: What time is it?
03:05:29 * shachaf is seriously a zombie.
03:05:31 <shachaf> 19:05
03:05:54 <shachaf> If I sleep for 10 hours I'll wake up at 05:00.
03:05:55 <kallisti> !perl my $x = "hello"; length $x = 4; print $x
03:05:56 <EgoBot> Can't modify length in scalar assignment at /tmp/input.3107 line 1, near "4;" \ Execution of /tmp/input.3107 aborted due to compilation errors.
03:06:01 <elliott> shachaf: You'll wake up between 3 and 9 or so.
03:06:10 <shachaf> Knowing me, I'll probably wake up around 23:00 and not be able to get to sleep again.
03:06:16 <elliott> If you sleep as long as I do after sleep deprivation 11:00.
03:06:20 <elliott> But that's not likely.
03:06:42 <elliott> shachaf: I somewhat doubt you'll wake up at 23:00 if you've been awake that long.
03:06:50 <shachaf> elliott: You'd be surprised.
03:06:58 <elliott> But there's no real point staying up for the sake of a few hours.
03:07:10 * shachaf walked to Menlo Park today. It was crazy, man.
03:07:31 <shachaf> The thing is that as soon as I close the computer, I won't be able to fall asleep.
03:07:32 <oerjan> @check True
03:07:33 <lambdabot> "OK, passed 500 tests."
03:07:34 <elliott> I read that as "walked into".
03:07:39 <elliott> And I was, thinking, like, "accidentally?"
03:07:49 <shachaf> I was planning to do laundry today.
03:07:51 <shachaf> Not much chance.
03:08:03 <oerjan> @messages
03:08:04 <lambdabot> elliott said 2m 59s ago: <Cale> Fixed @check
03:09:10 <oerjan> `log zjoin.*diag
03:09:22 <HackEgo> 2011-12-31.txt:18:54:46: <oerjan> > let zjoin = diag . scanl1 (zipWith (flip const)) where { diag = concat . takeWhile (not . null) . map (take 1) . foldr (\x xs -> x:map (drop 1) xs) []}; x = [[[1,2],[3,4]],[undefined]] in (zjoin $ zjoin x, zjoin $ map zjoin x)
03:09:40 <oerjan> @let zjoin = diag . scanl1 (zipWith (flip const)) where { diag = concat . takeWhile (not . null) . map (take 1) . foldr (\x xs -> x:map (drop 1) xs) []}; x = [[[1,2],[3,4]],[undefined]]
03:09:41 <lambdabot> Defined.
03:10:01 <elliott> shachaf: Watch as oerjan attempts proof by QuickCheck.
03:10:21 <shachaf> oerjan: QuickCheck still doesn't support @let.
03:10:22 <oerjan> @check \ll -> zjoin (zjoin (ll :: [[Int]])) == zjoin (map zjoin ll)
03:10:23 <lambdabot> Couldn't match expected type `[a]'
03:10:28 <shachaf> Or does it?
03:10:31 <shachaf> s/QuickC/@c/
03:10:34 <oerjan> oops
03:10:38 <elliott> shachaf: Well, Cale just fixed it.
03:10:41 <elliott> So maybe he reworked it.
03:10:47 <shachaf> You can never know with Cale.
03:10:53 <oerjan> :t zjoin
03:10:54 <lambdabot> forall a. [[a]] -> [a]
03:11:09 <oerjan> oh duh
03:11:11 <shachaf> > zjoin ["oerjan", "elliott"]
03:11:15 <lambdabot> mueval-core: Time limit exceeded
03:11:17 <oerjan> @check \ll -> zjoin (zjoin (ll :: [[[Int]]])) == zjoin (map zjoin ll)
03:11:20 <lambdabot> "Falsifiable, after 12 tests:\n[[[-7,-4,-5,-8,0,5,6,-7],[-4]],[[7,-7,-1,-3,...
03:11:26 <oerjan> AAAAAAAAAAAAAAA
03:11:30 <monqy> did you get the wrong zjoin
03:11:34 <elliott> i like how it doesn't tell you what went wrong.
03:11:37 <elliott> *I
03:12:03 <shachaf> elliott: What happened to all those times when you didn't capitalise your 'i's?
03:12:07 <shachaf> Are you Bourbaki?
03:12:19 <kallisti> what's the character limit on IRC again?
03:12:26 <kallisti> 300?
03:12:39 <elliott> shachaf: Yes.
03:12:39 <oerjan> > let ll = [[[-1,-2],[-2],[2,-4],[2,-4,-4]],[[],[1,3]]] in (zjoin (zjoin ll), zjoin (map zjoin ll))
03:12:40 <monqy> a billion / have fun
03:12:41 <lambdabot> ([-1,3],[-1])
03:12:47 <Jafet> kallisti: you can raise it by getting a short hostname
03:12:48 <elliott> kallisti: 512, including prefix
03:12:59 <Jafet> And connecting to a server with a short hostname
03:13:00 <elliott> > let ll = [[[-1,-2],[-2],[2,-4],[2,-4,-4]],[[],[1,3]]] in (zjoin (zjoin ll), map zjoin ll)
03:13:02 <lambdabot> ([-1,3],[[-1],[]])
03:13:11 <elliott> Jafet: where is server hostname in the message?
03:13:14 <elliott> oh, server-to-server messages?
03:13:16 <elliott> *Where
03:13:24 <Jafet> I think they are
03:13:29 <elliott> Huh?
03:13:42 <Jafet> When servers send your message to other servers
03:13:58 * shachaf will try out the sleep thing.
03:14:35 <elliott> Right.
03:14:37 <elliott> shachaf: Enjoy!
03:15:30 <oerjan> > let ll = [[[-1,-2],[-2],[2,-4],[2,-4,-4]],[[],[1,3]]] in (zjoin ll)
03:15:31 <lambdabot> [[-1,-2],[1,3]]
03:16:57 <oerjan> R.I.P. monad
03:17:03 <monqy> :(
03:18:06 <elliott> oerjan: don't give up hope!!!
03:18:11 <elliott> maybe you can rectify the shape
03:18:52 <oerjan> nah it's pretty obvious what happened when you see it
03:19:58 -!- elliott has set topic: Breaking news: ZipList still not a monad! | http://codu.org/logs/_esoteric/.
03:21:14 <oerjan> basically, zjoin ll has no chance of preserving the information of the shape of the elements pruned away
03:21:39 <kallisti> > [1..]
03:21:41 <lambdabot> Could not find module `Control.Monad.Writer':
03:21:41 <lambdabot> It is a member of the hidd...
03:21:52 <kallisti> > 2
03:21:53 * oerjan blinks
03:21:53 <lambdabot> Could not find module `Control.Monad.Writer':
03:21:53 <lambdabot> It is a member of the hidd...
03:21:55 <kallisti> @undefine
03:22:01 <oerjan> whew
03:22:03 <kallisti> > 2
03:22:04 <lambdabot> Could not find module `Control.Monad.Writer':
03:22:04 <lambdabot> It is a member of the hidd...
03:22:07 <kallisti> >_>
03:22:11 <kallisti> oerjan: no, proceed to panic
03:22:19 <kallisti> @unerd
03:22:20 <lambdabot> Unknown command, try @list
03:22:20 <oerjan> @undefine
03:22:22 <oerjan> > 2
03:22:23 <lambdabot> Could not find module `Control.Monad.Writer':
03:22:23 <lambdabot> It is a member of the hidd...
03:22:24 <kallisti> @undefloon
03:22:25 <lambdabot> Unknown command, try @list
03:22:47 <oerjan> > let ll = [[[-1,-2],[-2],[2,-4],[2,-4,-4]],[[],[1,3]]] in (zjoin ll)
03:22:47 <kallisti> @und
03:22:48 <lambdabot> Could not find module `Control.Monad.Writer':
03:22:48 <lambdabot> It is a member of the hidd...
03:22:48 <lambdabot> Maybe you meant: undefine undo
03:23:00 -!- elliott has quit (Quit: Leaving).
03:23:01 <oerjan> that's weird, it must have happened seconds ago
03:23:43 <oerjan> @undefine
03:23:53 <Sgeo> How is "ZipList not a monad" breaking news? I remember someone attempted to make it a monad, I guess that failed?
03:23:58 <monqy> > help
03:23:59 <lambdabot> Not in scope: `help'
03:24:05 * oerjan swats Sgeo -----###
03:24:07 <oerjan> YES I DID
03:24:23 <kallisti> oerjan: oh it's actually not a monad?
03:24:29 -!- elliott has joined.
03:24:39 <elliott> XChat forgot my settings again.
03:24:47 <oerjan> kallisti: not with the definition i made, and i don't see how to repair it.
03:24:55 <elliott> oerjan: Anyway, couldn't you, instead of pruning, "rearrange" the shape?
03:25:23 <elliott> Pad things out by repeating shapes in places that won't affect the joined shape, and use the padded spaces to put the awkward pieces of the other argument.
03:25:26 <oerjan> elliott: for rectangular lists the outcome is fixed
03:25:31 <elliott> Erm, there's no other argument.
03:25:34 <elliott> But you sort of know what I mean.
03:25:42 <elliott> oerjan: Yes, but you could behave specially for non-rectangular lists.
03:25:55 <oerjan> ok so lessee
03:26:03 <oerjan> > 2
03:26:04 <lambdabot> 2
03:26:11 <elliott> shocking
03:26:15 <kallisti> !perl substr("", 0,undef,"...")
03:26:16 <EgoBot> Modification of a read-only value attempted at /tmp/input.5704 line 1.
03:27:14 <oerjan> @let zjoin = diag . scanl1 (zipWith (flip const)) where { diag = concat . takeWhile (not . null) . map (take 1) . foldr (\x xs -> x:map (drop 1) xs) []}
03:27:15 <lambdabot> Defined.
03:28:31 <kmc> Sgeo, it's breaking news where?
03:28:32 <elliott> kmc: Hey, do you still have that horrible value-mutating code?
03:28:40 <kmc> not handy
03:28:53 <Sgeo> kmc, topic
03:29:03 <kmc> elliott, http://hpaste.org/52266
03:29:31 <oerjan> @check \ll -> (not . null . drop 1 . group $ map length ll) || zjoin (zjoin (ll :: [[[Int]]])) == zjoin (map zjoin ll)
03:29:33 <lambdabot> "OK, passed 500 tests."
03:29:46 <elliott> kmc: cool, thanks
03:29:49 <oerjan> huh
03:29:51 <oerjan> @check \ll -> (not . null . drop 1 . group $ map length ll) || zjoin (zjoin (ll :: [[[Int]]])) == zjoin (map zjoin ll)
03:29:53 <lambdabot> "Falsifiable, after 393 tests:\n[[[-2,-1,8],[-1,3,-8,5,-8],[3,-6],[3,2,0,4]...
03:29:54 <kmc> elliott, .... why?
03:29:56 <oerjan> darn
03:30:08 <elliott> kmc: wouldn't you be happier not knowing?
03:30:35 <kmc> Sgeo, seems sarcastic... I'm guessing someone somewhere made a big deal of this and was mocked for it
03:30:48 <kmc> "ZipList is not a monad" is probably one of those things which seems obvious if you live in #haskell
03:30:53 <oerjan> wtf this rarely fails
03:30:55 <kmc> but isn't actually written down somewhere you'd find it
03:31:09 <elliott> kmc: oerjan had a definition of join he thought would work but didn't
03:31:13 <elliott> and is apparently trying to repair it now
03:31:18 <oerjan> kmc: i haven't been mocked much yet
03:31:25 <oerjan> elliott: not really much hope
03:31:29 <kmc> heh
03:31:36 * elliott is interesting in seeing a proof it's not a monad, though, since I've just seen people assert it isn't based on vague arguments
03:31:40 <elliott> *interested
03:31:59 <kmc> i think the amount of "oral tradition" in Haskell is bad
03:32:20 * elliott hasn't seen that much oral tradition.
03:33:05 <kmc> there are a lot of things #haskell can explain but can't provide a link to
03:33:34 <kmc> if you've read LYAH and RWH and wonder what's next
03:33:39 <kmc> it's hard to even discover what you should read
03:34:04 <kmc> the only way i know is to hang around #haskell and try to understand anything anyone says
03:34:11 <kmc> and read articles / papers that way
03:34:46 <kmc> but if you just go looking for "haskell articles" you'll find a) gibberish monad tutorials, and b) research papers which are irrelevant to 99% of real haskell code people write
03:35:02 <oerjan> > let ll = [[[1,2],[6],[2,4,-4,1,-5,3],[-2,4],[5,4,6,3],[-2,-6,4]],[[-2,3],[4,-5,2],[-5,4,-1,4,-6,-1],[-2,0,3],[1,-6,-4,1,4,-5],[-1,1]]] in (zjoin ll, map zjoin ll)
03:35:03 <lambdabot> ([[1,2],[4,-5,2]],[[1],[-2,-5]])
03:35:48 <kmc> similarly how do you discover which of the 3,700 packages on Hackage are worth a damn
03:36:41 <oerjan> > let ll = [[[1,2],[6],[2,4,-4,1,-5,3],[-2,4]],[[-2,3],[4,-5,2],[-5,4,-1,4,-6,-1],[-2,0,3]] in (zjoin ll, map zjoin ll)
03:36:42 <lambdabot> <no location info>: parse error on input `in'
03:36:54 <oerjan> > let ll = [[[1,2],[6],[2,4,-4,1,-5,3],[-2,4]],[[-2,3],[4,-5,2],[-5,4,-1,4,-6,-1],[-2,0,3]]] in (zjoin ll, map zjoin ll)
03:36:56 <lambdabot> ([[1,2],[4,-5,2]],[[1],[-2,-5]])
03:38:46 -!- pikhq has quit (Quit: Reconnecting).
03:38:47 <oerjan> > let ll = [[[1,2],[]],[[-2,3],[4,-5]]] in (zjoin ll, map zjoin ll)
03:38:49 <lambdabot> ([[1,2],[4,-5]],[[1],[-2,-5]])
03:39:02 -!- pikhq has joined.
03:39:51 <oerjan> i think that's close to minimal
03:40:53 <elliott> kmc: You sure do like talking about how bad the Haskell community is at teaching people :P
03:42:27 <kmc> i still think it's pretty good
03:42:58 <kmc> but there are some flaws, and I don't see many other people talking about them
03:43:00 <elliott> See, I should write a Haskell book that covers every topic ever.
03:43:08 <elliott> Then there'd be no problems, because everybody could just point people there.
03:43:24 <elliott> People who point out situations not covered by the book would be summarily executed for heresy.
03:44:07 <kmc> mostly #haskell talks about how #haskell is the #1 best most friendly channel on freenode
03:44:13 <kmc> which might even be true
03:46:19 <elliott> I've never actually seen that past like 2008.
03:46:36 * elliott wonders what #haskell was like in the Old Days.
03:47:29 <oerjan> the only part of that example which isn't fixed is zjoin [[1,2],[]] = [1]. if it could be [1,something] instead that would fix that counterexample.
03:47:56 <elliott> oerjan: I can help: it's either [1,1] or [1,2].
03:48:05 <elliott> oerjan: That's sort of what I meant by "stuffing the gaps".
03:48:12 <oerjan> oh wait, join [[1],[-2,-5]] == [1,-5] would also work
03:48:19 <elliott> Where you'd shrink, instead throw in a value you have lying around.
03:48:25 <elliott> > zjoin [[1],[-2,-5]]
03:48:27 <lambdabot> [1]
03:48:32 <elliott> Right, same kind of thing.
03:49:22 <oerjan> well i'm starting to think there is probably a proof that this cannot work - if only someone had written it down somewhere we could find it.
03:49:42 <elliott> But but but but don't give up HOPE!
03:49:47 <oerjan> oh hm
03:50:05 <oerjan> if we reinsert the 6
03:50:15 <oerjan> > let ll = [[[1,2],[6]],[[-2,3],[4,-5]]] in (zjoin ll, map zjoin ll)
03:50:16 <lambdabot> ([[1,2],[4,-5]],[[1],[-2,-5]])
03:50:38 <oerjan> it becomes more symmetrical
03:52:15 * oerjan should eat before he reaches *HULK SMASH* level again ->
04:02:32 -!- Lymee has joined.
04:02:32 -!- Lymee has quit (Changing host).
04:02:32 -!- Lymee has joined.
04:02:55 -!- Madoka-Kaname has quit (Ping timeout: 240 seconds).
04:03:02 -!- Lymee has changed nick to Lymia.
04:11:12 <kallisti> uh... I forgot how date math works..
04:11:29 <kallisti> if I take the absolute difference between minute, hour, day, month, year, etc
04:11:38 <kallisti> that should work right?
04:11:41 <kallisti> yes I think it should.
04:14:19 <elliott> huh?
04:14:52 <kallisti> I'm just going to use a datetime thing..
04:14:54 <oerjan> kallisti: your description is sufficiently ambiguous that i'm not sure if you're terribly wrong or not.
04:15:00 <kallisti> because I'm pretty sure I'm wrong.
04:15:55 <elliott> What does "work" even mean
04:15:58 <elliott> What are you trying to do
04:16:02 <oerjan> i mean i _can_ interpret it in such a way that it gives a meaningful answer. barely.
04:16:35 <kallisti> elliott: take the difference between two dates?
04:16:55 <elliott> kallisti: "Difference"?
04:16:58 <kallisti> yes
04:17:08 <elliott> "It was sunny today, and rainy this other day, so... 70%."
04:17:22 <kallisti> ?????
04:17:26 <kallisti> that's weather
04:17:27 <kallisti> not dates.
04:17:37 * elliott facepalm
04:17:59 <oerjan> oh wait no. it is definitely terribly wrong, because even my charitable interpretation breaks down for leap years.
04:18:13 <elliott> Date libraries exist for a reason.
04:18:15 <elliott> Time is hard.
04:18:35 <kallisti> I was going to avoid a CPAN dependency but then I remembered that dates are annoying to work with.
04:18:50 -!- Darth_Cliche has joined.
04:19:09 <oerjan> kallisti: you are being horribly vague in such a matter that it _looks_ like you're making a horrible train wreck but it's impossible to be sure.
04:19:15 <oerjan> *such a way
04:19:24 -!- Darth_Cliche has changed nick to Klisz.
04:19:47 <kallisti> !perl use DateTime
04:19:48 <EgoBot> Can't locate DateTime.pm in @INC (@INC contains: /etc/perl /usr/local/lib/perl/5.10.1 /usr/local/share/perl/5.10.1 /usr/lib/perl5 /usr/share/perl5 /usr/lib/perl/5.10 /usr/share/perl/5.10 /usr/local/lib/site_perl .) at /tmp/input.11100 line 1. \ BEGIN failed--compilation aborted at /tmp/input.11100 line 1.
04:19:49 <elliott> oerjan: XY problem!! XY problem!! kallisti is never doing the wrong thing.
04:20:04 <kallisti> you guys must have missed the part where I decided to use a date library from CPAN
04:20:15 <oerjan> elliott: actually the problem is he hasn't told us _either_ X or Y properly :D
04:20:22 <elliott> kallisti: No, I just continued mocking you after that too! :D
04:20:27 <elliott> <penelope> Cody__: what's the type signature you should expect for findMin?
04:20:27 <elliott> <Cody__> Hold on
04:20:27 <elliott> * nexion has quit (Quit: Leaving)
04:20:27 <elliott> * LeNsTR|off is now known as LeNsTR
04:20:28 <elliott> <Cody__> findMin :: [Ixs] -> [x]. Not very good with typeclasses.
04:20:30 <elliott> <Cody__> findMin :: [x] -> [x].
04:20:33 <elliott> I honestly think people believe #haskell is a Haskell tutorial.
04:20:36 <kallisti> elliott: it's okay to be wrong when finding the correct solution.
04:21:10 <kallisti> or rather, when in the process of doing so.
04:21:47 -!- DCliche has quit (Ping timeout: 260 seconds).
04:22:40 <oerjan> <elliott> I honestly think people believe #haskell is a Haskell tutorial. <-- i'm sure some of it's popularity is because it de facto works as one.
04:22:49 <oerjan> *its
04:22:55 <elliott> oerjan: Yes, unfortunately.
04:25:37 <kallisti> Another problem introduced by Daylight Saving Time is that certain local times just do not exist. For example, in the US in 2003, the transition from standard to saving time occurred on April 6, at the change to 2:00:00 local time. The local clock changes from 01:59:59 (standard time) to 03:00:00 (saving time). This means that there is no 02:00:00 through 02:59:59 on April 6!
04:25:42 <kallisti> loooool
04:26:20 <kallisti> Attempting to create an invalid time currently causes a fatal error. This may change in future version of this module.
04:26:48 <kallisti> this is actually one of the better datetime packages I've seen.
04:27:32 <kallisti> http://search.cpan.org/~drolsky/DateTime-0.72/lib/DateTime/Infinite.pm
04:27:33 <kallisti> .....
04:32:11 -!- Klisz has quit (Quit: SLEEP, GLORIOUS SLEEP).
05:05:16 <pikhq> elliott: BTW, DC updated (on time!)
05:06:06 <elliott> Thanks District of Columbia!
05:17:33 -!- oerjan has quit (Quit: Good night).
05:33:29 <kallisti> hmmm type families would be good for defining chess variants, I think.
05:33:49 <kallisti> well an associated type family
05:33:54 <kallisti> to define the pieces
05:39:13 <kmc> also there's at least one haskell tutorial which actually embeds a chat window for #haskell
05:39:15 <kmc> (tryhaskell.org)
05:39:28 <kmc> i remember when that hit the Reddit front page
05:39:37 <kmc> the channel was full of people who were like
05:39:38 <kmc> WTF IS THIS
05:39:40 <kmc> FAGZ
05:39:42 <kmc> /part
05:41:15 <elliott> hi
05:41:31 <elliott> tryhaskell has an irc client?
05:41:34 <elliott> i guess i never got that far
05:41:42 <kmc> yeah
05:41:48 <kmc> it embeds the freenode webchat thingy
05:41:54 <elliott> aw, boring
05:41:55 <kmc> which i guess is javascript / ajax these days
05:42:00 <kmc> yeah
05:42:04 <elliott> it should have a haskell irc client
05:42:07 <kmc> it would be cooler if it made you write some part of an IRC client in haskell
05:42:10 <elliott> yes
05:42:10 <kmc> yeah
05:42:12 <elliott> say irc "hi!!"
05:42:19 <kmc> too bad it's not actually running haskell in the browser
05:42:22 <elliott> maybeGetNextLine irc
05:42:26 <kmc> unlike http://try.ocamlpro.com/
05:42:52 <elliott> http://www.haskell.org/haskellwiki/Why_Haskell_just_works
05:42:59 <elliott> best article title
05:43:09 <elliott> http://www.haskell.org/haskellwiki/Why_Haskell_is_the_most_amazingly_awesome_thing_ever
05:43:49 <kmc> impress your friends and intimidate your enemies with haskell
05:45:07 <qfr> I gave up on Haskell a long time ago
05:45:27 <qfr> I returned to Ruby/C++/C# :S
05:46:00 <elliott> qfr: my condolences
05:47:16 <kmc> R/Ruby/Racket/REBOL
05:47:24 <kmc> C/C++/COBOL/CommonLisp
05:47:33 <kmc> FORTRAN/Factor/Forth
05:48:21 <elliott> J/Java
05:48:38 -!- Vorpal has joined.
05:49:07 <monqy> Joy?
05:50:36 <elliott> yes
05:52:37 -!- atrapado has quit (Ping timeout: 252 seconds).
06:09:13 -!- Klisz has joined.
06:12:08 <shachaf> elliott: ...I told you.
06:12:14 <shachaf> 22:11.
06:12:20 * shachaf is going to suffer now.
06:12:39 <elliott> shachaf: Seriously?
06:12:40 <elliott> Go back to sleep.
06:13:10 <shachaf> I doubt it'll work.
06:13:20 <shachaf> This one person who's awake is just outside the door, loudly.
06:13:44 * elliott just outsides the door loudly sometimes too.
06:13:50 <elliott> Oh well, I did disclaim my advice.
06:14:27 * shachaf will see what he can do.
06:14:28 <pikhq> @time elliott
06:14:29 <lambdabot> Local time for elliott is Tue Jan 10 06:14:14
06:15:29 <elliott> pikhq: Shhh.
06:57:29 -!- Klisz has quit (Quit: SLEEP, GLORIOUS SLEEP).
08:40:55 <elliott> @hoogle (a -> f b) -> [a] -> f [b]
08:40:56 <lambdabot> Prelude mapM :: Monad m => (a -> m b) -> [a] -> m [b]
08:40:57 <lambdabot> Control.Monad mapM :: Monad m => (a -> m b) -> [a] -> m [b]
08:40:57 <lambdabot> Control.Monad forM :: Monad m => [a] -> (a -> m b) -> m [b]
08:40:57 <elliott> (I know.)
08:42:01 <Vorpal> elliott, I found an impressive ravine system in mc. About 10 intersecting ravines. One of them breaching the surface
08:42:13 <Vorpal> the result was that there was naturally sunlit redstone ore
08:44:22 <qfr> Vorpal you Haskell people are crazy
08:44:29 <Vorpal> qfr, that was minecraft stuff?
08:44:32 <Vorpal> not haskell
08:44:43 <qfr> Oh.
08:45:02 <Vorpal> qfr, how would that even make sense as haskell!?
08:45:10 <qfr> It was a joke :\
08:45:14 <Vorpal> oh
08:45:37 <qfr> "But did you find any co-ravines?" etc
08:45:50 <pikhq> Vorpal: Clearly Ravine is an instance of Monad and Num.
08:45:56 <Vorpal> pikhq, :D
08:46:20 <Vorpal> also two mineshaft systems intersecting this
08:46:31 <qfr> Om nom nom shafts
08:46:50 <Vorpal> also thanks to the technic pack there are TONS of ore here
08:48:32 <Vorpal> err I just dug away a bit of ore and found yet another ravine just behind it
08:51:48 -!- cswords_ has quit (Read error: Connection reset by peer).
09:01:30 -!- Frooxius has joined.
09:02:52 -!- _Slereah has joined.
09:03:55 -!- Slereah has quit (Ping timeout: 248 seconds).
09:05:21 -!- monqy has quit (Quit: hello).
09:11:27 <elliott> Vorpal: You know, there's a channel for that.
09:23:28 <Vorpal> elliott, oh right
09:23:33 <Vorpal> elliott, anyway it is kind of cool
09:40:05 <fizzie> Raving ravines.
10:10:01 -!- myndzi\ has joined.
10:13:12 -!- myndzi has quit (Ping timeout: 268 seconds).
10:37:51 -!- Jafet has quit (Quit: Leaving.).
10:50:03 <elliott> fizzie: You're a really calm dude, right? Give me the secrets of the calm, I need them.
10:52:49 <fizzie> Well, you know, basically they're just your regular mollusks, except they have this hinged shell thing going on. Normally they just kind of sit there and... wait, calm, not clam. Never mind.
10:53:27 <elliott> fizzie: Also your funnies, tell me the secrets of funnise.
10:53:29 <elliott> funnies.
10:54:00 <fizzie> Deliberate misunderstandings are one class of funnies.
10:54:20 <elliott> Ah.
10:54:23 <fizzie> Also nondeliberate since you can always just say "I meant to do that".
10:57:40 <itidus20> the soviet-russia-transformation of noun-subject present-tense-transitive-verb noun-object into noun-object present-tense-transitive-verb noun-subject
11:00:35 -!- ais523 has joined.
11:02:10 <itidus20> Every time you <action>, god kills another <small animal>.
11:05:13 -!- GreaseMonkey has quit (Quit: The Other Game).
11:07:57 <elliott> <NapHtaKeRoSene> hi
11:07:57 <elliott> <NapHtaKeRoSene> anybody know how to call a pointer to function in linux C ?
11:08:00 <elliott> --#haskell
11:09:19 <elliott> ais523: how do you call a pointer to function in linux C? you've taught C, you're the expert
11:09:55 <ais523> well, you can't call a pointer; if you want to call the function it points to, p(args) or (*p)(args)
11:10:00 <ais523> the first is more common, second is clearer
11:10:17 <ais523> and it doesn't matter whether it's Linux C or any other sort of C, not counting some embedded C-likes that don't have function pointers
11:10:40 <elliott> ais523: thanks!
11:11:00 <ais523> elliott: now I'm trying to work out if you're being sarcastic or not
11:11:05 <elliott> (they apparently couldn't ask in ##c because their nick isn't registered, which is an interesting reason to ask a C question in #haskell...)
11:11:13 <elliott> ais523: well, it was certainly a very good explanation.
11:12:15 <elliott> <NapHtaKeRoSene> blog it in my pm if you don't want it here ;; this is definitely some new sense of the word "blog" of which I was not previously aware
11:12:15 <fizzie> It's not as good as a "you can call a pointer anything you want, it's not sentient".
11:12:47 <ais523> elliott: heh, indeed
11:18:27 <elliott> ais523: wiki spam
11:18:41 <elliott> Take me for example. I could support Bachman, Cain, Palin, or Santorum. in no particular order. Others would choose fewer plus Paul., http://brendasongbikinivo.freeforums.org brenda song bikini, >:[[
11:30:02 <Patashu> elliot is a palin supporter???
11:30:18 <ais523> Patashu: elliott's quoting spam, I think
11:30:22 <ais523> just without quote marks or an attribution
11:30:27 <ais523> I generally do a <spambot> when I quote spam
11:30:30 <Patashu> that sounds like plagarism
11:31:04 <itidus20> imagines super mario kart on a mobius strup with rectangular sections of track which can pivot. i assure you it's boring, but noteable
11:34:32 <elliott> Patashu: yes i'm a die hard "true"publican
11:34:40 <elliott> like most brits.
11:36:00 <elliott> > return True >>= `when` Just ()
11:36:01 <lambdabot> <no location info>: parse error on input ``'
11:36:05 <elliott> > (return True >>=) `when` Just ()
11:36:06 <lambdabot> Couldn't match expected type `GHC.Bool.Bool'
11:36:06 <lambdabot> against inferred type ...
11:36:08 <elliott> > (return True >>=) $ `when` Just ()
11:36:09 <lambdabot> <no location info>: parse error on input ``'
11:36:19 <elliott> hmm... yeah, that won't work
12:09:18 <elliott> ais523: hey, do you know an easy way to make C-j indent to the previous line, rather than using the mode's autoindentation?
12:17:48 -!- ais523 has quit (Ping timeout: 252 seconds).
12:23:04 <elliott> :t scanl tail [1,2,3,4]
12:23:05 <lambdabot> Couldn't match expected type `b -> [a]' against inferred type `[a]'
12:23:05 <lambdabot> In the first argument of `scanl', namely `tail'
12:23:05 <lambdabot> In the expression: scanl tail [1, 2, 3, 4]
12:23:17 <elliott> :t scanl
12:23:18 <lambdabot> forall a b. (a -> b -> a) -> a -> [b] -> [a]
12:23:22 <elliott> > scanl f z [a,b,c,d]
12:23:23 <lambdabot> [z,f z a,f (f z a) b,f (f (f z a) b) c,f (f (f (f z a) b) c) d]
12:23:25 <elliott> right
12:33:20 -!- Patashu has quit (Quit: MSN: Patashu@hotmail.com , Gmail: Patashu0@gmail.com , AIM: Patashu0 , YIM: patashu2 , Skype: patashu0 .).
12:43:14 <elliott> @src scanl
12:43:14 <lambdabot> scanl f q ls = q : case ls of
12:43:14 <lambdabot> [] -> []
12:43:14 <lambdabot> x:xs -> scanl f (f q x) xs
12:46:21 * Sgeo keeps forgetting that scanl makes the first item be the 0 thing
12:47:27 <Sgeo> :t scanr
12:47:28 <lambdabot> forall a b. (a -> b -> b) -> b -> [a] -> [b]
12:47:41 <Sgeo> > scanr f z [a,b,c,d]
12:47:42 <lambdabot> [f a (f b (f c (f d z))),f b (f c (f d z)),f c (f d z),f d z,z]
12:49:54 -!- Phantom_Hoover has joined.
12:50:26 <Phantom_Hoover> hello
12:50:27 <lambdabot> Phantom_Hoover: You have 1 new message. '/msg lambdabot @messages' to read it.
13:16:42 -!- ais523 has joined.
13:17:14 <ais523> elliott: the /correct/ way is to write a minor mode that rebinds the key, but I'm not sure if it qualifies as "easy"
13:18:10 <elliott> ais523: I don't care about the correct way :P
13:18:36 <ais523> elliott: well, it's probably easier than the alternatives
13:18:58 <ais523> and once you've done it once, it'll work from then onwards (you'd be adding a command that'd be M-x control-j-line-up-mode or whatever)
13:19:33 <ais523> what are you trying to do, anyway? doing it with different commands altogether might be the really lazy easy solution
13:20:27 <elliott> ais523: make C-j indent to the previous line, rather than using the mode's autoindentation
13:20:35 <ais523> elliott: no, I mean in more detail
13:20:37 <elliott> I don't see why a minor mode matters when I can just rebind the key directly
13:20:38 <ais523> as in, why do you want to do that?
13:20:44 <elliott> ais523: that /is/ what I want to do
13:20:47 <elliott> it's an editor, that's my end goal
13:20:57 <elliott> I'm trying to change what it means for me to push ctrl and then j
13:20:57 <ais523> elliott: oh, you mean as a permanent editor setting?
13:21:08 <elliott> well, only in haskell-mode, but I believe there's a rebind-in-map thing
13:21:14 <elliott> at least I remember using one once
13:21:33 <ais523> I thought you meant you were trying to edit a file where you wanted to change the meaning of C-j for a while as you were doing something unusual indentation-wise
13:21:41 <ais523> hmm, let me check, I think I've written similar code for intercal-mode
13:27:39 <ais523> elliott: untested: (defun newline-and-indent-relative-maybe () "Insert a newline, then indent like the previous line." (interactive) (newline) (indent-relative-maybe)) (define-key haskell-mode-map "\C-J" 'newline-and-indent-relative-maybe)
13:27:43 <ais523> for your .emacs file
13:29:03 <ais523> seems to require that the haskell code's loaded first, though
13:29:42 <ais523> and I forget the syntax to do that
13:30:01 <ais523> or, hmm, I bet you'd put it in the hook for haskell-mode loading
13:30:59 <ais523> elliott?
13:31:10 <fizzie> Your elips, it was too much for him.
13:31:16 <fizzie> s/ps/sp/
13:31:22 <fizzie> He's lost within Emacs now.
13:40:34 <ais523> oh well
13:40:40 <ais523> he'll probably escape eventually, it isn't TV Tropes
13:41:48 <fizzie> No, we'll just get a final mysterious "it's full of parentheses" transmission.
13:46:44 <elliott> back, sorry
13:46:55 <elliott> ais523: thanks!
13:47:48 <ais523> indent-relative-maybe seems to be what you were asking for for lining up, and the newline's there because you wanted a newline first
13:48:30 <elliott> Yes, I did understand it :P
13:49:59 * elliott wonders what the emacs function that makes the current line empty if it's just whitespace is
13:50:08 <elliott> most C-j functions seem to call it, and that override seems to disable that feature
13:57:01 -!- _Slereah has changed nick to Slereah.
14:31:25 * elliott reads the C committee and Austin Group yell at each other point-by-point
14:31:30 <elliott> However, I don't think [this TR] would be especially useful, and I
14:31:30 <elliott> don't envision it gaining wide acceptance due to the following:
14:31:30 <elliott> awkward names with _s suffix
14:31:30 <elliott> Committee Response:
14:31:30 <elliott> It is less awkward than the posix_ prefix :-)
14:31:45 <elliott> ais523: Can you imagine the C commitee using a /smiley face/?
14:32:03 <ais523> yes
14:32:16 * elliott can't.
14:32:49 <elliott> [[
14:32:49 <elliott> people that want to manipulate strings are probably better off using
14:32:49 <elliott> C++ unless they're concerned with speed in time-critical loops in
14:32:50 <elliott> which they don't want to be doing superfluous checks anyway.
14:32:50 <elliott> Committee Response:
14:32:50 <elliott> We believe this TR is of interest to those that have a large C Legacy code, and do not have the option or want to change to C++.
14:32:53 <elliott> ]]
14:33:02 * elliott can't tell whether the commitee are just being accommodating, or really do see C as a legacy language.
14:33:22 <ais523> elliott: they mean that quite a lot of people have existing C code
14:33:28 <ais523> so it's legacy in that sense
14:34:05 <elliott> ais523: well, yes, but that's the only objection they offer to "just use C++"
14:34:16 <ais523> they only need one objection :)
14:34:24 <elliott> fair enough :P
14:34:42 <elliott> [[ edited out suggestion for additional robustness checking functions,
14:34:42 <elliott> available on request ]]
14:34:42 <elliott> Committee Response:
14:34:42 <elliott> If the author wants to generate a proposal and submit this proposal to WG14, it will be considered.
14:34:45 <elliott> ICE BURN
14:35:14 <elliott> (I wonder where this "generate"-as-author(v.) jargon comes from; the committee are using it a lot here.)
14:35:27 <ais523> the "available on request" implies to me that the suggestion was probably pure trolling
14:35:31 <coppro> that reminds me, I need to write that paper for WG14
14:36:05 <elliott> Dear WG14,
14:36:06 <fizzie> elliott: Perhaps even an ICE BURN
14:36:12 <elliott> Please die.
14:36:16 <elliott> Love,
14:36:20 <elliott> Elliott
14:36:28 <elliott> fizzie: YOU BROKE MY FORMATTING KICK YOUSRELF.
14:36:44 -!- ChanServ has set channel mode: +o fizzie.
14:36:46 -!- fizzie has kicked fizzie fizzie.
14:36:46 -!- fizzie has joined.
14:36:49 <elliott> Thanks.
14:36:55 <elliott> You forgot to -o yourself.
14:37:02 <elliott> Even if you're kicked, it's the spirit of the thing.
14:37:07 <elliott> ais523: I think that it was edited out by the Austin group.
14:37:07 -!- sebbu has quit (Read error: Connection reset by peer).
14:37:12 <elliott> The committee's remarks are in a different font.
14:37:16 <ais523> ah, perhaps
14:37:25 <elliott> (the Austin Group text is monospaced and indented)
14:37:52 -!- sebbu has joined.
14:37:53 -!- sebbu has quit (Changing host).
14:37:53 -!- sebbu has joined.
14:38:47 <elliott> ais523: hmm, ah, it seems like they view the /functions in question/ as primarily useful for legacy code
14:38:52 <elliott> (it's the _s stuff)
14:39:02 <elliott> presumably, they hope newly-written code doesn't need safeguards like that to ensure safety
14:39:03 <ais523> right, the _s stuff
14:39:10 <ais523> Microsoft have been trying to get them to add that for years
14:39:14 <ais523> probably decades now, actually
14:39:26 <elliott> haha, literally everyone is complaining about the "secure" name for them
14:39:40 <elliott> and the committee keep saying "see previous answer", where they went "you're wrong, but we've changed it anyway to shut you up"
14:40:20 <elliott> ais523: I guess they succeeded, since gets was replaced by gets_s
14:40:26 -!- Phantom_Hoover has quit (Ping timeout: 240 seconds).
14:40:26 -!- kmc has quit (Ping timeout: 240 seconds).
14:40:26 -!- Nisstyre has quit (Ping timeout: 240 seconds).
14:40:27 <elliott> presumably there are others in the same vein
14:40:35 <ais523> elliott: well, removing gets was definitely a good idea
14:40:36 -!- Frooxius has quit (Ping timeout: 240 seconds).
14:40:36 -!- Sgeo has quit (Ping timeout: 240 seconds).
14:40:49 -!- kmc has joined.
14:40:57 <ais523> the "secure" thing was Microsoft propaganda
14:41:09 <ais523> to try to persuade people to write their code in a way incompatible with other compilers
14:41:23 -!- Phantom_Hoover has joined.
14:41:32 -!- Frooxius has joined.
14:42:03 <elliott> I'm scared of this "diagnosed undefined behaviour" concept the thing apparently referred to
14:42:14 <fizzie> Wasn't it just _s for 'safe'?
14:42:19 -!- Sgeo has joined.
14:42:23 <elliott> fizzie: the title was blah blah secure blah
14:42:36 <elliott> I also don't want to know what fopen_s does; adds a "don't read past this many bytes of the filename argument" param?
14:42:44 <ais523> elliott: almost certainly
14:42:48 <ais523> and knowing Microsoft, the mode argument too
14:43:03 <elliott> haha
14:43:22 <elliott> ais523: oh, that was funnier when I thought fopen used a numeric mode like open(2)
14:43:24 -!- Nisstyre has joined.
14:43:32 <fizzie> elliott: It's errno_t fopen_s(FILE** pFile, const char *filename, const char *mode) in Microsoft libs.
14:43:45 <elliott> ais523: if, e.g. you think you might have only two bytes of the mode safe for reading, but it's an int argument
14:43:56 <ais523> fizzie: oh right, the Microsoft versions return errno
14:44:07 <elliott> I doubt the committee versions do
14:44:11 <ais523> I hope they don't
14:44:23 <fizzie> ais523: And it just validates the pointers in case of NULLs, it doesn't have a filename length field.
14:44:29 <ais523> although, if they have incompatible functions to Microsoft's with the same names, Microsoft will probably get annoyed
14:44:51 <ais523> (whereas if that happened with glibc, they'd just add another layer of feature test macros and another few tests in autoconf)
14:45:34 <elliott> .cs is the file extension for C# source code, right?
14:45:41 <ais523> fizzie: well, it's easy enough to make fopen validate nulls
14:45:46 <ais523> elliott: yes
14:46:01 <fizzie> ais523: N1570: "errno_t fopen_s(FILE * restrict * restrict streamptr, const char * restrict filename, const char * restrict mode);" -- it's very similar.
14:46:12 <ais523> ouch
14:47:26 <elliott> ais523: thanks
14:47:36 <elliott> fizzie: haha, it introduces an errno_t?
14:47:39 <ais523> well, in theory you could use anything, but .cs seems most common
14:47:46 <ais523> elliott: errno_t already existed, I think
14:47:49 <ais523> although maybe only in POSIX
14:48:09 <Deewiant> It's not in C99
14:48:39 <fizzie> It's not in C99; it's explicitly defined to be equivalent to "int" in C11.
14:49:09 <elliott> How useful.
14:49:44 <elliott> [[
14:49:52 <elliott> -----------------------------------------------
14:49:53 <elliott> >From Ulrich Drepper
14:49:53 <elliott> The proposed safe(r) ISO C library fails to address to issue completely.
14:49:53 <elliott> The problem with the existing interfaces is that the programmer has to
14:49:53 <elliott> put in a lot of additional effort to make sure the program behaves
14:49:53 <elliott> correctly. In many situations a much simpler code, with all kinds of
14:49:55 <elliott> error checking removed, works equally well and therefore is left out.
14:49:57 <elliott> This is the core of the problem. Code is rather written like
14:49:59 <elliott> [...]
14:50:01 <elliott> Proposing to make the life of a programmer even harder is not going to
14:50:03 <elliott> help. But this is exactly what is proposed. [...]
14:50:04 <fizzie> The rationale in somewhere is that it makes it "semantically" clear that what is returned is an error code.
14:50:05 <elliott> Committee Response:
14:50:07 <elliott> This committee is not addressing lazy programmers.
14:50:09 <elliott> ]]
14:51:41 <ais523> elliott: somehow I think that point might have been made better if it wasn't Drepper trying to make it
14:52:00 <elliott> ais523: it was fairly well-made, I just snipped out all the irrelevant parts
14:52:08 <ais523> ah, I see
14:52:13 <elliott> the actual committee response is
14:52:17 <elliott> [[
14:52:18 <elliott> This committee is not addressing lazy programmers. The committee felt the examples given were a little misleading, and believe that
14:52:18 <elliott> char *p = malloc (3 * NAME_LEN);
14:52:18 <elliott> strcpy_s (p, 3 * NAMELEN, name1); // there will be a constraint violation if malloc failed
14:52:18 <elliott> strcat_s (p, 3 * NAMELEN, name2);
14:52:19 <elliott> strcat_s (p, 3 * NAMELEN, name3);
14:52:21 <elliott> will generate a much safer outcome.
14:52:23 <elliott> In the first example given, if the malloc failed, there would have been
14:52:25 <elliott> undefined behavior, as there would have been if
14:52:27 <elliott> strlen(name1)+strlen(name2)+strlen(name3) > 3*NAMELEN.
14:52:29 <elliott> However,
14:52:31 <elliott> with this simple substitution for the safer functions,
14:52:33 <elliott> there is no undefined behavior. If malloc failed, at the end of this code
14:52:35 <elliott> fragment, p would be NULL, and no undefined actions would have occurred
14:52:37 <elliott> (though the implementation defined constraint violation handler would have
14:52:39 <elliott> been executed three times). If the overall length was too long, then p would
14:52:41 <elliott> point to memory that had the first byte set to 0. This memory could be
14:52:43 <elliott> successfully freed later.
14:52:45 <elliott> ]]
14:52:47 <elliott> which is (a) much more reasonable, (b) much less funny
14:52:51 <elliott> cf. ais523 v. Installing Gentoo with 3 commands
14:53:12 <ais523> oh, I prefer reasonable to funny
14:53:54 <ais523> hmm, I was writing some Neverwinter Nights scripting code recently
14:54:05 <ais523> and the main unusual feature of that language is error values propagating
14:54:28 <ais523> as in, you can pass arbitrary arguments to any of the API functions, and get a return value meaning that something went wrong
14:54:44 <ais523> it makes sense for a game; if someone's missing, then it just ends up skipping the bits of the script that apply to them
14:54:50 <ais523> although I feel a bit weird when I deliberately use that fact
14:55:03 <fizzie> There was a big fight in comp.lang.c on the "library functions should, in addition to testing for NULL, also use some sort of platform-specific functions to check that the pointers point to readable/writable memory" topic.
14:55:33 <fizzie> (The IsBadReadPtr and IsBadWritePtr things mentioned in there.)
14:55:40 <elliott> ais523: as in, f(nil) -> nil?
14:55:44 <ais523> elliott: yep
14:55:46 <elliott> Objective-C has [nil anything] -> nil
14:55:48 <elliott> which is comparable
14:56:07 <ais523> elliott: although instead of nil, it uses 0, "", and OBJECT_INVALID
14:56:10 <elliott> ais523: I think Icon has similar
14:56:15 <ais523> which is a bit uglier
14:56:25 <ais523> OBJECT_INVALID is fine, but 0 and "" aren't because they're sometimes reasonable return values in their own right
14:56:49 <elliott> I love Icon because it's one of the only languages where "x < (y | z)" DTRT
14:57:04 <ais523> elliott: do you love Perl 6 for the same reason?
14:57:24 <elliott> hmm, how is it phrased there?
14:57:59 <ais523> I think it's actually exactly the same
14:58:01 <ais523> not sure, though
14:58:33 * ais523 updates Rakudo
15:01:17 * ais523 fails to update Rakudo
15:01:37 <elliott> ais523: don't worry, you suceed a few minutes ago
15:01:44 <elliott> just wait for Feather
15:01:55 <elliott> *succeed
15:02:20 <ais523> I'm going to retry from scratch
15:08:21 <elliott> ais523: as long as you go back afterwards
15:08:41 <ais523> now I'm thinking about the irony of Rakudo's configure script being written in Perl 5
15:08:49 <ais523> it's perfectly natural, just seems a little out of place
15:09:20 -!- Jafet has joined.
15:18:54 -!- anders has left.
15:19:04 -!- ais523 has quit (Ping timeout: 268 seconds).
15:19:08 -!- ais523_ has joined.
15:22:50 -!- Klisz has joined.
15:25:42 -!- myndzi\ has quit (Read error: Connection reset by peer).
15:26:48 -!- ais523_ has changed nick to ais523.
15:31:31 -!- myndzi has joined.
15:48:31 <kallisti> so what does knowing the partial order of a data type do for me?
15:50:29 <elliott> gives you a partial order
15:51:12 <ais523> <spambot> You must be desperate to know what a father of the groom speech is if you are reading this now.
15:51:44 <elliott> :D
15:51:47 <elliott> i am!
15:51:59 <elliott> "Has he joined Obama in Wonderland where up is down and left is right? What's "fiscally conservative" about voting for every spending measure in sight?"
15:52:00 <ais523> it's simultaneously right on one level and wrong on a different one
15:52:04 <elliott> ais523: Our spambots are quite Republican lately.
15:52:08 <ais523> which is much more interesting than being right on multiple levels
15:52:56 * elliott wonders where all those quotes are coming from; they seem verbatim, but googling them just turns up more spam.
15:55:53 <ais523> probably the spam's out-SEOed the original quote
16:01:00 <coppro> up is down black is white and short is long
16:02:12 <kallisti> @pl (x y z -> z ++ "|" ++ y ++ "|" ++ z)
16:02:13 <lambdabot> (line 1, column 8):
16:02:13 <lambdabot> unexpected ">"
16:02:13 <lambdabot> expecting variable, "(", operator or ")"
16:02:16 <kallisti> @pl (\x y z -> z ++ "|" ++ y ++ "|" ++ z)
16:02:17 <lambdabot> const (ap (++) . (('|' :) .) . (. ('|' :)) . (++))
16:03:48 -!- Ngevd has joined.
16:04:05 <Ngevd> Hello!
16:04:56 <Ngevd> I managed to mention esoteric programming languages in my General Studies exam
16:05:19 <ais523> Ngevd: that's cheating, you can mention /anything/ in a General Studies exam and not lose a significantly significant number of marks
16:05:37 <Ngevd> It's my first A-level exam
16:05:44 <ais523> well, not /really/
16:05:54 <Ngevd> Got Maths exam on Friday, should I continue the pattern?
16:05:56 <ais523> General Studies doesn't count, apart from being embarrassing if you fail it
16:06:06 <ais523> Ngevd: if you reasonably can, I guess
16:06:17 <ais523> it should be harder to slip into Maths than General Studies without looking out of place, though
16:06:21 <kallisti> elliott: right so
16:06:22 <coppro> I wrote my high school English diploma examination on Order of the Stick
16:06:27 <kallisti> what does having a partial order do for you?
16:06:28 <ais523> hmm, is Maths still Module-based?
16:06:33 <Ngevd> One of my friends managed to mention Star Wars in every single GCSE exam
16:06:35 <Ngevd> ais523, yes
16:06:38 <kallisti> aside from giving you a nice Ord instance. :P
16:06:57 <Ngevd> coppro, he, nice
16:08:08 <kallisti> mmmm lentils
16:08:18 <coppro> it as kind of a lame essay though
16:08:21 <coppro> because I didn't have focus
16:08:29 <coppro> oh well, my essay-writing days are mostly over
16:08:47 <coppro> (and I can still write pages about rules ;) )
16:23:41 <Phantom_Hoover> <Ngevd> One of my friends managed to mention Star Wars in every single GCSE exam
16:23:57 <Phantom_Hoover> Wow, he must have a lot of time on his hands.
16:23:57 <Ngevd> That he sat, of course
16:24:09 <Ngevd> He didn't mention it in the ones he didn't sit
16:24:52 <Phantom_Hoover> Also, one of my folio pieces for Higher English was "Comic Sans: a Sad Indictment of Our Times".
16:26:48 <shachaf> elliott: Success(-ish)!
16:28:29 * Phantom_Hoover → goddamn STEP preparation.
16:37:10 <elliott> shachaf: Ish! The best kind.
16:48:16 <shachaf> elliott: I think I'll just let you take over.
16:48:54 <elliott> shachaf: I apologise for bringing up Char8 :(
16:49:22 <shachaf> elliott: You can make up for it by accusing nexion of being racist, like a certain member of #haskell would.
16:50:06 <Sgeo> ...what?
16:50:36 <elliott> Sgeo: People who say they "don't need Unicode" are usually under the influence of some rather heavy cultural bias.
16:50:45 <elliott> shachaf: You'd think Haskell users would appreciate the value of using types that say what you mean.
16:51:38 <Sgeo> Almost every programming language which has keywords has those keywords in English
16:51:39 <Sgeo> :/
16:51:44 <Sgeo> Standard library names, etc.
16:52:00 <elliott> Sgeo: Maybe you shouldn't try and comment on discussions you only see the behind-the-back commentary on?
16:52:02 <shachaf> elliott: You'd be surprised!
16:52:13 <elliott> God dammit mm_freak!
16:52:34 <elliott> shachaf: Hey, if this was SO, I would be getting rep for my pain.
16:52:41 * elliott isn't getting rep for his pain.
16:52:53 <Sgeo> elliott, I am present in #haskell , my comment was somewhat tangential, I guess.
16:53:11 <elliott> Sgeo: I'm just plain not sure what the relevance is, then.
16:54:12 <Sgeo> That there does seem to be heavy cultural bias in ... programming. Although not in such a way that it affects end-users the way a failure to do text right does.
16:54:38 <shachaf> elliott: Sure you are, elliott++
16:55:00 <elliott> Yessss
16:55:29 <elliott> Oh, wait, why am I arguing with mauke, I distinctly remember him being an ASCII-pushing traditionalist.
16:55:36 * elliott has little encyclopedia entries for everybody in his head.
16:55:36 <shachaf> 19:54 < nexion> Sgeo, yeah, I use that for the Unicode sections of the stream
16:55:47 <elliott> All negative, who needs to remember good things about people.
16:55:59 <shachaf> It's good to hear that the stream has "Unicode sections".
16:56:22 <shachaf> But of course the rest of it is ASCII.
16:56:26 <Sgeo> Presumably, the word POST or GET or whatever never contains non-ASCII characters, is his point?
16:56:27 <elliott> shachaf: They only need ASCII!
16:57:02 <shachaf> elliott: "heavily optimised"
16:57:11 <elliott> shachaf: I saw a blog post with #s in it once.
16:57:17 <elliott> That's heavily optimised enough for me, tyvm.
16:57:22 <shachaf> I wrote a program wih #s in it once.
16:57:28 <shachaf> > ord '#'
16:57:29 <lambdabot> 35
16:57:39 <elliott> shachaf: (Is Text not actually fast?)
16:57:43 <elliott> I mean, the structure sucks, but.
16:57:58 <shachaf> Not nearly as fast as ByteString when you're processing ASCII in certain cases.
16:58:06 <shachaf> At least, when I last tried it.
16:58:19 <elliott> shachaf: Well, who gives a shit; ideological purity trumps all.
16:58:27 <shachaf> Sure.
16:58:36 <shachaf> ...In some cases.
16:58:52 <shachaf> Like "why can't I pattern-match ByteStrings?".
16:59:05 <shachaf> It's 08:58, by the way.
16:59:18 <elliott> <mauke> I don't care how "heavily optimised" Text is; it's got stupidity built in
16:59:21 <Deewiant> Use view patterns and uncons
16:59:22 <elliott> I wonder if the "stupidity" is Unicode.
16:59:25 -!- Ngevd has quit (Read error: Connection reset by peer).
16:59:47 -!- Ngevd has joined.
16:59:55 <Vorpal> wow I'm somehow still connected
16:59:58 <Vorpal> which is strange
17:00:07 <Vorpal> since the computer suspended to disk
17:00:33 <shachaf> elliott: Not when it's O(n/k)!
17:00:54 <Vorpal> (I didn't notice the power cable had been disconnected and I wasn't using the laptop at the time, I only noticed when I heard the "burp" from the dvd drive that it makes while suspending to disk)
17:00:59 <elliott> shachaf: What's multiplication, man.
17:01:29 <fizzie> "View patterns an unicorns" sounded exciting.
17:01:32 <fizzie> Then it was just uncons.
17:01:43 <shachaf> elliott: Hey, I want a type to represent a vector of length 7.
17:01:49 <Deewiant> #define unicorns uncons
17:01:50 <Deewiant> Go wild
17:01:52 <Sgeo> :t uncons
17:01:53 <lambdabot> Not in scope: `uncons'
17:01:53 <shachaf> But access to it has to be O(1), not O(7).
17:01:55 <shachaf> What do I do?
17:01:59 <Deewiant> ?hoogle uncons
17:02:00 <lambdabot> Data.ByteString.Char8 uncons :: ByteString -> Maybe (Char, ByteString)
17:02:00 <lambdabot> Data.ByteString.Lazy.Char8 uncons :: ByteString -> Maybe (Char, ByteString)
17:02:00 <lambdabot> Data.ByteString uncons :: ByteString -> Maybe (Word8, ByteString)
17:02:10 <ais523> shachaf: just divide O by 7
17:02:16 <fizzie> ?hoogle snoc
17:02:16 <elliott> shachaf: newtype Vec a = Vec (a,a,a,a,a,a,a)
17:02:16 <lambdabot> Data.ByteString.Char8 snoc :: ByteString -> Char -> ByteString
17:02:17 <lambdabot> Data.ByteString.Lazy.Char8 snoc :: ByteString -> Char -> ByteString
17:02:17 <lambdabot> Data.ByteString snoc :: ByteString -> Word8 -> ByteString
17:02:22 <elliott> shachaf: There's only one field, so it must be O(1).
17:02:38 <Vorpal> O(7) lol
17:02:39 <shachaf> Also I want this to work for any value of 7.
17:02:52 <Deewiant> elliott: But if he wants O(1) access to all the elements, he needs 7 fields, so it's O(7) for the whole thing again.
17:03:00 <elliott> Deewiant: Trade-offs.
17:03:04 <shachaf> Deewiant has a point.
17:03:13 <Sgeo> Can view-patterns be used to hide an equality check?
17:03:22 <Sgeo> As a pattern match
17:03:24 <elliott> shachaf: I was going to say something.
17:03:42 <shachaf> Sgeo: The point is that writing the ByteString that represents the ASCII "POST" is awkward.
17:03:57 <Vorpal> <Deewiant> elliott: But if he wants O(1) access to all the elements, he needs 7 fields, so it's O(7) for the whole thing again. <-- couldn't you work with several at once?
17:03:58 <Sgeo> f ((==blah) -> True) = whatever
17:04:11 <elliott> shachaf: To make up for my long spiel about monads, I wrote a long spiel about applicatives.
17:04:12 <shachaf> Sgeo: f blah | isAscii "POST" blah = ...
17:04:22 <elliott> Vorpal: Most people don't have 7-core processors
17:04:39 <Vorpal> elliott, indeed, I have 8 core (including the hyper threading)
17:04:43 <Sgeo> shachaf, I'm not going for decency here
17:04:47 <shachaf> elliott: Why don't you write a long spiel about jQuery?
17:04:49 <Sgeo> I'm going for abuse of view patterns
17:04:51 <elliott> Vorpal: You're bourgeois.
17:04:56 <Vorpal> elliott, heh
17:05:06 <fizzie> Vorpal: A 7-core processor is just an 8-core prosessor with one snuffed core.
17:05:19 <elliott> shachaf: What is there to say? It is art; it is perfection. It's the alpha and the qoppa.
17:05:20 <Vorpal> elliott, anyway, what about stuffing multiple values into a single SSE or AVX register
17:05:22 <Sgeo> Would my pattern work?
17:05:24 <elliott> jQuery is.
17:05:27 <Vorpal> or even into a normal machine word
17:05:39 <elliott> Vorpal: You have to stuff all 7 of them
17:05:39 <shachaf> elliott: I thought it was a monad.
17:05:41 <elliott> So O(7) again.
17:05:49 <elliott> shachaf: It's an ArrowApply.
17:05:56 <Vorpal> elliott, how large is each? And once you stuffed them like that you could keep them like that surely
17:06:11 <Vorpal> and you can load an entire SSE register with one instruction anyway
17:06:15 <Vorpal> (same for writing it out)
17:06:38 <fizzie> Isn't AMD Phenom X3 just those samples of Phenom X4 where one of the cores failed the tests?
17:06:44 <Vorpal> I believe so
17:06:44 <shachaf> elliott: I enjoy how this web page has a commutative diagram on it: http://www.windley.com/archives/2009/01/jquery_monads_and_functional_programming.shtml
17:07:23 <elliott> shachaf: The T^2 represents elements on the page.
17:07:29 <elliott> shachaf: The \mu is jQuery.
17:07:33 <Vorpal> fizzie, I have like the best i7 you can get without intel calling it extreme or whatever they do to those supposed to be more stable for overclocking.
17:07:33 <shachaf> elliott: Ooh, more! Of a slightly different variety: http://weblogs.asp.net/bleroy/archive/2010/06/29/how-i-understood-monads-part-2-2-have-we-met-before.aspx
17:07:38 <elliott> shachaf: T_\eta is the CSS selector you're using.
17:08:03 <elliott> "Oh yeah, C#4’s dynamic is a monad
17:08:03 <elliott> Thanks to the new dynamic keyword in C#4, it is now possible to ask the C# compiler to relax compile-time type checking and instead resolve the members of some objects at runtime.
17:08:03 <elliott> Here’s a somewhat trivial example:
17:08:03 <elliott> dynamic foo = new {
17:08:03 <elliott> bar = "baz"
17:08:05 <elliott> };
17:08:07 <elliott> Console.WriteLine(foo.bar);"
17:08:09 <elliott> Very monadic!
17:08:22 <elliott> The wrapping is magic and the binding is baked into the semantics of the language.
17:08:31 <Vorpal> fizzie, if they still do that, I don't remember
17:08:36 <Vorpal> fizzie, (it is a sandy bridge)
17:08:36 <elliott> shachaf: Also, I see no diagrams on that second one.
17:08:44 <shachaf> elliott: It's true. I meant "more suffering".
17:08:57 <fizzie> Vorpal: IIRC the "Extreme Edition" chips do also have some bumped-up specs in addition to overclockability.
17:09:05 <Vorpal> possibly
17:09:17 <elliott> shachaf: I'm glad that guy acknowledges Microsoft are evil.
17:09:19 <Vorpal> fizzie, mine is a normal edition sandy bridge i7 at 3.4 GHz
17:09:25 <elliott> In his blog title.
17:09:29 <Vorpal> fizzie, which is pretty extreme anyway
17:09:33 <elliott> Along with an evil-looking pumpkin.
17:09:36 <elliott> I think he has Microsoft issues.
17:09:49 <fizzie> Vorpal: I think for Sandy Bridge they just went with a "K" or "X" suffix in the model number for the "extreme" ones.
17:09:58 <Vorpal> fizzie, ah possibly
17:10:15 <elliott> shachaf: Heyy, cheater isn't here, I can complain about him wasting space in #haskell with impunity! Well, relative impunity.
17:10:42 <shachaf> Just wait until #-blah hears that quote!
17:10:55 <Vorpal> fizzie, I believe one of the labs at university have those.
17:10:55 <elliott> shachaf: Don't.
17:11:08 <shachaf> elliott: Don't worry, I'm leaving anyway.
17:11:08 <Vorpal> fizzie, it also have pretty old nvidia quadro cards for some reasons.
17:11:11 <Vorpal> reason*
17:11:20 <elliott> shachaf: Do you remember when cheater tried to get me banned from #haskell because I pointed him to LYAH?
17:11:26 <shachaf> No.
17:11:28 <elliott> That was fun.
17:11:51 <elliott> <ben_m> cheater, he took an arrow in the knee
17:11:51 <elliott> <cheater> heh.
17:11:58 <elliott> Phantom_Hoover: Is there a cure for crying.
17:12:15 <fizzie> Vorpal: Apparently the i7-2600K in fact only differs from the i7-2600 in that it has some unlocked overclocking settings; plus it *doesn't* do some things. (TXT, the trusted execution thing; VT-d, the IO virtualization thing; and vPro, the remote management thing.)
17:12:24 <shachaf> elliott: Yes: Conveniently, the cure is crying.
17:12:29 <Phantom_Hoover> elliott, anti-onion.
17:12:41 <elliott> Phantom_Hoover: Sounds explosive.
17:12:56 <fizzie> Vorpal: Anyway, they seem to have gotten a Core i7-3930K/-3960X six-physical-cores models out now, too.
17:12:57 <Phantom_Hoover> Yes, with tears.
17:12:59 <Vorpal> the only good arrow to the knee joke I seen so far was from a LP of skyrim where some NPC placement bugged out and, as the player said: "took a stair to the knee"
17:13:09 <shachaf> The Anti-onion Router, also known as "tar".
17:13:17 <Vorpal> fizzie, heh
17:13:20 <shachaf> Did you know /bin/tar sends everything you do to the NSA immediately?
17:13:26 <elliott> Only GNU tar.
17:13:29 <Vorpal> fizzie, I'm pretty sure those weren't around when I bought mine
17:13:57 <Vorpal> fizzie, why not VT-d?
17:14:01 <Vorpal> fizzie, that makes no sense
17:14:02 <Vorpal> hm
17:14:26 <Vorpal> fizzie, I believe the one I have does VT-d but my mobo doesn't or something like that
17:18:27 <fizzie> Vorpal: Probably they've figured out there's not much overlap between overclockers and people who need "enterprise" features. Though I've never quite figured out the "let's disable features" decisions.
17:19:48 <elliott> It's like the Pokemon versions.
17:19:53 <elliott> Gotta buy them both to have all the feechurez.
17:20:03 <ais523> heh
17:22:21 <Vorpal> elliott, I wonder if there are extreme edition xenons?
17:22:27 <Vorpal> probably not
17:22:38 <Vorpal> anyway I would quite like to use VT-d
17:23:21 <Vorpal> possibly
17:23:26 <Vorpal> not sure what the point would be
17:23:52 <Vorpal> would be nice if you could use this for the GPU or such to do fast 3D in qemu
17:24:11 <Vorpal> sounds unlikely to work though
17:24:24 <Vorpal> and would not work at all with windowed mode
17:26:41 <Phantom_Hoover> Hmm, what do IBM actually /do/ these days?
17:26:55 <Phantom_Hoover> I can't actually think of anything I associate with them.
17:26:56 <Ngevd> Chips
17:27:09 <Phantom_Hoover> Not any chips I've heard of, at least.
17:27:44 <Ngevd> They do the CPU for Wii's
17:28:20 <Ngevd> And XBox 360's
17:28:39 <Vorpal> and main frames
17:28:45 <Phantom_Hoover> Main frames.
17:28:48 <Vorpal> yes
17:28:59 <Ngevd> They co-designed the PS3 CPU
17:29:33 <Phantom_Hoover> Vorpal, main frames.
17:29:50 <Vorpal> Phantom_Hoover, yes. They are still made
17:30:21 <Phantom_Hoover> Main... frames.
17:30:33 <Vorpal> Phantom_Hoover, as opposed to minicomputers
17:30:56 <elliott> Phantom_Hoover: Mainframes, CPUs.
17:31:05 <elliott> Supercomputers.
17:31:10 <Vorpal> oh yes, that too
17:31:10 <elliott> Bad software.
17:31:20 <elliott> Research.
17:31:45 <Ngevd> AIs on quiz shows
17:31:50 <Phantom_Hoover> IBM, a bad software company.
17:31:53 <Vorpal> Ngevd, snap you just beat me to that
17:32:05 <Phantom_Hoover> Makers of the finest bad software.
17:32:33 <Vorpal> "Virtually all console gaming systems of the latest generation use microprocessors developed by IBM. The Xbox 360 contains a PowerPC tri-core processor, which was designed and produced by IBM in less than 24 months.[56] Sony's PlayStation 3 features the Cell BE microprocessor designed jointly by IBM, Toshiba, and Sony."
17:32:35 <Vorpal> eh
17:32:38 <Vorpal> virtually all?
17:32:41 <Vorpal> 2 out of 3?
17:32:52 <Phantom_Hoover> The Wii uses an IBM chip too.
17:33:02 <Vorpal> oh right, says so much further down
17:33:07 <Vorpal> so all then
17:33:12 <Vorpal> not just virtually all
17:33:58 <Vorpal> "Broadway is the codename of the 32-bit Central Processing Unit (CPU) used in Nintendo's Wii video game console. It was designed by IBM, and is currently being produced using a 90 nm SOI process." <-- 90 nm. Wow that is quite a way behind PC CPUs
17:34:52 <Phantom_Hoover> You'd almost think the technology was six years old or something.
17:35:11 <Vorpal> Phantom_Hoover, hm weren't Intel at like 60 nm around then?
17:35:16 <elliott> s/PC CPUs/x86/
17:35:19 <Vorpal> elliott, well yes
17:35:25 <elliott> Intel and AMD x86, even.
17:35:30 <Vorpal> indeed
17:35:31 <elliott> "The 90 nm process refers to the level of CMOS process technology that was reached in the 2002–2003 timeframe, by most leading semiconductor companies, like Intel, AMD, Infineon, Texas Instruments, IBM, and TSMC."
17:35:35 <Ngevd> Game Cube used IBM chips
17:35:45 <elliott> 65 nm — 2006
17:35:49 <Vorpal> elliott, Intel and AMD stands for virtually all consumer x86 CPUs used in desktops and laptops though
17:35:53 <elliott> 2011-6 = 2005.
17:35:55 <elliott> So not really.
17:36:05 <Ngevd> elliott, what year is it?
17:36:09 <Vorpal> elliott, hm okay
17:36:22 <Ngevd> Nevermind
17:36:30 <Vorpal> Ngevd, 2012?
17:36:37 <Ngevd> My god.
17:36:40 <Vorpal> bbl
17:37:11 <elliott> Jan 2012.
17:37:24 <elliott> It's not not-2011 for a while now.
17:37:26 <Phantom_Hoover> The Wii was released in late 2006, but since they obviously couldn't use state-of-the art chips at the time of release, I think it's fair to say the underlying technology is all early- to mid-2006 at the latest.
17:37:59 <elliott> Nintendo are really impressively durable with their platforms.
17:38:12 <elliott> At least compared to today's cycles.
17:38:38 <Vorpal> elliott, come on, how old is the PS3? And the xbox 360?
17:38:56 <Phantom_Hoover> Do you know the first thing about either?
17:39:04 <Vorpal> Phantom_Hoover, that they are better than wii?
17:39:10 <elliott> lol
17:39:24 <elliott> Vorpal: because they have a better CPU, right?
17:39:25 <Phantom_Hoover> There are about ten different models of each, which subdivide into about three or four generations of hardware.
17:39:43 <Vorpal> elliott, better hardware at least, not sure if it is the CPU or the GPU (if they even have separate GPUs?)
17:39:59 <Vorpal> Phantom_Hoover, hm. Right.
17:40:15 <elliott> Phantom_Hoover: And Sony aren't exactly announcing the next generation of the PlayStation to be PS3+0.5, like Nintendo have with the Wii U.
17:40:44 <Ngevd> Ah yes, that reminds me.
17:41:00 <Ngevd> I need to correct the genetive of "nemo" from "nullius" to "neminis"
17:41:18 <elliott> Vorpal: I have no comment.
17:42:05 <Vorpal> I believe the PS4 and whatever the next xbox will be called are supposed to be showed at some expo later this year. Not sure if that is confirmed or just rumors.
17:42:09 <Phantom_Hoover> Vorpal, surely even /you/ understand budgeting.
17:42:10 <Vorpal> rumours*
17:42:24 <Vorpal> Phantom_Hoover, yes? What about it?
17:42:39 <Vorpal> Phantom_Hoover, you mean the separate GPU thingy?
17:43:43 <Ngevd> Bye
17:43:47 -!- Ngevd has quit (Quit: Goodbye).
17:43:53 <Vorpal> well, I need to leave as well. Cya.
17:44:05 * Phantom_Hoover notes that according to WP a low-end XBox is actually cheaper than a Wii at launch price.
17:44:53 <elliott> Phantom_Hoover: Those were introduced later, though.
17:45:05 <elliott> Presumably due to market pressures the Wii placed upon consoles.
17:45:34 <Phantom_Hoover> And indeed a Wii is cheaper at current prices.
17:46:12 <elliott> Phantom_Hoover: That's not surprising; at the end of its cycle Nintendo hardware can be bought for about 3 pennies and a piece of fluff.
17:46:39 <Phantom_Hoover> I presume you have done this regularly.
17:46:47 <elliott> Phantom_Hoover: You know not the true face of England.
17:47:07 <Phantom_Hoover> Which makes it all the more amazing that you haven't played any SSB games despite them being the best.
17:50:05 <elliott> Phantom_Hoover: Also the true face of England.
17:50:14 * elliott doesn't even own a Wii.
17:50:27 <Phantom_Hoover> Tut tut tut?
17:50:30 <Phantom_Hoover> Pirate one.
17:50:47 <elliott> Yes.
17:51:19 <elliott> Phantom_Hoover: The solution is clear: a Hexham-Helsinki SSB battle???? For friendship diplomacy. I will supply the friendship,
17:51:42 <Phantom_Hoover> OK.
17:51:45 <Phantom_Hoover> Which SSB.
17:52:25 <elliott> Phantom_Hoover: All... of them... simultaneously?
17:52:31 <elliott> Controlled by the same controller.
17:52:40 <elliott> Polyglot gaming.
17:52:51 <Phantom_Hoover> I don't think you can use an N64 controller with a Wii but wait
17:53:03 <elliott> Phantom_Hoover: There's a "classic" controller for the Wii
17:53:06 <elliott> It's just a matter of software.
17:53:16 <Phantom_Hoover> I know this.
17:53:23 <elliott> EXCUSE ME IM WII EXPERT
17:53:31 <elliott> Phantom_Hoover: Oh my god polyglot gaming of two unrelated games would be the most amazing thing ever.
17:53:33 <elliott> I have a new life goal.
17:55:09 <Deewiant> Hmm, unrelated games hasn't been done as far as I'm aware
17:55:32 <elliott> Deewiant: What has been done by implication?
17:55:37 <Deewiant> Some set of Mega Mans, Mega Man Xs, Final Fantasies, and Marios has been done, at least
17:55:43 <elliott> Neat
17:55:44 <Deewiant> (Those are the ones I recall having seen)
17:55:57 <Deewiant> And this is TAS, not sure if that counts
17:56:04 <elliott> In realtime?
17:56:05 <elliott> Right.
17:56:09 <elliott> Well, that makes it "easier". :p
17:56:47 <Deewiant> Evidently TASVideos has a category for it: http://tasvideos.org/Movies-C2020Y.html
17:56:54 <Deewiant> And there's no others than the ones I remembered
18:00:11 <fizzie> I remembered the Mega Man and the Mario ones, but not that Final Fantasy set.
18:01:09 <fizzie> Didn't some dude play Mega Man X and X2 in realtime?
18:01:29 <fizzie> Or maybe I'm just recalling that TAS thing.
18:01:43 <Deewiant> I don't recall any non-TAS.
18:02:26 <fizzie> Can't find one, so maybe it was just the TAS.
18:02:38 <fizzie> Anyway, there was that "Mario 64 with feet", you never know what people do.
18:03:36 <ais523> fizzie: that TAS has been improved since
18:03:42 <ais523> X1, X2, X3 300%
18:03:55 <ais523> there have been other multigame runs; most are worse than the original, that one's better though
18:04:20 <fizzie> Yes, I can see that. I probably just saw the X1/X2 one.
18:04:27 <fizzie> Also "300%" sounds silly.
18:04:35 <ais523> well, 100% * 3
18:05:52 <elliott> fizzie: you must hate cpu metres
18:06:02 <elliott> ~GOODE NIGHTE FRENS~
18:07:04 <Deewiant> Not all CPU metres use 100% = one CPU
18:07:39 <Deewiant> Or whatever the unit should be called, 100% = one relatively traditional single-threaded core
18:10:18 -!- elliott has quit (Ping timeout: 248 seconds).
18:41:41 <fizzie> Aw, "List of lists" just goes to Portal:Contents/Lists. I was hoping it would be called that.
18:42:06 <fizzie> At least there's the "List of lists of lists".
18:52:10 -!- ais523 has quit (Remote host closed the connection).
18:59:41 -!- azaq23 has joined.
18:59:52 -!- azaq23 has quit (Max SendQ exceeded).
19:00:50 -!- azaq23 has joined.
19:01:21 <Vorpal> <Phantom_Hoover> I don't think you can use an N64 controller with a Wii but wait <-- you could rig up some levers or such to control several physical controllers at once?
19:01:26 <Vorpal> or one in each hand?
19:04:40 <Phantom_Hoover> No, I was wondering if Nintendo offered the original Super Smash Bros. on their internet service.
19:05:11 <Phantom_Hoover> Aha, it is.
19:05:38 <Phantom_Hoover> So you could play all three SSB games at once on a Wii, at least.
19:06:13 <Phantom_Hoover> And yes, indeed, you can use a GameCube controller for all three.
19:06:59 <Vorpal> Phantom_Hoover, I was suggested an alternative solution
19:07:20 <Phantom_Hoover> It is an inferior solution.
19:07:28 <Vorpal> Phantom_Hoover, well yes
19:07:56 -!- monqy has joined.
19:12:35 <itidus20> you can emulate it of course
19:16:25 -!- Ngevd has joined.
19:20:41 -!- Patashu has joined.
19:21:05 <Ngevd> Hello
19:23:41 -!- oerjan has joined.
19:24:29 -!- oerjan has set topic: The Return of the JIT | http://codu.org/logs/_esoteric/.
19:35:25 -!- Gregor has set topic: The Return of the JITchards | http://codu.org/logs/_esoteric/.
19:35:52 <oerjan> what's a JITchard
19:36:12 <oerjan> is it a richard with a speech impediment
19:36:39 <Gregor> JITchards
19:36:49 <Gregor> It's the JIT I wrote for IOCCC
19:36:53 <oerjan> aha
19:37:37 <Ngevd> How did that go?
19:38:06 <oerjan> JITchards, by Jegoj
19:40:03 <oerjan> :t op
19:40:04 <lambdabot> forall o n. (Newtype n o) => (o -> n) -> n -> o
19:40:21 <oerjan> :t rop
19:40:22 <lambdabot> Not in scope: `rop'
19:40:24 <oerjan> :t opr
19:40:25 <lambdabot> Not in scope: `opr'
19:40:46 <Sgeo> op?
19:41:04 <Sgeo> @hoogle op
19:41:04 <lambdabot> System.IO openBinaryFile :: FilePath -> IOMode -> IO Handle
19:41:04 <lambdabot> GHC.IO.Handle.FD openBinaryFile :: FilePath -> IOMode -> IO Handle
19:41:04 <lambdabot> System.IO openBinaryTempFile :: FilePath -> String -> IO (FilePath, Handle)
19:41:34 <oerjan> something like that from simplereflect
19:41:50 <oerjan> which hoogle doesn't cover afaik
19:44:51 <oerjan> it's op, apparently
19:47:50 <oerjan> :t Debug.SimpleReflect.op
19:47:51 <lambdabot> Couldn't find qualified module.
19:47:57 <oerjan> :t fun
19:47:58 <lambdabot> forall a. (SimpleReflect.FromExpr a) => String -> a
19:48:02 -!- Klisz has quit (Quit: SLEEP, GLORIOUS SLEEP).
19:48:06 <oerjan> :t SimpleReflect.op
19:48:07 <lambdabot> Not in scope: `SimpleReflect.op'
19:48:34 -!- Phantom_Hoover has quit (Ping timeout: 276 seconds).
19:49:13 <oerjan> one of lambdabot's great mysteries: how to qualify a given module identifier, if it's even possible.
19:49:17 <oerjan> :t expr
19:49:18 <lambdabot> Expr -> Expr
19:49:38 <oerjan> :t f
19:49:39 <lambdabot> forall a. (SimpleReflect.FromExpr a) => a
19:50:16 <oerjan> :k (SimpleReflect.FromExpr a) => a
19:50:17 <lambdabot> Not in scope: type constructor or class `SimpleReflect.FromExpr'
19:50:24 <oerjan> :k (FromExpr a) => a
19:50:25 <lambdabot> Not in scope: type constructor or class `FromExpr'
19:51:04 <oerjan> :t f == "a"
19:51:05 <lambdabot> No instance for (SimpleReflect.FromExpr [Char])
19:51:05 <lambdabot> arising from a use of `f' at <interactive>:1:0
19:51:05 <lambdabot> Possible fix:
19:53:00 <oerjan> ah it's lambdabot's show package, not all simplereflect.
20:04:24 -!- Taneb has joined.
20:05:28 -!- Ngevd has quit (Ping timeout: 276 seconds).
20:05:36 -!- Phantom_Hoover has joined.
20:08:29 -!- Taneb has quit (Ping timeout: 240 seconds).
20:14:42 -!- pikhq has quit (Ping timeout: 240 seconds).
20:14:45 -!- pikhq_ has joined.
20:23:42 -!- Vorpal has quit (Ping timeout: 240 seconds).
20:25:27 <kallisti> oh my god why are ice cream waffles so good.
20:25:58 <shachaf> It's not that ice cream waffles are so good, it's that everything else is so bad.
20:26:20 <shachaf> Ice cream waffles are the clue left to us by God, indicating that things are so much worse than they could be.
20:26:55 <kallisti> wat
20:27:03 <kallisti> no I'm pretty sure ice cream waffles are just really good.
20:27:10 <kallisti> like... it's like having a waffle cone
20:27:19 <kallisti> but warm and more like an actual waffle
20:27:21 <kallisti> because it is
20:27:23 <oerjan> <kallisti> aside from giving you a nice Ord instance. :P <-- Ord instances are supposed to be _total_ orders (ignoring bottom/nontermination)
20:27:30 <kallisti> oerjan: ah okay.
20:27:44 <monqy> who makes a bottom/nontermination Ord instance
20:28:03 * oerjan swats monqy -----###
20:28:09 <monqy> lists?
20:28:17 <oerjan> well of course.
20:28:18 <shachaf> kallisti: I wouldn't know. I've nevre had an ice cream waffle.
20:28:32 <oerjan> [1..] <= [1..] has no chance of terminating.
20:28:38 <kallisti> monqy: if you instead elect to use _|_ to mean false
20:28:40 <monqy> :'(
20:28:41 <kallisti> and True to mean True
20:29:00 <kallisti> then you can define _|_ to not equal anything.
20:29:02 <kallisti> :>
20:29:10 <monqy> :'( :'( :'(
20:32:19 <Gregor> Dafuq is an ice cream waffle?
20:32:43 <Gregor> Unless you're just talking about waffles with ice cream.
20:34:04 <kallisti> I am
20:34:05 <kallisti> like
20:34:08 <kallisti> waffles
20:34:09 <kallisti> then
20:34:11 <kallisti> put ice cream on them.
20:34:14 <kallisti> ice cream waffle
20:34:22 <Sgeo> oerjan, can't a partial order be said to be a total order ignoring bottom?
20:34:28 <Sgeo> Oh, I guess circular stuff
20:35:06 <Gregor> Logically an ice cream waffle should be a waffle made of ice cream
20:35:07 <oerjan> Sgeo: no, you can have x <= y and y <= x both being False
20:35:09 <Gregor> Except that that is nonsense.
20:35:12 <oerjan> no bottom involved
20:36:08 <oerjan> partial orders have no circularity, they still have transitivity.
20:41:13 -!- GreaseMonkey has joined.
20:44:29 -!- pikhq_ has quit (Ping timeout: 240 seconds).
20:44:32 -!- pikhq has joined.
20:49:55 -!- pikhq_ has joined.
20:50:02 -!- pikhq has quit (Ping timeout: 252 seconds).
21:14:46 -!- Klisz has joined.
21:15:36 <Phantom_Hoover> How have I not watched all the French and Saunders clips on YouTube by now.
21:20:43 -!- pikhq has joined.
21:21:31 -!- pikhq_ has quit (Ping timeout: 276 seconds).
21:32:53 -!- Patashu has quit (Ping timeout: 252 seconds).
21:48:24 <itidus20> "<oerjan> Sgeo: no, you can have x <= y and y <= x both being False" this is weird.
21:49:13 <monqy> never heard of a partial order?
21:49:47 <itidus20> not before today
21:50:02 <itidus20> im on the wiki page now
21:50:09 -!- Ngevd has joined.
21:50:24 <shachaf> Partial ordering is the best kinds of ordering.
21:50:33 <shachaf> Other than well-ordering.
21:50:37 <shachaf> And a semilattice.
21:50:52 <Ngevd> Hello
21:51:33 <monqy> i'm rather partial to it myself
21:53:03 <oerjan> itidus20: a good example is set inclusion. neither of {1,2} and {1,3} is contained in the other.
21:53:18 <Phantom_Hoover> shachaf, what about pizza ordering?
21:53:33 <shachaf> Phantom_Hoover: That's just lazy.
21:53:52 <shachaf> Go to the pizzeria yourself if you want pizza so much.
21:53:58 <itidus20> cowabunga
21:54:51 <itidus20> american adaptions of italian food described by anthropomorphic turtles using surfer terminology
21:55:00 -!- Zuu has quit (Ping timeout: 252 seconds).
21:55:28 <itidus20> in a japanese animated adaption of an american comic
21:56:02 <monqy> the world truly is beautiful
21:56:48 <shachaf> @google is the world beautiful
21:56:49 <lambdabot> http://www.theworldisbeautiful.com/
21:56:49 <lambdabot> Title: the world is beautiful
21:57:00 <shachaf> Hotels and restaurants that match your preferences:Luxurious and Relaxing Hotels in Buenos Aires
21:57:12 <shachaf> Truly.
21:58:13 <Ngevd> Goodnight
21:58:15 -!- Ngevd has quit (Quit: Goodbye).
22:03:24 <itidus20> i have pondered about the mysteries of order before
22:03:50 <monqy> mysteries?
22:03:53 <itidus20> but without breaking any ground
22:04:12 <itidus20> uh.. now i suppose i have to try to remember
22:07:02 <Sgeo> When I was a kid, I used to ponder stuff about infinities and alternate number lines and numbers defined such that its absolute value < 0
22:08:53 -!- Patashu has joined.
22:09:55 -!- itidus20 has quit (Ping timeout: 252 seconds).
22:12:50 -!- Zuu has joined.
22:12:50 -!- Zuu has quit (Changing host).
22:12:51 -!- Zuu has joined.
22:17:06 * Phantom_Hoover → sleep
22:17:07 -!- Phantom_Hoover has quit (Quit: Leaving).
22:38:00 -!- itidus21 has joined.
22:38:52 <itidus21> `searchlog itidus list
22:39:34 <HackEgo> No output.
22:40:18 -!- pikhq_ has joined.
22:40:24 -!- pikhq has quit (Ping timeout: 248 seconds).
22:46:50 <itidus21> about order, i recall once not so long ago trying to figure out something wrong with my conception of lists.. but i cant remember exactly what my thought was
22:47:31 <itidus21> something about the [first] [??] [??] [last]
22:49:59 <oerjan> well that doesn't look obviously wrong so far :P
22:51:40 <kallisti> @src first
22:51:41 <lambdabot> Source not found. Sorry about this, I know it's a bit silly.
22:51:48 <oerjan> kallisti: Arrow method
22:51:51 <oerjan> @src Arrow
22:51:52 <lambdabot> class Arrow a where
22:51:52 <lambdabot> arr, pure :: (b -> c) -> a b c
22:51:52 <lambdabot> (>>>) :: a b c -> a c d -> a b d
22:51:52 <lambdabot> first :: a b c -> a (b,d) (c,d)
22:51:52 <lambdabot> second :: a b c -> a (d,b) (d,c)
22:51:53 <lambdabot> (***) :: a b c -> a b' c' -> a (b,b') (c,c')
22:51:56 <lambdabot> (&&&) :: a b c -> a b c' -> a b (c,c')
22:52:08 <oerjan> @src first (->)
22:52:09 <lambdabot> Source not found. BOB says: You seem to have forgotten your passwd, enter another!
22:52:15 <oerjan> @src (->) first
22:52:15 <lambdabot> first f = f *** id
22:52:21 <kallisti> is it not defined in terms of -- ah yes
22:52:23 <oerjan> @src (->) (***)
22:52:23 <lambdabot> (f *** g) ~(x,y) = (f x, g y)
22:52:51 <kallisti> yes
22:53:16 <kallisti> *** is like two processes in parallel.
22:54:09 <kallisti> basically it produces a function on the product of the two argument types of its operand functions.
22:54:13 <oerjan> well parallel dataflow. i'm sure the Kleiski instance does one of them first.
22:54:16 <kallisti> yes.
22:54:24 <oerjan> @src Kleiski (***)
22:54:24 <lambdabot> Source not found. Just try something else.
22:54:29 <kallisti> I didn't mean "process" in any kind of concurrent sense.
22:54:42 <oerjan> um
22:54:45 <oerjan> @src Kleisli (***)
22:54:46 <lambdabot> Source not found. And you call yourself a Rocket Scientist!
22:54:53 <oerjan> :t Kleisli
22:54:54 <lambdabot> forall a (m :: * -> *) b. (a -> m b) -> Kleisli m a b
22:55:07 <kallisti> @src (,) (&&&)
22:55:07 <lambdabot> Source not found.
22:55:15 <kallisti> halp
22:55:25 <oerjan> i don't know that (,) is an Arrow
22:55:35 <kallisti> @src (->) (&&&)
22:55:35 <lambdabot> Source not found. I've seen penguins that can type better than that.
22:55:36 <oerjan> the first argument has the wrong variance
22:55:39 -!- itidus21 has quit (Ping timeout: 248 seconds).
22:55:55 <oerjan> @src (&&&)
22:55:55 <lambdabot> f &&& g = arr (\b -> (b,b)) >>> f *** g
22:56:09 <kallisti> ah
22:56:17 <kallisti> it takes a single flow of data and splits it in two.
22:56:24 <kallisti> :t arr
22:56:26 <lambdabot> forall b c (a :: * -> * -> *). (Arrow a) => (b -> c) -> a b c
22:56:37 <oerjan> > (f &&& g) x :: Expr
22:56:38 <lambdabot> Couldn't match expected type `SimpleReflect.Expr'
22:56:38 <lambdabot> against inferred ...
22:56:42 <oerjan> oops
22:56:52 <oerjan> > (f &&& g) x :: (Expr, Expr)
22:56:53 <lambdabot> (f x,g x)
22:56:58 <kallisti> yes
22:57:19 <oerjan> > (f *** g) (x,y) :: (Expr, Expr)
22:57:20 <lambdabot> (f x,g y)
22:57:37 <kallisti> yes
22:57:42 <kallisti> not sure I get what arr is doing though
22:57:58 <kallisti> er well I know what it's doing in that case
22:57:59 <kallisti> just not in general
22:58:19 <oerjan> turns a function into an arrow
22:58:23 <kallisti> is it like... ah okay
22:58:40 <kallisti> yes I see that based on the type.
22:59:14 <kallisti> arr (join (,)) >>> f *** g
23:00:36 <oerjan> some have complained that arr is used too much in the Arrow definitions
23:00:54 <oerjan> makes it hard to generalize to arrow-like things that _don't_ embed all functions.
23:01:39 <oerjan> or arrow-like things where you want to be able to analyze the flow at runtime without running into opaque functions all the time
23:03:31 <oerjan> like, you could imagine using arrow notation to build a circuit of logical gates
23:31:23 -!- cheater has joined.
23:34:09 -!- Frooxius has quit (Quit: ChatZilla 0.9.88-rdmsoft [XULRunner]).
←2012-01-09 2012-01-10 2012-01-11→ ↑2012 ↑all