←2012-03-13 2012-03-14 2012-03-15→ ↑2012 ↑all
00:01:26 <fizzie> oerjan: 7 days. (W|A.)
00:01:36 <oerjan> ah
00:02:12 <fizzie> (604800 seconds.)
00:05:22 <ais523> elliott: Wikipedia used a stock timespan parser from somewhere, which has a bunch of joke features
00:05:37 <fizzie> The other day W|A threw me an interstitial-style pop-up-and-darken-the-rest-of-the-page ad about something or other, plus a "switch to W|A Pro to get rid of annoying ads" text.
00:06:34 <fizzie> Maybe "modal dialog ad" is a more apt description.
00:06:54 <fizzie> Except that sounds like an advertisement for modal dialogs.
00:07:27 <fizzie> "Get your modal dialogs here! App-modal, system-modal, we've got them all!"
00:10:30 -!- augur has quit (Remote host closed the connection).
00:17:09 <pikhq_> `frink 11218573000000000000000000000000000000000000000000 plancktime -> "seconds"
00:17:20 <HackEgo> 604819.95790859072818 seconds
00:17:32 <pikhq_> oerjan: Thar
00:17:45 <ais523> `frink 11218573000000000000000000000000000000000000000000 plancktime -> "weeks"
00:17:49 <ais523> what's with the quotes at the end?
00:17:55 <HackEgo> 1.0000329991874846696 weeks
00:18:06 <ais523> `frink 1 week -> "plancktime"
00:18:16 <HackEgo> 1.1218202808422283826e+49 plancktime
00:18:18 <pikhq_> ais523: Quotes tell frink to just display the unit at the end...
00:18:23 <pikhq_> `frink ` week -> plancktime
00:18:25 <pikhq_> Compare.
00:18:31 <pikhq_> Also, bleh.
00:18:31 <ais523> `frink 1 week -> plancktime
00:18:34 <HackEgo> Unrecognized character '`' in line 1, column 0... ignoring. \ 1.1218202808422283826e+49
00:18:43 <HackEgo> 1.1218202808422283826e+49
00:18:51 <ais523> oh, changes whether the unit's displayed
00:18:53 <ais523> that's weird
00:19:02 <pikhq_> Yeah, but that's how frink works.
00:19:32 <oerjan> happy pi day!
00:20:00 * pikhq_ notes that US units are really mad.
00:20:09 <pikhq_> `frink 6 feet -> "survey feet"
00:20:20 <HackEgo> 1499997/250000 (exactly 5.999988) survey feet
00:20:39 <pikhq_> Yeah, that's right, multiple notions of the foot.
00:20:43 * oerjan suddenly realizes tau day is his birthday, feels conflicted
00:21:54 <pikhq_> `frink 30 miles per gallon -> rods per hogshead
00:22:05 <HackEgo> Warning: undefined symbol "per". \ Warning: undefined symbol "per". \ Warning: undefined symbol "per". \ Warning: undefined symbol "per". \ Warning: undefined symbol "per". \ 1999996/13125 (approx. 152.3806476190476)
00:22:09 <pikhq_> :(
00:22:11 <elliott> /
00:22:21 <pikhq_> `frink 30 miles/gallon -> rods/hogshead
00:22:30 <HackEgo> 377999244/625 (exactly 604798.7904)
00:22:35 <RocketJSquirrel> `frink 1 planck length -> lightcenturies
00:22:44 <HackEgo> Warning: undefined symbol "length". \ Unknown symbol "lightcenturies" \ Warning: undefined symbol "length". \ Warning: undefined symbol "lightcenturies". \ Unconvertable expression: \ 1 m^2 s^-1 kg (angular_momentum) length (undefined symbol) -> lightcenturies (undefined symbol)
00:22:45 <elliott> plancklength
00:22:48 <RocketJSquirrel> :(
00:22:53 <elliott> you're multiplying planck by length
00:22:56 <pikhq_> Or l_P
00:22:58 <elliott> sheesh
00:23:01 <RocketJSquirrel> `frink 1 plancklength -> lightyears
00:23:11 <HackEgo> 1.7083801957597206401e-51
00:24:09 <elliott> * oerjan suddenly realizes tau day is his birthday, feels conflicted
00:24:10 <elliott> oerjan: :D
00:24:15 <RocketJSquirrel> `frink 1 year -> planktimes
00:24:24 <HackEgo> Unknown symbol "planktimes" \ Warning: undefined symbol "planktimes". \ Unconvertable expression: \ 3.1556925974678400e+7 s (time) -> planktimes (undefined symbol)
00:24:29 <RocketJSquirrel> >: (
00:25:12 <MDude> 'frink 1 year -> planktime
00:25:14 <elliott> `frink planktime = 10 years; 1 year -> "planktime"
00:25:19 <elliott> erm
00:25:20 <elliott> `frink planktime = 10 years; 1 year -> "planktimes"
00:25:25 <HackEgo> 0.099999999999999999999 planktime
00:25:25 <elliott> was trying to show off the automatic pluralisation
00:25:30 <HackEgo> Unknown symbol "planktimes" \ Warning: undefined symbol "planktimes". \ Unconvertable expression: \ 3.1556925974678400e+7 s (time) -> planktimes
00:25:34 <elliott> whoops
00:25:35 <elliott> failed horribly
00:25:44 <elliott> it's been a while, as they say
00:25:58 <olsner> it's been a plank
00:26:11 <elliott> yes
00:26:24 <MDude> Light must have gotten a lot slower for the plank time to be that long.
00:26:50 <oerjan> `frink 1 gausss
00:27:00 <HackEgo> 1/10000 (exactly 1.0e-4) s^-2 kg A^-1 (magnetic_flux_density)
00:27:00 <elliott> MDude: Have you *seen* a plank?
00:27:02 <elliott> They hardly move.
00:27:20 <elliott> oerjan: Gausssssssssnake.
00:28:45 <pikhq_> I like how Frink uses base units.
00:29:18 <oerjan> by dose is ruddig :(
00:29:30 <pikhq_> `frink 30 miles per gallon -> "m^-2"
00:29:41 <HackEgo> Warning: undefined symbol "per". \ Warning: undefined symbol "per". \ Unconvertable expression: \ 17847743385087/97656250000 (approx. 182.76089226329088) m^4 (unknown unit type) per (undefined symbol) -> m^-2
00:29:46 <pikhq_> Blah
00:29:49 <pikhq_> `frink 30 miles/gallon -> "m^-2"
00:29:58 <HackEgo> 1440000000000/112903 (approx. 1.275431122290816e7) m^-2
00:30:06 <pikhq_> Yaaay.
00:30:30 <elliott> arcanesentiment has had no posts for over 6 months :(
00:31:00 <ais523> annoying VHDL feature: it doesn't allow __ in a variable name, compilers enforce this
00:31:12 -!- cswords_ has joined.
00:31:21 <ais523> what sane reason is there to ban __ inside variable names? so that it can safely be used as a separator in name mangling rather than using length prefixes?
00:31:28 <elliott> __internal_use_names
00:31:38 <ais523> elliott: normally you ban a prefix for that
00:31:44 <ais523> not something that can be put anywhere inside the name
00:31:56 <ais523> (fwiw, my Verity compiler uses leading 0 on internal use names, as names can't normally start with a digit)
00:34:28 -!- cswords has quit (Ping timeout: 246 seconds).
00:34:34 <pikhq_> Also, this ain't C.
00:35:15 <elliott> ais523: why do you need internal names?
00:35:35 <ais523> elliott: stuff generated by desugaring, mostly
00:35:49 <elliott> ais523: that means you're doing it wrong :(
00:35:51 <ais523> also, one of the keywords ("export") works by generating a variable behind the scenes ("00export")
00:35:55 -!- augur has joined.
00:36:03 <ais523> elliott: well, the resulting variables have to be called something in the VHDL code!
00:36:12 <elliott> gah, Tektur creates [[graph]] the day after I considered doing so
00:36:18 <pikhq_> Okay, I guess it is C. :P
00:36:18 <elliott> only my article would have made sense
00:37:34 <ais523> elliott: we try to let the user's variable names get all the way through into the generated code
00:37:43 <ais523> partly this is so that the linker works, partly it's to make things easier to debug
00:38:54 <elliott> ais523: I didn't disagree with that
00:39:14 <ais523> so this means that when extra variables are added, they need names too
00:39:57 <elliott> the problem is that you're adding extra variables
00:42:08 <ais523> this is variables in the functional programming sense
00:42:36 <ais523> so here's a problem for you: suppose you have the following code: f(x;x); f(x||x)
00:42:43 <ais523> err, I don't mean that
00:42:50 <ais523> f(\x.x;x); f(\x.x||x)
00:42:59 <ais523> now, the two arguments to f don't have compatible signatures
00:43:00 <elliott> s/variables/names/ then
00:43:16 <ais523> err, you have it backwards; a "name" is kind-of like a pointer or a reference
00:43:25 <elliott> i'm not talking in verityspeak
00:43:38 <ais523> computer science has a whole load of widely-defined terms
00:43:42 <ais523> you can't just redefine them at random!
00:43:49 <ais523> "name" in Algol-like languages is like a reference
00:43:52 <elliott> fine
00:43:54 <elliott> go on
00:44:19 <ais523> so this needs to be desugared into f(\x1.\x2.x1;x1); f(\x1.\x2.x1||x2)
00:44:31 <ais523> (the first throws away x2)
00:44:48 <elliott> ok, replace
00:44:49 <elliott> type VarName = String
00:44:50 <elliott> with
00:45:05 <elliott> data VarName = VarName String Integer
00:45:11 <elliott> the latter is the number (1,2,etc.)
00:45:15 <ais523> elliott: now, suppose I do f(\x.x;x); f(\x.x||x); f(g)
00:45:20 <ais523> and g has the same type as \x.x;x
00:45:37 <ais523> oh wait, in that case I can change g to \j.g or whatever
00:45:56 <ais523> oh, still works, I need to invent a fresh name for the lambda that's put around g
00:46:01 <ais523> in your terminology
00:46:15 <elliott> I think your real problem is that you have a desugaring step that goes from language L to language L.
00:46:15 <ais523> so I get f(\x1.\x2.x1;x1); f(\x1.\x2.x1||x2); f(\j.g)
00:46:34 <elliott> You want a step from L to L', where L' is more suited to this purpose in a way that includes not having to make up names and wrap things in lambdas.
00:46:35 <ais523> nah, it goes from one language to a slightly different one
00:46:47 <elliott> Yes, but you're not exploiting the opportunity to make them different enough.
00:47:04 <ais523> elliott: anyway, the \j.g /goes through to the final hardware/
00:47:10 <ais523> you can identify the individual wires that make up j
00:47:16 <ais523> and they need names
00:47:32 <elliott> not necessarily
00:47:38 <ais523> well, they need names in the VHDL code
00:47:38 <elliott> you could represent it as a nameless graph structure or the like
00:47:54 <ais523> VHDL doesn't let you have wires that don't have names
00:47:54 <elliott> really, I would never write a source code transformation on something with explicit string variable names
00:48:00 <elliott> ais523: that's the backend's problem
00:48:08 <ais523> but I wrote the backend too!
00:48:22 <ais523> you think I should generate the arbitrary names, which are different from all existing names, in the backend rather than frontend?
00:48:30 <ais523> I don't see how that would modify the problem at all
00:48:39 <elliott> I think you should eliminate names entirely, tbh
00:49:02 <ais523> but then I wouldn't have them the same in the final VHDL program as the original user's prorgam
00:49:03 <ais523> *program
00:49:16 <ais523> (mangled, there's an s/_/0_0/g and a suffix to preserve case-sensitivity)
00:49:19 <elliott> well, I don't necessarily care, but you can easily fix that
00:49:32 <elliott> just have some graph nodes labelled and others not, or the like
00:50:12 <ais523> elliott: you also have to allow for the problem that such graphs aren't easily represented with ADTs
00:50:19 <ais523> and the most common way to do so is /to give the nodes arbitrary names/
00:50:23 <ais523> so you're not even gaining anything
00:50:37 <elliott> well, that's an implementation detail of the graph library
00:50:49 <elliott> admittedly, I'm more likely to use a de bruijn form than a graph
00:51:19 <ais523> I must stop asking you for advice :)
00:51:25 <ais523> how's your own Verity compiler/interp getting on?
00:51:48 <elliott> I haven't coded more than one thing in weeks
00:52:00 <ais523> ouch, that seems /really/ out of character for you
00:52:12 <elliott> oh, I don't mean I've coded that thing throughout those weeks
00:52:16 <elliott> just I've only written one thing in weeks
00:52:25 <ais523> either way
00:53:53 <ais523> problems with school, or something like that?
00:54:03 <elliott> no, I've just had nothing to code :(
00:54:30 <ais523> not even a Verity compiler? ;)
00:54:39 -!- derdon has quit (Remote host closed the connection).
00:54:42 <ais523> I thought you wanted to write one with a less insane license
00:54:48 <elliott> http://esolangs.org/wiki/Talk:Main_Page
00:54:51 <ais523> and you presumably wouldn't be targeting hardware, so no need for SCC transforms, etc
00:55:05 <elliott> I guess I should tell em we're planning on doing a featured languages thing even though it's not quite what e's talking about...
00:55:23 <ais523> yes; also, we've already settled on such a list, haven't we?
00:55:31 <elliott> i believe so
00:55:32 <ais523> BF, Befunge, INTERCAL, Unlambda, Underload
00:55:35 <ais523> did I miss one?
00:55:36 <elliott> well
00:55:42 <elliott> "the most interesting possible"
00:55:50 <elliott> I'd go for befunge, unlambda, underload, ///, BCT or something
00:56:03 <elliott> BF and INTERCAL aren't really astonishingly interesting
00:56:08 <ais523> well, hm
00:56:18 <ais523> we'd really want to show off all corners of esolang design
00:56:24 <RocketJSquirrel> Malbolge?
00:56:29 <ais523> there are some missing genres there, e.g. we'd want a thematic language
00:56:31 <ais523> RocketJSquirrel: good point
00:56:34 <ais523> preferably a /good/ one
00:56:40 -!- augur has quit (Remote host closed the connection).
00:56:43 <ais523> Shakespeare or Chef or Haifu or something like that
00:57:00 -!- oerjan has quit (Quit: Good night).
00:57:06 <elliott> it would be nice to have a page with "exceptional examples of esolang design" for esolang-designers-to-be
00:57:11 <elliott> perhaps it would even dissuade BF derivatives
00:57:23 <RocketJSquirrel> Instead we'd get Befunge derivatives!
00:57:24 <RocketJSquirrel> Hooray!
00:58:01 <RocketJSquirrel> I would also proffer Kipple and some OISC.
00:58:15 <ais523> Befunge is not a language that takes well to derivatices
00:58:18 <ais523> *derivatives
00:58:22 <ais523> should be an OISC there, indeed
00:58:23 <elliott> brainfuck, befunge, intercal, unlambda, underload, ///, bct, malbolge, shakespeare|chef|haifu, kipple, subleq?
00:58:30 <elliott> that's 11
00:58:41 <elliott> I suppose BCT isn't all that vital to a newcomer
00:58:50 <elliott> and it's much closer to a CA than an esolang
00:58:54 <ais523> also, there's a corner of esolangs with several examples that I don't think has a name, but it stores all its data in a queue or stack or something like that, and is reasonably imperative
00:58:58 <RocketJSquirrel> I would say BCT isn't an esolang, although it's a "language" of esointerest.
00:59:04 <ais523> elliott: Fractran?
00:59:18 <elliott> fractran wasn't even designed as an esolang
00:59:30 <elliott> <ais523> also, there's a corner of esolangs with several examples that I don't think has a name, but it stores all its data in a queue or stack or something like that, and is reasonably imperative
00:59:32 <elliott> FALSE-likes?
00:59:35 <ais523> no, but there was an equivalent language that was
00:59:43 <elliott> Bag
00:59:44 <ais523> elliott: FALSE is a little atypical of it
00:59:53 <ais523> I was thinking more along the lines of Sceql
00:59:56 <elliott> ah
01:00:05 <elliott> are there more examples than {Qdeql, Sceql}?
01:00:09 <ais523> (FALSE is in there, but is an outlier)
01:00:22 <ais523> I thought so, but now I'm having problems thinking of them
01:00:24 <ais523> to the wiki!
01:00:52 <ais523> probably half of http://esolangs.org/wiki/Category:Stack-based
01:01:23 <RocketJSquirrel> Is Piet worth consideration? It's really only interesting in its encoding, but still ..
01:01:25 <ais523> Piet counts
01:01:39 <ais523> it uses an unusual source code form, but computationally it's just like that
01:01:49 <elliott> RocketJSquirrel is talking about for this hypothetical page
01:02:05 <RocketJSquirrel> Yes.
01:02:10 <ais523> elliott: I know, it was a timing coincidence
01:02:15 <ais523> I didn't see his comment while I was writing mine
01:02:18 <RocketJSquirrel> Also, Schrodilang.
01:03:06 <elliott> ais523: oh, that's amazing
01:03:30 <elliott> RocketJSquirrel: r u srs
01:03:34 <RocketJSquirrel> No X-D
01:03:44 <RocketJSquirrel> I will not proffer any of my own languages in seriousness X-D
01:04:13 <elliott> oh you made that
01:09:56 -!- fizzie has quit (Ping timeout: 260 seconds).
01:10:31 -!- fungot has quit (Ping timeout: 260 seconds).
01:11:22 <ais523> hey, remember that one-dimensional MMO we were discussing ages ago?
01:11:26 <ais523> `pastlog one-dimensional MMO
01:11:47 <elliott> no
01:11:50 <elliott> but go on
01:11:58 <HackEgo> No output.
01:27:37 <RocketJSquirrel> Clearly best dimensionality for an MMO.
01:27:48 <elliott> ais523: goooon
01:27:50 <elliott> *
01:27:54 <elliott> g oooooon
01:27:56 <elliott> goooooooo n
01:28:15 <ais523> elliott: I can't remember many of the details either
01:28:17 <ais523> that's why I asked
01:28:28 <ais523> I remember that it was going to give some kind of main advantage for being online constantly
01:28:50 <ais523> some mechanic involving swapping with someone, and you could cancel a swap that someone was trying to do to you manually within 5 minutes or so
01:35:48 <Sgeo> DANGIT
01:36:00 <Sgeo> I was looking at HPMOR on TV Tropes, and uncovering spoilers
01:36:07 <Sgeo> Uncovered a spoiler for the new chapter.
01:41:50 <pikhq_> It's not like it's that hard to read, it's only longer than the goddamned Yudkowsky sequences. :P
01:42:39 -!- augur has joined.
01:44:50 <Sgeo> pikhq_, I have previously read HPMOR
01:44:57 <Sgeo> I don't remember much of it though.
01:48:21 <augur> ais523: ty
01:49:23 <elliott> what
01:53:28 <augur> ais523: thank you
01:54:43 <elliott> what
01:56:01 <Sgeo> elliott, tswett monqy UPDATE
01:56:47 <tswett> Dankes.
01:58:28 <ais523> augur: thanks for thanking me
01:58:47 <elliott> ais523: thanks
01:58:55 <augur> ais523: for your comment on the typo on reddit
01:59:30 <ais523> ah, OK
01:59:40 <ais523> that was your program? I don't have everyone here's reddit usernames memorized
01:59:47 <ais523> elliott: you're welcome
02:00:10 <ais523> come to think of it, I'm not sure if a recursive function with no recursive call is even legal in Verity
02:00:11 <ais523> let me check
02:00:12 <augur> ais523: indeed. me = psygnisfive
02:00:49 <ais523> $ ./gosc -S /tmp/t.ia
02:00:51 <ais523> /tmp/t.ia: recursion in input program cannot be converted: recursive argument f not used in fix(\f.c_skip$0) [line 1 character 0 - line 1 character 11]
02:00:58 <ais523> indeed it isn't
02:02:52 <elliott> ais523: thanks
02:03:34 <ais523> sadly, the error message for something like "fix \f.\x.{f(f(x))}" is much worse, as the compiler can't figure out exactly where the error happens, just that it happens
02:03:52 <ais523> (I must write an article about Verity programming some day; the semantics are almost eso in some places, e.g. that line isn't obviously wrong)
02:04:07 <elliott> ais523: link to verity's site?
02:04:26 <ais523> http://www.veritygos.org/
02:04:32 <ais523> which in Firefox, at least to me, is an infinite redirect loop
02:04:53 <ais523> also Epiphany, so it's not a result of refusing cookies
02:04:55 <ais523> wow, that's impressive
02:04:57 <elliott> thanks, can you be less helpful now?
02:05:03 <elliott> you could link me to a gopher URI, say
02:05:22 <elliott> $ curl -I http://www.veritygos.org/
02:05:22 <elliott> HTTP/1.1 301 Moved Permanently
02:05:22 <elliott> Cache-Control: private
02:05:22 <elliott> Content-Length: 0
02:05:22 <elliott> Location: http://www.veritygos.org
02:05:25 <ais523> the old name, https://sites.google.com/site/thegeometryofsynthesis/ is still working
02:05:31 <elliott> someone needs firing
02:05:51 <elliott> ais523: have you tried to convince the lawyers to let you license it under something more reasonable any more?
02:06:08 <ais523> <ais523 to website owner> That link is currently a redirect to itself.
02:06:19 <ais523> nah, because my boss agrees with them, and he's not worth arguing with
02:06:27 <ais523> besides the license is reasonable, for what it's intended for
02:06:53 <ais523> hmm, it makes quite a statement
02:06:57 <ais523> it's like the website version of a fixed point
02:07:28 <kmc> BART has an official unofficial map: http://www.bart.gov/schedules/developers/maps.aspx
02:08:36 -!- fizzie has joined.
02:08:39 <elliott> ais523: you said verity's syntax is documented; where is that?
02:08:42 <elliott> also, what license are the libraries under?
02:08:47 <ais523> in a file grammar.txt inside the documentation
02:08:51 <ais523> and permissive, it's all in the EULA
02:09:35 <elliott> I haven't read the EULA, much less agreed to it
02:09:36 <ais523> "(e) Directory Examples can be used, copied, reproduced and distributed without restriction."
02:09:46 <elliott> meh, I didn't agree to that, so I guess I can't
02:10:09 <ais523> hmm, they forgot "modified"
02:10:18 <elliott> forgot?
02:10:21 <elliott> I am sure it was intentional
02:10:24 <ais523> perhaps
02:11:14 <elliott> how many library files are there?
02:11:49 -!- cheater_ has quit (Ping timeout: 252 seconds).
02:12:23 <ais523> $ find lib -name '*.vhd' | wc -l \ 5 \ $ find lib -name '*.v' | wc -l \ 2 \ $ find include -name '*.ia' | wc -l \ 4
02:12:31 <ais523> depends on your definition
02:12:39 <ais523> we're planning to write more
02:12:51 <ais523> and maybe support .ml libraries for the interpreter
02:13:08 <ais523> thing that annoys me; OCaml's compiler is not available via the OCaml libraries
02:13:17 <ais523> it's written in OCaml, there's no reason it /shouldn't/ be
02:13:18 <elliott> my definition is "how much I have to rewrite"
02:13:26 <elliott> can I convince you to not write any more so I don't have to rewrite them?
02:13:46 <ais523> you can't convince me not to do my job :)
02:13:53 <ais523> however, I'm not sure how many more or less my job will require me to write
02:14:16 <ais523> however however, some of them are platform-specific to platforms you probably don't own, and some are very simple
02:14:44 <ais523> one thing not described in the distribution is the VHDL/Verilog API, which is important for writing libraries in languages other than Verity
02:14:52 <ais523> it is described in our papers, though
02:14:54 <elliott> hmm, there's nothing stopping a Verity implementation doing sharing, right?
02:14:59 <ais523> apart from the naming schemes
02:15:01 <elliott> or, hmm, it's impure
02:15:03 <elliott> so there is
02:15:10 <ais523> "sharing" = what, in this context?
02:15:17 <elliott> call-by-need
02:15:54 <ais523> yep, let f = \x.x;x in new x:=2 in f(x := !x + 1); print(x)
02:16:16 <ais523> (whitespace is irrelevant except for separating alphanumeric tokens, as you probably guessed already)
02:16:18 <elliott> anyway, what license does grammar.txt have?
02:16:58 <ais523> err, huh
02:17:01 <ais523> the license defines Documentation
02:17:06 <ais523> and then there are no license terms relating to it
02:17:19 <elliott> wonderful
02:17:25 <ais523> I believe that means that its license is all rights reserved, by default
02:17:29 <ais523> but I'm not a lawyer so don't know for certain
02:17:55 <elliott> I don't think I can implement Verity without agreeing to terms I find unacceptable, then, unless you retranscribe the grammar for me
02:18:30 <ais523> elliott: if you read the grammar off a website, would that be unacceptable?
02:18:51 <ais523> note that (despite what Oracle are claiming in court), implementing an API is not a derivative work of that API
02:19:00 <elliott> that would be fine, assuming that I don't have to agree to an EULA
02:19:23 <elliott> and I'm not worried about creating a derivative work; I just don't want to agree to the EULA, and am not convinced a court would accept my argument that I didn't when downloading my copy of gosc.tgz
02:19:31 <ais523> "By installing, downloading, and/or using the Software, You agree to the terms and conditions of this Agreement."
02:19:43 <ais523> ah, hmm, Software apparently includes Documentation
02:19:51 <elliott> that doesn't mean anything
02:19:54 <elliott> oh, hmm, I see
02:19:56 <ais523> who comes up with these definitions?
02:20:18 <elliott> I don't believe that reading a grammar definition on a website can cause me to agree to an EULA
02:20:38 <ais523> ah, OK, the license terms apply to the Software as a whole, including the documentation
02:20:56 <ais523> elliott: perhaps I can persuade them to put the grammar on the website, then
02:21:12 <elliott> prediction: they'll put it behind an EULA
02:21:16 <ais523> hahaha
02:21:23 <ais523> they didn't put the quick-start guide behind a EULA
02:21:36 <elliott> meh, why can't you just explain the grammar to me on IRC? any grammar more than 500 chars isn't worth using :)
02:21:56 <ais523> (it's behind a download link, though, for reasons I don't understand; but it's a Markdown file with a .txt extension, because I passed it off to them as plain text)
02:23:17 <ais523> hmm
02:23:25 <ais523> operator precedence is a pain to describe over IRC
02:23:36 <ais523> due to notation that would simplify describing it being used in the language itself
02:23:46 <ais523> maybe I'll just explain in operator precedence order
02:23:53 <ais523> starting at the loosest
02:24:38 <elliott> i hate operator precedence
02:25:05 <ais523> so, loosest is lambda (\a.b), scoped binding (let a = b in c, which is sugar for (\a.c)(b)), fixedpoint (fix \a.b); fixedpoint has the same semantics as fix in haskell, except it must take a literal lambda as its argument
02:25:22 <ais523> and although those are all equal, I don't think there's any possible circumstance in which it would matter anyway
02:25:36 <ais523> next is pair formation (a,b)
02:25:39 <elliott> hmm, "Adding two numbers is O(log n)" I thought arithmetic was generally taken to be O(1)
02:25:43 <ais523> not by me!
02:25:50 <tswett> The category of programming languages, where arrows are compilers. Discuss.
02:26:05 <ais523> tswett: seems pretty categorical to me
02:26:14 <tswett> Verily.
02:26:37 <ais523> after that is the creation of memory cells, "new a in b", which causes a to be a memory location throughout b (and then cease to exist again)
02:26:49 <elliott> erm, "a" is a little vague there
02:26:54 <elliott> i see foo(128) in trees.ia
02:26:54 <ais523> oh, it's an identifier
02:26:59 <elliott> foo(128) is an identifier?
02:27:00 <ais523> that's array creation
02:27:04 <elliott> ok
02:27:11 <ais523> which is something else that we haven't added to our grammar documentation
02:27:21 <elliott> well that's helpful.
02:27:28 <ais523> and specifically, serial array creation (an array where you can only access one element at a time)
02:27:37 <ais523> btw, whether things can happen simultaneously or not is critical to understanding Verity
02:27:43 <elliott> er, does that not apply to all arrays?
02:27:53 <elliott> hmm
02:27:53 <ais523> that's the only sort of array we've implemented so far
02:28:05 <elliott> I'm not convinced I need to care about the simultaneous thing for an implementation on standard computers
02:28:06 <elliott> do I?
02:28:09 <ais523> we're planning parallel arrays too, with syntax probably a[128], which would be sugar for defining 128 different variables
02:28:18 <ais523> no, unless you plan to reject incorrect programs
02:28:32 <ais523> the interpreter works by passing the code through the compiler's type-checker, then throwing away the output ;)
02:28:50 <ais523> (except for inferring things like bitwidths)
02:29:19 <elliott> rejecting incorrect programs would be nice
02:29:38 <ais523> OK, after that, is a || b, which is parallel composition; a and b must be allowed to be executed simultaneously, obviously
02:29:51 <ais523> then a;b, sequential composition (i.e. "do a then b")
02:30:00 <ais523> both || and ; take two commands as arguments and return a command
02:30:12 <ais523> (and a command is a 0-bit integer with possible side effects)
02:30:30 <ais523> then come the control structures: "while a do b" and "if a then b else c"
02:30:52 <elliott> this language is too big :(
02:30:57 <ais523> the first argument is a 1-bit integer; while takes a command as its loop body, if allows any base type in the then and else fields
02:30:58 <elliott> why can't while/if be just primitives?
02:31:01 <elliott> it's call-by-name
02:31:03 <ais523> well, it's meant to be practical
02:31:10 <ais523> and they are, but there's syntax for them
02:31:15 <ais523> to stop people having to write whiledo(a)(b)
02:31:22 <elliott> that just means your function call syntax is ugly
02:31:41 <elliott> but go on
02:32:07 <ais523> it actually gets desugared into an ffi call internally, (c_while:(exp$1*com)->com) a b
02:32:19 <ais523> and the actual implementation of while is done by the FFI
02:32:30 <ais523> then is assignment, a := b
02:32:30 <elliott> what is this foo$7 stuff i see in trees.ia?
02:32:34 <elliott> ok never mind keep going
02:32:42 <ais523> that's really really tightly binding
02:32:56 <ais523> and part of the identifier syntax, at that
02:33:17 <elliott> yeah, never mind, just keep going
02:33:52 <ais523> after that comes arithmetic primitives, | ^ (left-associative), &, == (non-associative), < > (non-associative), << >> +>> (left-associative), + - (left-associative), *
02:33:57 <elliott> RIP Encyclopædia Britannica, you will not be missed
02:34:05 <RocketJSquirrel> Other languages to go to the best-of page: IRP
02:34:08 <ais523> all have the same meaning as in C, except that >> is unsigned rightshift and +>> is signed rightshift
02:34:34 <ais523> (i.e. >> fills the left-over bit with 0, +>> fills it with the sign bit of the original number, like >>> and >> in Java)
02:34:53 <elliott> RocketJSquirrel: And Glass?
02:34:54 <ais523> there's also a +< and +> for signed comparisons, which aren't in this grammar file for some reason; < and > are unsigned
02:35:01 <RocketJSquirrel> elliott: Naaaaaaaaaaaaaaaaaw
02:35:10 <ais523> after that is ~, unary bit-complement (the same as in C)
02:35:13 <elliott> ais523: you know, Haskell solved this operator syntax problem excellently.
02:35:15 <ais523> after that is !, variable dereference
02:35:39 <monqy> excellently?
02:36:01 <elliott> monqy: better than ais523 solved it
02:36:12 <monqy> what is this verity thing
02:36:18 <ais523> then is function call, "a(b)" (can also be written as "a b" if b is sufficiently simple; IIRC it must be a constant or identifier, possibly with a cast)
02:36:54 <ais523> then tightest of all is bitwidth conversion, a$$n where n is a literal integer, which discards high bits or zero-extends
02:37:02 <ais523> (and likewise, a+$$n discards high bits or sign-extends)
02:37:09 <elliott> i am really not looking forward to implementing this parser
02:37:12 <ais523> you can also put various type assertions on things
02:37:36 <ais523> examples would be :com, :exp$5, :(com -> com)
02:37:49 <ais523> single-dollar is a bitwidth assertion, which can be used on types or numerical constants
02:37:54 <ais523> so 0$8 means an eight-bit zero
02:38:00 <ais523> and exp$5 a five-bit integer
02:38:04 <ais523> exp$0 is equivalent to com
02:38:23 <ais523> and 0$0 can also be written as "skip"
02:38:39 <ais523> unary minus always requires parens, incidentally
02:38:45 <ais523> to distinguish between a-1 and a(-1)
02:39:06 <ais523> anyway, that's about it, syntactically
02:39:14 <ais523> there's also a lambda that works on tuples, \(a,b).x
02:39:29 <elliott> OK, I gave in and looked at grammar.txt
02:39:52 <ais523> and the difference between \a.\b.x and \(a,b).x is that the second asserts that a and b can be used simultaneously, the first asserts that they can't be
02:39:53 <elliott> which is a vaguely less agonising way to present this mess of a syntax :P
02:40:07 <elliott> here's a more useful question: what's the type system?
02:40:17 <ais523> well, there are three different type systems…
02:40:34 * elliott 's desire to implement Verity over time, graphed: \
02:40:35 <ais523> programs are written in ICA, but must be valid in SCC
02:40:46 <ais523> and then that's converted to SCI for use in hardware
02:40:51 -!- Jafet has joined.
02:40:59 <ais523> I could try to describe them over IRC, or just link you to the papers defining them
02:42:11 <elliott> the latter will probably save you time, since I can not read them more efficiently than I can not read your explanations of them
02:42:17 <ais523> here, http://www.cs.bham.ac.uk/~drg/papers/popl11.pdf
02:42:37 <ais523> that describes not only all the type systems used, but all the algorithms we use to convert between them
02:43:14 <ais523> oh, and it describes the resulting circuitry too
02:43:23 <ais523> except in the case of recursion, which we hadn't worked out at the time that paper was written
02:43:29 <elliott> what if i just skipped the type system? ;)
02:43:37 <monqy> what is verity and why is it like this
02:43:51 <ais523> well, then you wouldn't be rejecting invalid programs, but it'd still work fine on the valid ones, mostly
02:43:54 <ais523> except for bitwidth inference
02:44:39 <elliott> monqy: ais523&co.'s impure, call-by-name higher-order functional language
02:44:43 <elliott> designed to compile to hardware
02:44:54 <ais523> for instance, print(~4) implies that the 4 is a 32-bit 4, at least if you do an "import <print>"
02:45:10 <ais523> because print.vhd defines print as being of type exp$32->com
02:45:25 <ais523> and of course the bitwidth of the 4 will affect what its complement is
02:46:41 * elliott wonders if ais523 has monqy on ignore or something
02:46:47 <ais523> I don't
02:46:52 <ais523> just you answered faster than I did
02:46:59 <ais523> monqy: I wanted to call it ALGOL-11
02:47:02 <ais523> but they wouldn't let me
02:47:16 <ais523> well, ALGOL-12 by now I guess, but 11 sounds nicer
02:47:56 <elliott> ais523: he asked earlier, too
02:48:23 <ais523> it is very much an Algol dialect, though, semantically
02:48:34 <ais523> and the syntax is different but based off similar principles
02:48:52 <ais523> elliott: oh, there's also {} in the syntax, which is sugar for ():com
02:49:07 <ais523> so you can write while 1 do {command; another_command}
02:49:31 <ais523> the type system also has var, but it's sugar for something
02:49:56 <ais523> ah, var$n = (exp$n*(exp$n->com))
02:50:25 <ais523> which means that I guess ! and := could be implemented in pure Verity, if I were so inclined
02:50:29 <ais523> but there's no way to define operators yet
02:50:43 -!- Jafet has quit (Quit: Leaving.).
02:50:53 <ais523> oh, and the other thing that it's easy to miss is that division doesn't exist
02:50:56 <ais523> we might add a library for div and mod
02:51:00 <elliott> <ais523> but there's no way to define operators yet
02:51:01 <elliott> <elliott> ais523: you know, Haskell solved this operator syntax problem excellently.
02:51:36 -!- Sgeo has quit (Read error: Connection reset by peer).
02:51:38 <ais523> just by interpreting any random string of characters it doesn't understand as an operator
02:51:48 <ais523> but that's actually more complex than what we're doing at the moment
02:51:56 <ais523> *string of punctuation marks
02:52:04 -!- Sgeo has joined.
02:52:13 <elliott> that's a rather pov way of putting it :p
02:52:47 <ais523> because you'd need to get the parser to parse prio operatives (or whatever you call them, but it's called prio in algol 68) and then change the way it parsed from then on accordingly
02:52:52 <ais523> I thought you didn't like state?
02:53:00 <ais523> (^ both nonsequitur and strawman)
02:53:53 <elliott> ais523: how many 1-pass compilers are there?
02:53:59 <elliott> anyway, I already said I hate operator precedence
02:54:07 <elliott> so no, the parser doesn't have to do that at all
02:56:29 -!- ion has quit (Ping timeout: 260 seconds).
02:56:45 <ais523> elliott: it's very hard to convince people to use a language where a+b*c doesn't do what they expect
02:57:02 <ais523> "looking vaguely familiar" was the main criterion we used to design Verity's syntax
02:57:10 -!- ion has joined.
02:57:19 <ais523> I added {} for ():com simply because I wanted to use them for while statements
02:57:32 <ais523> because it looked weird with ()
02:58:05 * elliott isn't sure "convincing people to use Verity" is a real problem ais523 faces :P
02:58:20 <ais523> I don't face it /personally/
02:58:31 <ais523> but I was asked to help the people/person out whose job it was
03:01:04 * elliott evaporates
03:02:32 <elliott> ais523: anyway, why does the language need a built-in notion of bitwidths?
03:02:47 <ais523> concession to hardware, where everything needs a set bitwidth
03:03:17 <ais523> "4-bit integer" and "1024-bit integer" are completely different types, the type system should reflect that
03:03:33 <elliott> ais523: #
03:03:39 <elliott> (this is a new macro meaning "you misinterpreted my previous comment")
03:03:51 <elliott> I'm asking why it needs anything other than bits at all as primitive
03:04:01 * Sgeo installs the PinkiePie fix
03:04:03 <elliott> I don't see why arithmetic on n-tuples of bits should be built-in
03:04:33 <ais523> elliott: because it's an operation that people will want to do a lot? and because it makes sense to be able to access the bits of an integer in parallel with each other?
03:04:54 <ais523> (exp$1 * exp$1) is not the same type as (exp$2) in terms of the operations you can do o nit
03:04:55 <ais523> *on it
03:05:07 <ais523> as the first is a promise that you won't access the two bits simultaneously
03:05:14 <elliott> ais523: people want to do lots of operations a lot, that doesn't mean they have to be axiomatic!
03:05:54 <elliott> and, OK, I misused n-tuple
03:06:00 <elliott> you need a parallel tuple type then
03:06:18 <ais523> not really, that'd complicate the type system considerably for no real gain
03:06:38 <elliott> at the same time as simplifying it (by removing bitwidths)
03:06:39 <ais523> tupling is serial, currying is parallel, is the whole heart of the language
03:06:50 <ais523> (c_seq:com*com->com) (c_par:com->com->com)
03:07:08 <ais523> elliott: well, you'd need to add empty tuples as well, or else make com a separate type from exp$0
03:07:46 <elliott> I would do that anyway (making com a separate type), although empty tuples are good too, so might as well rename com to () or such
03:07:48 <ais523> elliott: also, you'd need a sufficiently smart compiler to even produce remotely efficient hardware
03:08:02 <elliott> hmm, why? I don't see why you wouldn't be able to translate it back efficiently
03:08:11 <ais523> because it's possible to force individual parts of a tuple
03:08:18 <ais523> and the hardware would need to reflect that
03:08:24 <elliott> let's say parallel tupling is &, why can't (exp & exp & exp) just translate to exp$3?
03:08:34 <ais523> imagine a program like (\(a,b).a)(print(4),print(5))
03:08:57 <elliott> ugh, stop overloading syntax :)
03:09:00 <ais523> or (\(a&b).a)(print(4)&print(5)) with & as parallel tuple rather than bitwise &
03:09:07 <ais523> and I didn't overload syntax, did I?
03:09:08 <elliott> is ^ used?
03:09:10 <ais523> at least, what do you think I overloaded
03:09:13 <ais523> yes, bitwise XOR
03:09:15 <elliott> I thought you overloaded (a,b)
03:09:20 <elliott> hmm... is @ used?
03:09:22 <ais523> (a,b) means a tuple b
03:09:25 <ais523> nope, @ isn't used
03:09:34 <elliott> OK, the type is (a @ b) with constructor (a @ b) then, go on
03:09:42 <elliott> what type does print(4) have?
03:09:46 <ais523> com
03:09:56 <ais523> print itself has type exp$32->com
03:10:11 <ais523> because some definite value needs to be picked for separate compilation, and 32 is nicely sized for most applications of print
03:10:13 <elliott> (aka (exp@exp@exp@...) -> com)
03:10:16 <ais523> yep
03:10:20 <elliott> OK, so, let's pick little-endian
03:10:31 <elliott> (\(a&b).a) is, in your current language, just (\x.x&1)
03:10:34 <ais523> now, (exp@exp@…) would allow you to force individual bits independently
03:10:41 <elliott> nope, that's the whole point
03:10:44 <ais523> and have different side effects on different bits
03:11:03 <ais523> which would mean 32 potential entry points
03:11:16 <ais523> which would be rather nastily inefficient for hardware that's O(number of entry points)
03:11:22 <elliott> nope, that's the whole point
03:11:52 <ais523> elliott: OK, so you have a parallel tuple that forces you to force every element at once?
03:12:11 <ais523> hmm, this concept actually exists in call-by-push-value, it has two types of tuples for this reason
03:12:17 <elliott> ais523: Isn't exp$32 a parallel 32-tuple that forces you to force every element at once?
03:12:47 <ais523> elliott: well, no, it's not implemented like that, but it is equivalent to that
03:13:04 <elliott> i thought you were being incredulous at the idea
03:13:08 <ais523> elliott: anyway, this type system doesn't even make sense now, what's ((com*com)@com) meant to mean?
03:13:10 <elliott> sorry if i misinterpreted
03:13:12 <ais523> (com*com) has two entry points
03:13:25 <ais523> so which of them gets forced when you force the whole thing?
03:13:37 <elliott> hmm, give me a second to try and understand your silly language :)
03:13:52 <ais523> this isn't even my language any more, it's basic call-by-name semantics
03:14:11 <elliott> yes, but I don't see a problem, in terms of call-by-name semantics
03:14:17 <elliott> forcing a tuple forces the outer tuple but neither of the elements
03:14:26 <elliott> that's how the non-strict languages I know work
03:14:29 <elliott> WHNF and all that
03:14:43 <elliott> or are your tuples unlifted or something fancy like that
03:14:48 <ais523> elliott: oh, in Verity, you force individual tuple elements, forcing the whole tuple isn't something that makes sense
03:14:58 <ais523> and likewise, it's impossible to sequence a tuple with something, seq only works on base types
03:14:58 <elliott> so it _is_ your language :)
03:15:00 -!- MDude has changed nick to MSleep.
03:15:11 <elliott> well, presumably it forces both, then
03:15:16 <ais523> elliott: it's that way in all the literature for Algol-like languages
03:15:47 <elliott> ais523: well, that means you identify _|_ and (_|_,_|_), right?
03:15:50 <ais523> elliott: think of com as being like a monad action, if it helps; that's one valid way to implement it
03:15:52 <elliott> so it's an unlifted product type
03:16:22 <ais523> elliott: (_|_, _|_) would be a reasonable way to define _|_ at a product type, yes
03:16:33 <elliott> right, so all you're saying is that your product type is unlifted
03:16:36 <elliott> (whereas, e.g. Haskell's is lifted)
03:16:50 <elliott> ais523: then, I don't see what's wrong with forcing both sides of it
03:16:59 <ais523> because (_|_, 0) is also a legal value
03:17:00 <elliott> that's the reasonable implementation, IMO, since (,) is clearly strict in both of its arguments
03:17:05 <elliott> ais523: that's fine
03:17:15 <elliott> oh, right, (,) isn't strict
03:17:18 <elliott> anyway
03:17:23 <elliott> that just means that (_|_, 0)@anything happens to be _|_
03:17:26 <elliott> lots of things are _|_, what's the problem?
03:17:39 <ais523> it is impossible to define (,) in Verity, except in terms of itself
03:18:03 <elliott> i retracted my comment about (,)
03:18:18 <ais523> elliott: so which /order/ does it force the two sides of (print 0, print 1)@skip?
03:18:42 <ais523> it can't force them simultaneously, , introduces a serial tuple
03:19:15 <elliott> I feel like pointing out that I didn't actually mean this was the only acceptable solution, btw, and had another possible one in mind, but
03:19:17 <elliott> ais523: left first, why not
03:19:48 <ais523> I fail to see how this type system is less complicated than the one with a primitive fixed-width integer type :)
03:20:16 <elliott> <elliott> I feel like pointing out that I didn't actually mean this was the only acceptable solution, btw, and had another possible one in mind, but
03:20:16 <ais523> oh, the other reason things like + are primitive in Verity, is that you can't define polymorphic functions
03:20:28 <elliott> yes, that's another broken thing about verity ;)
03:21:01 <ais523> from a semantic level, if you write print(3+4), the compiler will generate a 32-bit + for you
03:21:04 <ais523> and use that
03:21:17 <ais523> to prevent a huge amount of duplication, it uses generics in the generated VHDL
03:21:50 <elliott> yes, so you just want C++ template style generics
03:21:53 <elliott> *polymorphism
03:21:57 <ais523> yep
03:21:58 <elliott> that's perfectly OK, but you should expose it to your users too
03:22:02 <ais523> it is, in the FFI
03:22:07 <elliott> no, not in the FFI :)
03:22:14 <ais523> but + gets desugared into an FFI call
03:23:12 <ais523> I agree that proper C++-style templates would make a reasonable addition to the language, though; they're mentioned in one of our papers
03:23:20 <ais523> well, not /that/ C++-style, that would be insane by definition
03:23:23 <ais523> but the basic idea
03:23:32 <elliott> it can look identical to ML/haskell-style polymorphism at the language level
03:23:53 <elliott> the only thing you'd lose, expressivity-wise, is complicated polymorphic recursion
03:24:42 <ais523> polymorphism only over bitwidths would be so much easier
03:24:57 <ais523> mostly because VHDL doesn't support polymorphism except for array bounds
03:25:13 * elliott mumbles distaste at implementation-oriented language design
03:25:33 <ais523> although, it'd be nice if a parallel array was just a template that took a compile-time param and returned a variable
03:25:45 <ais523> now I'm seriously thinking about this
03:26:24 <elliott> right now, you can't even write generic data structures in verity, right?
03:26:39 <ais523> you can't even write recursive data structures
03:26:55 <ais523> except by rolling your own malloc-alike, or by implementing them as functions (which is very inefficient for most practical uses)
03:26:56 <elliott> sure you can, you have a trees implementation :P
03:27:02 <ais523> oh, you saw that?
03:27:09 <elliott> yes, it is available on the website
03:27:13 <ais523> that's done with a roll-your-own-malloc, and not a particularly efficient one at that
03:27:15 <ais523> I didn't write it
03:27:18 <elliott> that's why I asked about arrays
03:27:22 <ais523> that was my supervisor trying to prove a point
03:27:32 <elliott> what point?
03:27:41 <ais523> that hardware recursion was useful, or something
03:27:45 <ais523> I'm not entirely sure myself
03:28:07 <elliott> isn't that obvious?
03:29:03 <ais523> perhaps
03:29:16 <ais523> there are so many restrictions on our hardware fix impl that I'm not at all convinced it's useful
03:29:25 <elliott> what restrictions?
03:29:34 <ais523> no parallelism anywhere near it, mostly
03:29:51 <ais523> also, you can't nest fix inside fix; it's possible to design circuitry so you could, but it'd be much less efficient so we don't
03:30:11 <elliott> hmm, does that just mean syntactically, or does that mean in fix e, you cannot use any code that uses fix in e?
03:30:14 <ais523> (fix \f.\x.(f(x)||skip) cannot be implemented in hardware with the techniques we're using)
03:30:44 <ais523> and it's a semantic restriction; it's implementing syntactically into the compiler because I couldn't figure out how it worked in the type system and how to modify the compiler accordingly
03:30:59 <elliott> this language sucks way more than @hwlang :(
03:31:13 <ais523> well, we've already achieved more with it than anyone else has before
03:31:16 <ais523> apart from pipelining
03:31:20 <ais523> but I'm working on that atm
03:31:37 <elliott> what's the catch, btw?
03:31:46 <ais523> "the catch"? in what?
03:32:03 -!- pikhq has joined.
03:32:07 <elliott> well, i was brought up believing hardware can't do any of this, so there's clearly some deception going on :)
03:32:25 <ais523> there's a limited recursion value, because you run out of memory for a stack after a while
03:32:37 -!- pikhq_ has quit (Ping timeout: 272 seconds).
03:32:44 <ais523> although instead of having a global stack, which has terrible performance by hardware standards, we have a different stack for each variable in the program
03:32:56 <ais523> i.e. new allocates stacks rather than individual memory cells
03:33:04 <elliott> dynamic scope?!
03:33:27 <ais523> it's done by getting all the state in the program to refer to a different location depending on the recursion depth
03:33:32 <ais523> including state in control
03:33:50 <ais523> (i.e. remembering which branch of the ; you're in in \x.x;x)
03:34:58 <ais523> λq.(λg.g(λx.g(qx)))(λb.(λk.((k(λu.u))(λl.((kb)(λt.(l(t skip)))))))(λv.λw.wv))
03:35:11 <ais523> took me so long to work out that expression :)
03:35:41 <elliott> what is that?
03:35:42 <ais523> it's of type (com^m -> com^n -> com)^(n^2) -> com, m <= 1
03:36:03 <ais523> the issue was finding an expression that had a side-condition like that
03:36:13 <ais523> that's SCC type
03:36:33 <ais523> it was hard enough proving that the type system was even decidable in the absence of polymorphism
03:36:42 <ais523> it is, but it's nontrivial enough to see that that we got a paper out of it
03:36:47 <ais523> together with the type system transformations
03:37:35 <ais523> this is arguably a deficiency of the type system, due to using (\v.\w.wv) in two unrelated contexts that just happen to have similar types
03:37:46 <ais523> I'm not convinced that ML lets you do that either, though
03:37:52 <ais523> (Anarchy would!)
03:39:33 <elliott> btw, is it just me or does your language have nothing to do with algol
03:40:29 <ais523> it's just you
03:40:38 <ais523> its semantics are almost identical to algol 60's
03:40:52 <ais523> allowing for the difference in syntax
03:41:03 <ais523> which isn't even that different; they both work on the same principle, just use different names for things
03:41:57 <ais523> oh, and algol 60 doesn't have ||
03:42:02 <ais523> the file extension should really be .ica rather than .ia
03:42:12 <ais523> but what happened was that I was using .ica and my supervisor was using .ia
03:42:20 <ais523> and we had to standardise on one eventually
03:42:22 <ais523> besides, .ia looks better
03:42:35 <elliott> no, .ica does
03:42:44 <ais523> well we can't change it /now/ :P
03:43:37 <elliott> btw, I'm not convinced that call-by-need is compatible with hardware (the gosc site suggests it is)
03:44:00 <ais523> that was a crazy idea that my supervisor said
03:44:02 <elliott> after all, it involves heavy, global mutation in a concurrent setting
03:44:16 <ais523> he was talking to someone else, and they decided it would be worthwhile for the compiler, and might even replace pipelining
03:44:19 <elliott> OK, you don't necessarily need the global, if you're OK with evaluation being per-thread
03:44:20 <ais523> and I had to tell them why they were completely wrong
03:44:25 <elliott> i.e. each thread evaluates a thunk zero or once
03:44:28 <ais523> they'd basically discovered common subexpression elimination
03:44:32 <elliott> ais523: haha
03:44:35 <ais523> and confused it with call-by-need
03:44:46 <elliott> well, tell him to fix the website, then ;)
03:45:07 <ais523> although, "parallel call-by-need" or whatever it's called could be worthwhile
03:45:20 <ais523> we discovered that it's possible via a source-level transformation, though
03:45:43 <elliott> what does parallel call-by-need mean, precisely?
03:46:16 <ais523> basically, whenever you determine the value of a lambda variable in a particular scope, you start specializing everything in that scope that uses the variable, in the background
03:46:28 <ais523> and then when it goes out of scope, kill the specializations
03:46:37 <elliott> err, that sounds nothing like call-by-need
03:46:40 <ais523> and return to the original
03:46:59 <ais523> elliott: well, think of it this way: \x.print(x+1);print(x+1)
03:47:25 <ais523> as soon as that's called, x gets a value, x+1 gets specialized in the background (i.e. only executed once), and you end up printing the sum twice while only calculating it once
03:48:16 <ais523> the similarity with common subexpression elimination comes when you realise that's equivalent to \x.new y := x+1 in print(!y);print(!y), with a backgrounded initialization of y
03:48:25 <ais523> (important if print takes some time to set up before it asks for !y's value)
03:48:42 <elliott> hardware is weird
03:49:09 <ais523> anyway, we realised that in the absence of side-effects, background-calculating things didn't actually cost anything at all
03:49:38 <ais523> not even in the need to be able to kill the calculation halfway through, because we can use the same circuitry for that as we do for the global reset
03:49:52 <ais523> (which is necessary so that we don't end up with multiple instruction pointers at power on)
03:50:49 <elliott> so has any of this been tested on a real fpga? :P
03:51:06 <ais523> no, but if we do it, it'll be as a source-level translation anyway
03:51:17 <ais523> together with extra support for a one-way parallel composition
03:51:42 <elliott> no, I mean, gosc itself
03:51:48 <ais523> yes, of course
03:52:13 <ais523> why do you think that quickstart.txt contains detailed notes on which things to click in Quartus II to get it working properly? or have you not read that?
03:52:48 <elliott> indeed not
03:52:51 <elliott> but i was joking
03:53:40 <ais523> someone who's apparently really important came round, and we showed him a recursive memoized Fibonacci that displayed its result in hex on some seven-segment displays
03:53:44 <ais523> running on an actual FPGA
03:53:47 <elliott> argh, i just remembered that thing shachaf said
03:53:58 <elliott> also, heh, what did he say?
03:54:09 <ais523> I wasn't there at the time
03:54:12 <ais523> so I don't know
03:54:13 <elliott> ah
03:54:25 <ais523> anyway, the funny thing was that he was giving a seminar, and I was pretty much forced to attend
03:54:35 <ais523> but by the time I got there, the whole room was full and there was no room for me, so I didn't
03:54:41 <shachaf> elliott: Wait, what did I say?
03:54:42 <ais523> and it seems the same threat had gone out to the whole department
03:54:52 <elliott> shachaf: Remember when you asked what "either, but not both" meant logically?
03:54:59 <elliott> My brain has started to attempt to try and work it out. :-(
03:55:03 <ais523> it's an xor, isn't it?
03:55:06 <shachaf> I said that?
03:55:13 <elliott> ais523: no
03:55:23 <elliott> ais523: the idea is that you get to pick whether (P & ~Q) or (~P & Q)
03:55:28 <shachaf> Oh, I remember that now.
03:55:31 <elliott> but then you're not allowed to go back and change your mind
03:55:42 <ais523> elliott: clearly that requires state :)
03:55:47 <elliott> ais523: well, it's like linear logic, sort of
03:55:56 <ais523> not really
03:56:05 <elliott> well, I'm stating it vaguely
03:56:08 <elliott> I don't think it requires state
03:56:19 <elliott> just a different structure
03:56:23 <ais523> p :- \+ q_mem, assertz(p_mem). q :- \+ p_mem, assertz(q_mem).
03:56:24 <shachaf> If you don't think it requires state, why are you stating it???
03:56:32 * shachaf contributes to the discussion.
03:56:41 <elliott> ais523: heh
03:56:51 <ais523> it's much clearer in Prolog :P
03:57:10 <elliott> anyway, I think any solution using actual state misses the point of the question
03:57:52 <elliott> you essentially want (forall R, (P&~Q -> R) & (~P&Q -> R) -> R), except it can only be used once
03:57:59 <elliott> except it's not even "only once", really
03:58:04 <elliott> you just don't want to be able to nest it
03:58:10 <elliott> except it's a bit stronger than that, because you could pass id...
03:58:42 <ais523> elliott: something like "X=p" and "X=q" in Prolog?
03:58:59 <ais523> either is true, but not if you use them both in the same scope
03:59:04 <elliott> ais523: yes, similar
03:59:23 <elliott> the "one-use" thing is why I think linear logic is vaguely related
03:59:44 <ais523> elliott: (p, q)?
03:59:47 <ais523> in Verity?
03:59:50 <elliott> hmm?
03:59:59 <ais523> you can't use p and q at the same time
04:00:10 <elliott> heh
04:00:13 <ais523> the type system forces it, linear-logic-style
04:00:17 <elliott> right
04:01:26 <elliott> hmm... I don't really know anything about linear logic, but would asserting (X ⊸ (P ⊗ Q^⊥)) ⊗ (X ⊸ (P^⊥ ⊗ Q)) work?
04:01:33 <elliott> then X is P orbutnotboth Q
04:01:43 <elliott> I suspect that doesn't actually work, but am too ignorant to know why
04:01:54 <ais523> I don't know anything about that syntax for linear logic
04:02:00 <ais523> other than recognising it
04:02:03 <elliott> I was copying from Wikipedia
04:02:14 <elliott> ^⊥ is the dual thing
04:02:18 <elliott> ⊸ is linear implication
04:02:35 <elliott> "⊗ is called "multiplicative conjunction" or "times" (or sometimes "tensor")"
04:02:44 <elliott> but perhaps I meant & ("additive conjunction") and didn't realise it
04:02:48 <elliott> again, I really know nothing about linear logic
04:02:55 <elliott> [[ ! is pronounced "of course" (or sometimes "bang")
04:02:55 <elliott> ? is pronounced "why not"]]
04:02:58 <elliott> other than that it's ridiculous...
04:03:05 <ais523> "⊗" is typically pronounced as "tensor" regardless of what it actually means
04:04:37 <ais523> affine type systems, on the other hand, I'm happy with /those/
04:04:48 <ais523> (an affine type system is like a linear one, except it allows you to not use a variable if you don't want to)
04:04:57 <elliott> that would work for this, I think
04:05:40 <ais523> anyway, -> is affine in SCI and Verity
04:05:59 <ais523> (and tuple formation is non-affine, which is why it has the restriction that you can only use one side at a time; so that the hardware itself ends up used in an affine way)
04:07:35 <shachaf> That's affine type system you got there.
04:07:46 <shachaf> It would be a shame if anything was to happen to it.
04:12:00 <elliott> it sounds like shachaf has an affinity for ais523's type system
04:12:13 <ais523> don't make this into a pun thread :(
04:12:29 <elliott> oerjan isn't here, we have to work twice as hard to cover for his absence
04:12:51 <elliott> i started coming up with another pun, but gave up before i affinis-ed
04:13:51 <elliott> ais523: come on that one was awful
04:14:19 <ais523> maybe if I ignore them they'll go away?
04:15:08 <elliott> ais523: careful, if you start ignoring everyone you might incur some unwanted affines you have to pay
04:15:44 <shachaf> elliott: So what's an efficient way to do operations on columns of a (row-major) matrix?
04:16:33 <elliott> shachaf: make it be column-major instead?
04:16:52 <shachaf> elliott: I'm doing booperations on both columns and rows.
04:16:55 <shachaf> But the rows are easy.
04:17:16 <elliott> booperations
04:17:33 <ais523> shachaf: just use a stride?
04:17:45 <ais523> have a pointer and add the width of a row to it each time round the loop
04:17:52 <shachaf> Come on, elliott, booperate with me on this.
04:17:55 <ais523> probably not cache-efficient, but I don't think there is a cache-efficient way to do that
04:18:14 <shachaf> ais523: Right, I was looking for something more cache-efficient. :-)
04:18:30 <ais523> but how can there be one? the stuff you're looking for is not together in memory
04:18:31 <elliott> shachaf: Store it in BOTH row-major and column-major order!!
04:18:39 <ais523> I guess you could use a GPU, where you manage the caches yourself?
04:18:42 <elliott> In fact, interleave the row-major and column-major representations, one element per each.
04:18:43 <shachaf> ais523: I know. :-(
04:18:52 <shachaf> I've half a mind to just transpose the matrix first.
04:19:04 <elliott> Come on, interleaving would be great.
04:19:09 <ais523> so that you only incure the cache-inefficiency penalty once?
04:19:11 <shachaf> If I was doing enough column operations it would probably be worth it, but I'm only scanning each column once.
04:19:24 <ais523> elliott: interleaving is nearly always a bad idea cache-wise
04:19:30 <ais523> no matter what you're interleaving or why
04:19:48 <shachaf> @ty interleave
04:19:49 <lambdabot> forall (m :: * -> *) a. (MonadLogic m) => m a -> m a -> m a
04:19:51 <shachaf> TAKE THAT, OLEG
04:19:51 <elliott> ais523: OK, /fine/, buy two-dimensional memory and store the row-major stuff /behind/ the column-major stuff
04:19:53 <ais523> unless, on a CPU, the values you're interleaving would always be accessed together
04:20:00 <elliott> (what do you mean, you could just use the two-dimensional storage directly?)
04:20:09 <ais523> dual-layer memory? like a DVD?
04:20:18 <elliott> yes
04:20:24 <elliott> i was going to say that, but decided 2d would be better as it would let me make that joke
04:20:44 <shachaf> YAY, JOKES
04:20:59 <shachaf> Also, transposing a matrix in-place is hard. :-(
04:21:29 <ais523> shachaf: I gave a lecture partly about doing that efficiently
04:21:44 <ais523> because the person who was meant to give it booked a plane in the morning rather than the afternoon
04:22:02 <ais523> (because he'd tried to book one in the afternoon, been offered one in the morning instead, and didn't check to make sure it was at the time he requested)
04:22:43 <shachaf> That sounds exciting.
04:23:17 <ais523> the funny thing is, that over half the matrix transpose stuff had been made moot since the year before
04:23:23 <ais523> because GPUs had got better at accessing device memory
04:31:14 <elliott> 1.19 still isn't out!
04:31:53 <shachaf> @google what is 1.19
04:31:56 <lambdabot> http://antoine.frostburg.edu/chem/senese/101/measurement/faq/volume-to-mass-air.shtml
04:31:57 <lambdabot> Title: General Chemistry Online: FAQ: Measurement: How can the mass of air in a room be ...
04:32:07 <elliott> ais523: "We have to write out binary data, so we use the writeFile defined in Data.ByteString.Char8, which operates on ByteStrings. This is why we need to convert our String to a ByteString first using B.pack."
04:32:09 <elliott> erm
04:32:10 <elliott> *shachaf:
04:32:16 <elliott> Also, 1.19 is http://mediawiki.org/.
04:32:22 <shachaf> Is 1.19 the new albumen?
04:32:35 <shachaf> It's out now.
04:34:19 <shachaf> Hmm.
04:34:42 <shachaf> Maybe I can transpose the matrix while I'm doing the row operations?
04:35:00 <shachaf> I guess that still doesn't help.
04:35:23 <elliott> shachaf: Why not make the matrix symmetric?
04:35:29 <elliott> Then you can skip the transposition altogether.
04:35:40 <shachaf> Why not just make it all zeros?
04:35:45 <shachaf> Then I can store it in constant space.
04:35:53 <elliott> Bit constraining, don't you think?
04:36:15 <elliott> hmm, what if you stored a matrix with a Z-order curve?
04:37:17 * shachaf wasn't familiar.
04:37:37 <shachaf> However, I don't really see how that would help with column locality...
04:37:50 <elliott> I don't think it would, I'm just thinking about representations.
04:38:01 <elliott> To pack stuff closer together.
04:40:36 <elliott> http://upload.wikimedia.org/wikipedia/commons/d/da/Lebesgue-3d-step3.png sleep.png
05:05:42 -!- asiekierka has joined.
05:09:02 <ais523> a GPU can transpose matrices at over 60GBps
05:10:04 <elliott> how fast can CPUs do it?
05:12:16 -!- cswords__ has joined.
05:15:31 -!- cswords_ has quit (Ping timeout: 246 seconds).
05:23:41 <elliott> ais523:
05:23:57 <ais523> not sure
05:24:01 <ais523> haven't tried
05:24:04 <ais523> but I don't think it's that fast
05:27:15 <elliott> wow, Jimbo Wales is actually the designated method of appealing an arbcom decision
05:27:20 <elliott> why is WP bear-ocracy so fascinating?
05:27:30 -!- pikhq_ has joined.
05:27:40 -!- pikhq has quit (Ping timeout: 240 seconds).
05:55:43 <zzo38> I once wrote a matrix transposing program in QBASIC which was part of another program for compressing sokoban levels
06:06:47 <shachaf> elliott: You're an expert in C++ and g++'s optimizations, right?
06:17:31 <elliott> shachaf: Yes.
06:17:33 <elliott> Go on
06:17:38 <ais523> elliott: I think you can also appeal to arbcom, in the case of new evidence, or simply nobody understanding the previous verdict
06:17:47 <shachaf> elliott: Is there a reason g++'s optimizer would compile the uncommented-out line very differently from the commented-out ones in <http://ideone.com/vJ109>?
06:18:30 <elliott> ais523: yep, but the higher authority is explicitly jimbo
06:19:02 <elliott> http://en.wikipedia.org/wiki/Wikipedia:Arbitration/Policy#Appeal_of_decisions
06:19:37 <elliott> shachaf: That one's twice as short.
06:19:42 <elliott> So it's probably faster.
06:20:27 <elliott> shachaf: Why are you coding C++?
06:20:31 <shachaf> elliott: The first of the three lines is even shorter, though. :-(
06:20:57 <shachaf> elliott: Because it's the best language.
06:21:06 <elliott> Oh, I thought the last one was an alternative to the first two together.
06:21:22 <elliott> Which one is fastest?
06:21:45 <shachaf> The first two compile to fancy AVX instructions.
06:22:17 <shachaf> The third compiles to boring old subtraction.
06:23:05 <elliott> Well, the first is basically C code.
06:23:15 <elliott> The second is OOPy and therefore idiomatic, due to its method call.
06:23:40 <elliott> But the third is unidiomatic (no OOP) C-style code that has the overhead of classes and objects and stuff.
06:23:46 <elliott> Worst of both worlds.
06:23:51 * shachaf sighs.
06:23:57 <elliott> http://meta.stackoverflow.com/questions/125578/facebook-like-confirm
06:24:02 <shachaf> Would it make it better if I changed operator[] to a named method?
06:24:13 <elliott> Yes.
06:24:15 <elliott> It would go faster then.
06:25:03 <ais523> shachaf: needs more rvalue references
06:25:07 * ais523 has not looked at the code
06:25:50 <elliott> {(c?a:b) = 0} is valid C++ code, is it valid C?
06:26:02 <shachaf> elliott: It doesn't. :-(
06:26:05 <zzo38> I don't thin kso
06:26:27 <elliott> shachaf: Try using -O.
06:27:00 <shachaf> elliott: I'm using -O3. :-(
06:27:04 <shachaf> Maybe I should try -O4
06:27:31 <pikhq_> Won't help for single-file programs. :)
06:27:44 <elliott> shachaf: Yes.
06:27:47 <elliott> Or -O11.
06:28:15 <pikhq_> elliott: -O4 has meaning in recent GCC.
06:29:03 <shachaf> ais523: Would you look at the code if it was C?
06:29:44 <ais523> no
06:29:45 <elliott> *That's* how you pronounce Dijkstra?
06:30:00 <ais523> elliott: *(c?a:b) = 0 is valid C
06:30:10 <ais523> in C++, you don't need the * if a and b are lvalue references
06:30:14 <ais523> elliott: "deek-stra"
06:30:20 <elliott> ais523: are you sure?
06:30:25 <ais523> reasonably
06:30:26 <elliott> http://upload.wikimedia.org/wikipedia/commons/8/85/Dijkstra.ogg says "diik-stra"
06:30:33 <ais523> oh, that's the same thing
06:30:36 <ais523> maybe not
06:30:39 <elliott> deek is eeeeee
06:30:41 <ais523> perhaps that's right
06:30:42 <elliott> diik is iiiiiiii
06:30:53 <elliott> d-eek vs. die-k
06:31:09 <elliott> <ais523> in C++, you don't need the * if a and b are lvalue references
06:31:10 <elliott> I believe
06:31:16 <elliott> int a,b,c=0; (c?a:b) = 0;
06:31:16 <elliott> is valid
06:31:23 <elliott> (in C++)
06:31:33 <ais523> seriously?
06:31:37 <ais523> !help languages
06:31:38 <EgoBot> ​languages: Esoteric: 1l 2l adjust asm axo bch befunge befunge98 bf bf8 bf16 bf32 boolfuck cintercal clcintercal dimensifuck glass glypho haskell kipple lambda lazyk linguine malbolge pbrain perl qbf rail rhotor sadol sceql trigger udage01 underload unlambda whirl. Competitive: bfjoust fyb. Other: asm c cxx forth sh.
06:32:04 <ais523> !cxx int a,b,c=0; (c?a:b)=1; cout >> a >> endl;
06:32:11 <EgoBot> Does not compile.
06:32:19 <ais523> !cxx int a,b,c=0; (c?a:b)=1;
06:32:24 <ais523> EgoBot: 'twould be nice if you'd tell us /why/
06:32:25 <EgoBot> No output.
06:32:29 <ais523> hmm
06:32:33 <shachaf> !cxx int a,b,c=0; (c?a:b)=1; cout << a << endl;
06:32:38 <EgoBot> 32767
06:32:47 <ais523> hahahaha
06:32:50 <ais523> wtf?
06:32:58 <elliott> wat
06:33:07 <elliott> maybe it interpreted b as a pointer
06:33:08 <elliott> or something
06:33:20 <ais523> !cxx int a,b,c = 0; (c?a:b)=1; std::cout << a << std::endl;
06:33:25 <EgoBot> 32767
06:33:27 <elliott> oh, wait, I bet shachaf is up to his unicode tricks again
06:33:35 <ais523> but I retyped that
06:33:39 <elliott> hmm
06:33:42 <elliott> then, wtf?
06:33:46 <elliott> shachaf: ????
06:33:52 <ais523> !cxx int a,b,c = 0; std::cout << a << std::endl;
06:33:57 <EgoBot> 32767
06:33:58 <elliott> also, why was shachaf's valid but not ais523's?
06:33:59 <elliott> wait
06:34:00 <ais523> (retyped again just to make sure)
06:34:00 <elliott> ais523: you idiot
06:34:02 <elliott> <ais523> !cxx int a,b,c = 0; (c?a:b)=1; std::cout << a << std::endl;
06:34:03 <elliott> what is c?
06:34:11 <elliott> what is (c?a:b), symbolically?
06:34:22 <ais523> oh, a isn't initialized, and b is getting assigned to
06:34:23 <elliott> !cxx int a,b,c = 0; (c?a:b)=1; std::cout << b << std::endl;
06:34:28 <EgoBot> 1
06:34:31 <elliott> there
06:34:41 <elliott> Deewiant: we need ds9kc!
06:34:44 <ais523> so why is uninitialized memory consistently 32767, I wonder?
06:34:49 <elliott> ais523: UML, presumably
06:35:08 <elliott> ais523: it's effectively a clean-booted Linux system every command
06:35:17 <ais523> but why not 0?
06:35:31 <zzo38> I think in C you need *(c?&a:&b)=1; instead
06:36:07 <elliott> ais523: since when is unininitialised memory usually 0?
06:36:25 <ais523> it's more often 0 than anything else
06:36:27 <elliott> !cxx int8_t a,b,c = 0; (c?a:b)=1; std::cout << b << std::endl;
06:36:32 <EgoBot> ​.
06:36:34 <elliott> err
06:36:36 <ais523> or some sentinel value (32767 is not a good sentinel value)
06:36:42 <elliott> !c int a; printf("%d\n", a);
06:36:45 <elliott> erm
06:36:45 <EgoBot> 0
06:36:47 <elliott> !c char a; printf("%d\n", a);
06:36:49 <EgoBot> 0
06:36:52 <elliott> !c unsigned char a; printf("%d\n", a);
06:36:54 <EgoBot> 0
06:36:57 <elliott> ok, what's going on?
06:37:02 <elliott> !c unsigned char a,b; printf("%d %d\n", a,b);
06:37:05 <EgoBot> 0 0
06:37:15 <elliott> help
06:38:19 <elliott> by the way, how does everyone pronounce GIF?
06:38:23 <elliott> if you say jif, I'll stop talking to you
06:39:44 <zzo38> GIF.
06:39:48 <shachaf> zzo38++
06:40:00 <shachaf> elliott: I wrote a GIF parser once! If you pronounce it "jif" then it works very inefficiently.
06:40:29 <zzo38> zzo38+++---++-+++-----++-+----++++--+--+++--+---++++---+++-++---+++-----++--+++-++--+--+
06:40:38 <elliott> @karma zzo38
06:40:38 <lambdabot> zzo38 has a karma of 3
06:40:46 <elliott> @karma zzo38
06:40:46 <lambdabot> zzo38 has a karma of 3
06:40:47 <elliott> zzo38+++---++-+++-----++-+----++++--+--+++--+---++++---+++-++---+++-----++--+++-++--+--+
06:40:48 <elliott> @karma zzo38
06:40:48 <lambdabot> zzo38 has a karma of 3
06:40:51 <elliott> HMM.
06:40:59 <elliott> shachaf: You've told me!
06:41:22 <shachaf> If you pronounce it correctly it still works inefficiently.
06:42:24 <elliott> I wonder if ais523 is not saying "jif" so that I keep talking to him.
06:43:26 <elliott> "I want Stack Exchange to be part of the social web and ultimately the semantic web. I'm not satisfied with the archipelago of S.E. islands, each with their own priesthood of moderators who frown upon chit chat and buddy buddy."
06:58:12 -!- OPTer has joined.
06:58:43 <elliott> `welcome OPTer
06:58:47 <HackEgo> OPTer: Welcome to the international hub for esoteric programming language design and deployment! For more information, check out our wiki: http://esolangs.org/wiki/Main_Page
06:58:49 <shachaf> elliott: It compiles to the good instructions when returning a pointer instead of a reference. :-(
06:59:39 <elliott> shachaf: References are safe, thus slow.
07:00:01 <shachaf> Oh.
07:00:44 <shachaf> elliott: I guess the unsafest operators would be fastest, right?
07:01:02 <elliott> shachaf: Yes.
07:01:41 <elliott> ais523: Hey, should I sleep?
07:01:54 <shachaf> <ais523> yes
07:01:57 <ais523> at some point
07:02:04 <ais523> you don't seem as tired as last time you asked that
07:02:19 <elliott> sh;odiuld i sleeeeeeeeeep
07:02:20 <ais523> depends on when you want to wake up
07:02:21 <elliott> *slep
07:02:33 <elliott> Your e-mail have been awarded 1,000.000.00 GBP in our 2012 BT AWARD
07:02:33 <elliott> Inbox
07:02:33 <elliott> X
07:02:33 <elliott> fromSherry McKibben hsaasherryM11@shaw.ca
07:02:33 <elliott> to
07:02:33 <elliott> date14 March 2012 06:53
07:02:35 <elliott> subjectYour e-mail have been awarded 1,000.000.00 GBP in our 2012 BT AWARD
07:02:37 <elliott> mailed-byshaw.ca
07:02:39 <elliott> hide details 06:53 (9 minutes ago)
07:02:41 <elliott> Name.....Country......Phone.....
07:02:48 <elliott> my email have been awarded 1,000.000.00 GBP in our 2012 BT AWARD!!!!!
07:03:37 <elliott> shachaf: [[Haskell, being lazy, allows the usage of thunks (unevaluated expressions) which can build up ad infinitum without such mucky things as 'stack overflows' ugh.]]
07:03:45 <elliott> shachaf: You know when foldl builds up a billion thunks and you get a stack overflow?
07:03:48 <elliott> That never happens.
07:04:51 <shachaf> elliott: What about the time when it happened.
07:05:35 <elliott> That didn't happen.
07:06:01 <shachaf> ^dundundun
07:09:04 <elliott> ^def dundundun ul ([dramatic music])S
07:09:10 <elliott> fungot????
07:09:12 <elliott> fizzie!!!!
07:09:14 <elliott> fizzie: FI!!!J!IO!JO!IJZXIE
07:09:47 <shachaf> elliott: That's a long Wikipedia link you've got there.
07:10:06 <elliott> what
07:10:23 <shachaf> The one in the Wikipedia brackets.
07:11:02 <elliott> Oh.
07:11:06 <elliott> Those are MediaWiki brackets.
07:11:13 <elliott> Anyway, I've been quoting with [[...]] since before Wikipedia existed.
07:11:28 <elliott> Yes, I was quoting [[...]] when I was 5 years old, fuck you.
07:11:33 <elliott> (Untrue.)
07:11:52 <monqy> :0
07:12:11 <shachaf> You should quote as follows: «You should quote as follows: »
07:12:36 <elliott> monqy! It's that kid who's younger than me!
07:12:38 <elliott> HOW ARE YOU DOING
07:12:50 <elliott> Hey ais523, should I sleep?
07:13:00 <monqy> elliott: hi im fine
07:13:14 <ais523> elliott: can you not make your own mind up, this time?
07:13:24 <ais523> also, quotes are {{{ }}}, or you're insufficiently Agoran
07:13:34 <elliott> Agoran quotes are usually {{ }} these days!
07:13:40 <elliott> Anyway, those are both MediaWiki syntax too.
07:15:06 <shachaf> monqy is younger than you?
07:15:15 <shachaf> I'm pretty sure monqy is A BILLION YEARS OLD
07:15:30 <pikhq_> I'm pretty sure elliott is the universe.
07:15:49 <elliott> shachaf: Shut up, you're only 4.
07:15:50 <pikhq_> And the age he tells people is actually how long he's had Internet.
07:16:04 <elliott> The universe sure did get internet late.
07:16:22 <pikhq_> It's expensive wiring off-planet.
07:16:33 <pikhq_> Especially since you need superluminal cabling.
07:16:58 <elliott> If I'm the universe then where is @?
07:17:35 <shachaf> elliott: When the logs get edited, all references to @ ever not having existed will be erased.
07:17:53 <pikhq_> The present state of @ is the cosmic background radiation.
07:18:18 <pikhq_> That is to say, the big bang is actually a representation of your thought processes.
07:18:35 <elliott> I can't tell whether this makes @ awesome or really bad.
07:18:48 <zzo38> As far as I can tell it means neither.
07:18:56 <shachaf> zzo38 has a point.
07:19:12 <shachaf> elliott: Does it mean either one? It could mean neither. That would be a possibility.
07:20:27 <elliott> pikhq_: So how do I connect to the CMBR?
07:22:11 <pikhq_> Fetch the data from WMAP.
07:22:21 -!- cswords__ has quit (Read error: Connection reset by peer).
07:22:38 <elliott> That's static!
07:22:44 <elliott> @ is, like, fluid.
07:26:12 <pikhq_> Alternately, get a radio, untune it.
07:26:19 <pikhq_> Listen to the sounds of the creation of the universe.
07:27:09 <elliott> Man, @ sucks.
07:28:08 <elliott> Wow, Britannica costs $1,395?
07:28:34 <Madoka-Kaname> Superluminal cabling is stupid.
07:28:44 <Madoka-Kaname> Just put a few fiber optic cables through a wormhole
07:29:32 <shachaf> elliott: Can I have a wormhole?
07:31:20 <elliott> shachaf: Yes.
07:31:55 <shachaf> elliott: You should answer DanBurton's question.
07:33:34 <elliott> shachaf: Done.
07:35:00 * shachaf has influence.
07:37:02 <shachaf> elliott: I wantonly to understand!
07:38:30 -!- cheater has joined.
07:38:59 <elliott> ais523: Should I __ __ _____?
07:39:18 <ais523> elliott: you could ask zzo38 to take your horoscope again
07:39:33 <elliott> zzo38: Should I sleep?
07:39:51 <zzo38> elliott: Are you tired?
07:39:57 <ais523> you know that infinitely redirecting website? I got a reply back saying it was working yesterday
07:40:23 <zzo38> Ultimately it should be your own choice to sleep or to not sleep. However, you can make decisions using other methods if you prefer.
07:41:17 <elliott> zzo38: I'm looking for a more... astrologically inclined answer.
07:41:23 <elliott> ais523: problem solved, then
07:41:23 <shachaf> zzo38: What's the best method to use to make decisions?
07:41:38 <zzo38> elliott: OK. Tell me your latitude and longitude then.
07:42:09 <ais523> zzo38: I imagine they're the same as last time
07:42:19 -!- pikhq has joined.
07:42:20 <zzo38> I forget what they were last time
07:42:28 -!- pikhq_ has quit (Ping timeout: 252 seconds).
07:42:47 <elliott> let's see...
07:42:54 <elliott> Latitude:N54:58:22 Longitude: W2:06:41, apparently
07:43:52 <zzo38> OK, I put that into the computer. The answer is the same as last time: Wake up.
07:44:06 <elliott> Whoa.
07:44:26 <zzo38> (I know you are probably awake already)
07:45:11 <shachaf> elliott: Do you live in 45 Rye Terrace?
07:45:19 <elliott> Well, I was awake... but then I woke up.
07:45:25 <elliott> shachaf: No, I googled "hexham latitude longitude".
07:46:33 <elliott> ais523: USELESS TRIVIUM OF THE DAY: apparently, WMF developers aren't called developers any more
07:46:51 <ais523> heh
07:46:58 <zzo38> Perhaps you can put it in your own Astrolog next time.
07:47:06 <elliott> (they're "system administrators", which is (a) more accurate and (b) boring)
07:47:09 <elliott> zzo38: I doubt it runs on Linux.
07:47:37 <zzo38> elliott: It runs on DOS, Mac, Windows, and Unix. So probably it will run on Linux.
07:47:47 <shachaf> I put it in my own Astrolog.
07:47:55 <shachaf> It told me I should "give Astrolog money".
07:48:00 <elliott> "Wikimedia's present power structure is a mix of anarchic, despotic, democratic, republican, meritocratic, plutocratic, technocratic, and bureaucratic elements"
07:48:02 <zzo38> (The author's other program, Daedalus, appears to be Windows only, though)
07:48:25 <elliott> s/is a .*/is a mess/
07:48:50 <zzo38> shachaf: You put your coordinates in and it told you that? But as far as I know it is not for sale.
07:49:00 <shachaf> elliott: s/ix.*/ess/ # regex golf!
07:49:25 <elliott> "ix"?
07:49:27 <elliott> Oh.
07:49:56 <zzo38> O, now you have regex golf. I think some of the anarchy golf problems are similar to a regex golf in some cases.
07:55:11 -!- fungot has joined.
07:56:01 <elliott> fungot :') <3
07:56:01 <fungot> elliott: this is my explanation, but it's the v6 stack driver that throws that out.
07:56:09 <elliott> fizzie: You put fungot on IPv6 and it broke?
07:56:09 <fungot> elliott: fibonacci heaps, trinomial heaps, fat heaps, thin heaps, fat heaps, thin heaps, fat heaps, relaxed heaps, and maybe even specifically optimized by the implementation
07:56:10 <elliott> Monster.
07:56:16 <elliott> `addquote <fungot> elliott: fibonacci heaps, trinomial heaps, fat heaps, thin heaps, fat heaps, thin heaps, fat heaps, relaxed heaps, and maybe even specifically optimized by the implementation
07:56:16 <fungot> elliott: bloody flow analysis :) bye.
07:56:23 <HackEgo> 823) <fungot> elliott: fibonacci heaps, trinomial heaps, fat heaps, thin heaps, fat heaps, thin heaps, fat heaps, relaxed heaps, and maybe even specifically optimized by the implementation
07:56:41 <fizzie> Fat heaps, thin heaps, fat heaps, thin heaps, ...
07:57:42 <elliott> Relaxed heaps, and maybe even specifically optimised by the implementation.
07:59:54 <shachaf> Was that automatically generated?
08:00:00 <shachaf> fungot++
08:00:00 <fungot> shachaf: i checked it :) first i need to
08:00:10 <shachaf> fungot: FIRST YOU NEED TO WHAT
08:00:10 <fungot> shachaf: process 3 killed. i'm happy with double-precision arithmetic. however, these rules are then used to anticipate the events after n steps, i can assure you
08:00:48 <elliott> I think fungot is dying.
08:00:48 <fungot> elliott: perhaps it has something to do with it?" ;p
08:03:07 <shachaf> fungot? More like funbot!
08:03:08 <fungot> shachaf: it's also an identifying uri manipulation libs for just about every side, except on keenspot when it points to some proxy in switzerland which happens to be in
08:06:58 <zzo38> Did you try to put it in your own Astrolog? (Hint: You should enter your own timezone and location into the configuration file so that it selects that one by default. You can create other files with other info if you want to chart other info commonly.)
08:07:25 <shachaf> elliott: If you're the universe, does that make you mostly vacuum?
08:07:37 <elliott> Dark energy, man.
08:19:30 <ais523> augur: "sqort"
08:19:41 <ais523> your typo fix contains a typo of its own
08:19:51 <augur> ais523: :(
08:23:53 -!- OPTer has quit (Remote host closed the connection).
08:32:44 -!- pikhq_ has joined.
08:33:08 -!- pikhq has quit (Ping timeout: 264 seconds).
08:48:23 -!- elliott has quit (Read error: Connection reset by peer).
08:53:33 -!- elliott has joined.
08:54:00 <Sgeo> elliott, monqy tswett update (kallisti too if you read logs)
08:54:18 <monqy> hi
08:55:33 <zzo38> Do you have any opinions about the Eleven Satanic Rules of the Earth?
08:56:31 <elliott> yes
08:56:33 <elliott> they're all @
08:56:41 <shachaf> elliott: Why don't you join any channels by default?
08:57:09 <zzo38> How do you mean by that?
08:58:31 <Sgeo> http://www.daniweb.com/software-development/legacy-and-other-languages/threads/408985 this is the new language I am in love with.
08:58:47 <elliott> It's perfect.
09:00:11 <Sgeo> Number of people who have failed to resist the urge to say that it's perfect: 3.
09:00:54 <elliott> I am glad we are not the only ones you force to suffer.
09:01:34 <Sgeo> Actually, someone else linked it, although I repeated the link for someone who came in afterwards and saw some discussion.
09:02:00 <olsner> "first exapmle of perfect code" :D
09:02:35 <Sgeo> Imperfect comments do not count as code, I would assume.
09:02:37 <elliott> It's prefect.
09:04:13 <Sgeo> It's intended to be readable by both VB and C people! The redundant } and end statements ensure it!
09:13:05 -!- monqy has quit (Quit: hello).
09:14:27 <zzo38> Do you know Pascal's Wager? Do you know the opposite? The first time I saw the opposite in the book, was not named; but I saw it once called Rachel's Wager so I will call itat.
09:15:15 <shachaf> Named after Blaise Rachel, the famous mathematician?
09:17:12 <zzo38> No. It is someone with the OpenID URL http://rach.myopenid.com/
10:02:42 -!- pikhq_ has quit (Ping timeout: 246 seconds).
10:02:44 -!- pikhq has joined.
10:16:12 -!- ais523 has quit (Remote host closed the connection).
10:23:33 -!- oerjan has joined.
10:24:06 -!- zzo38 has quit (Remote host closed the connection).
10:24:25 <elliott> hi oerjan
10:24:44 <elliott> oerjan: http://esolangs.org/w/index.php?title=EsoInterpreters&curid=2229&diff=31113&oldid=31102 adds a column to EsoInterpreters with nothing but a BF interpreter.
10:25:01 <elliott> (the next revision fixes the link, but not the &nsbp;s in every other cell.)
10:25:04 <oerjan> hi elliott
10:25:12 <elliott> i decided to delegate this one to you :P
10:25:21 <oerjan> WAT
10:26:33 <shachaf> elliott: Why is g++'s optimizer stupid?
10:26:35 <elliott> truly, telling people about revisions is the most heinous crime against human rights
10:27:10 <shachaf> elliott: In particular, why is "if (data_[ix] < min) min = data_[ix];" much faster than "min = std::min(data_[ix], min);"?
10:27:29 <shachaf> You'd expect it to recognize a minimum operation which is, you know, the standard library's minimum operation.
10:27:47 <elliott> shachaf: It's C++ that is stupid.
10:27:48 <elliott> hth
10:28:01 <elliott> oerjan: P.S. If I made you an admin, it'd be delegation, not abuse.
10:28:02 <shachaf> oh
10:28:16 <oerjan> ah. i knew there would be a catch to this admin thing.
10:28:32 <shachaf> elliott: Because if I wrote in C, there would be no standard library function for min/max, right?
10:29:38 <elliott> shachaf: right!
10:35:12 <fizzie> shachaf: On the other hand, only with C++ you can just pull the whole thing from <algorithm> and avoid the loop, by writing *min_element(data_.begin(), data_.end()) instead.
10:35:18 <fizzie> (It's probably even slower.)
10:37:53 <shachaf> fizzie: It's about the same speed as a loop with std::min.
10:38:05 <fizzie> Sadness.
10:38:53 <elliott> It could have been even slower.
10:38:57 <elliott> But it foregoed the opportunity.
10:39:00 <elliott> forgoed a word
10:39:20 <fizzie> You just forged the foregoed word.
10:39:35 <oerjan> elliott: oh wait it was just a typo, not forgetting about making the rest of the column completely...
10:39:39 <oerjan> i guess i can do that
10:39:58 <elliott> oerjan: ern o
10:40:02 <elliott> oerjan: i did not want you to fix it
10:40:07 <elliott> i wanted you to remove the useless column :P
10:40:18 <elliott> if we put a column for every language with just a BF interpreter, it would be an exceedingly wide table.
10:41:04 <oerjan> oh bah
10:41:26 <fizzie> FWIW, int min1(int a, int b) { if (a < b) return a; return b; } and int min2(int a, int b) { return std::min(a, b); } generate exactly identical code; but of course "if (a[b] < min) min = a[b];" is not quite equivalent to "min = std::min(a[b], min)".
10:41:40 <elliott> oerjan: (you could just re-save the old revision, if you're thinking it'll be a long ordeal)
10:41:45 <elliott> (i just don't want to have to write the edit summary ;P)
10:42:11 <oerjan> elliott: what. i disagree with that policy.
10:42:36 <oerjan> i have already said that the table needs to split up soon anyway.
10:42:46 <elliott> erm, the whole point is to be a _cross-reference_, is it not?
10:42:52 <elliott> there's no crossing.
10:43:52 <oerjan> elliott: oh. the _actual_ problem is that the entry has swapped row/column.
10:44:11 <elliott> anyway
10:44:14 <elliott> more importantly
10:44:15 <elliott> // TODO: add support for [ and ]
10:44:17 <elliott> it's not a brainfuck interpreter
10:44:23 <oerjan> oh.
10:44:35 <oerjan> well in that case...
10:44:42 <elliott> :-D
10:45:36 <shachaf> fizzie: It looks vaguely like an inlining problem.
10:45:51 <shachaf> fizzie: Certainly I don't expect it to be able to vectorize it without inlining.
10:46:00 <elliott> shachaf: Write it in J instead.
10:46:31 <shachaf> fizzie: Code that looks very similar -- e.g. min = data_[ix] < min ? data_[ix] : min; -- also gets vectorized.
10:47:25 <shachaf> My other g++ optimizer vectorization complaint today also had to do with inlining -- something that only worked with pointers and not with references.
10:47:29 <elliott> shachaf: But I heard C lets you get close to the metal, and has really predictable performance.
10:47:32 <elliott> Unlike that Haskell thing.
10:47:46 <elliott> With Haskell you can have a bunch of seemingly-equivalent expressions with wildly different performanec characteristics!
10:47:47 <elliott> *performance
10:47:50 <elliott> That could never happen in C/C++.
10:48:17 <shachaf> I'll let kmc handle this one.
10:50:02 <shachaf> ...OK, this is kind of ridiculous.
10:50:48 <shachaf> inline const Pixel &mymin(const Pixel &a, const Pixel &b) { return a < b ? a : b; }
10:50:51 <shachaf> inline const Pixel mymin(const Pixel a, const Pixel b) { return a < b ? a : b; }
10:51:02 <shachaf> Pixel is signed short.
10:51:11 <shachaf> The second line gets optimized; the first one doesn't.
10:52:01 <elliott> why C++
10:53:24 <fizzie> The first one is kinda weird-looking, though. If I were an optimizer, I probably wouldn't bother either.
10:54:00 <shachaf> fizzie: But that's what std::min is...
11:00:40 <fizzie> It must have something to do with the con-text.
11:01:06 <elliott> shachaf: Why is that ridiculous
11:01:12 <elliott> it doesn't optimise std::min so it doesn't optimise the first mymin
11:02:01 <fizzie> http://sprunge.us/OcbC gives absolutely identical 'use1' and 'use2'. (cmp esi, edi; cmovle edi, esi; jmp _Z5applyi.)
11:02:25 <fizzie> But maybe it's much harder when you're talking about references to std::vectors or something.
11:02:47 <fizzie> To its elements, I mean.
11:02:56 <shachaf> fizzie: I'm talking about vectorization.
11:03:02 <shachaf> Try using it in a loop over an array.
11:04:55 <fizzie> Okay, http://sprunge.us/jPeB also gives identical code.
11:05:05 <fizzie> Whoops, that's the identical function too. :p
11:05:22 <fizzie> Yeah, it's kinda different.
11:06:03 <fizzie> Also forgot the ++s, but anyhow.
11:07:33 <shachaf> Well, the ++s are kind of important. :-)
11:08:24 <shachaf> But suddenly I'm not getting it to reproduce.
11:09:07 <shachaf> Oh, because your min function is over ints.
11:09:23 -!- ais523 has joined.
11:10:12 <shachaf> fizzie: http://sprunge.us/GidL
11:10:45 <elliott> shachaf: Can you write my functions for me?
11:11:11 <shachaf> elliott: I'm too busy writing fizzie's function for fizzie.
11:11:21 <shachaf> hi fizzie
11:12:56 <fizzie> I saw something similar with the ints; it seems to want to keep an up-to-date copy of min on stack for each iteration of the loop when you call the reference version.
11:13:42 <shachaf> fizzie: But it generates drastically different code for my version.
11:13:50 <shachaf> Especially if you compile with -O3 -march=native
11:13:57 <shachaf> elliott: Happy -march!
11:14:34 <fizzie> Well, yes, it doesn't vectorize. But how could it, if it "needs" to keep updating -1(%rsp) for each byte separately.
11:15:21 <shachaf> Right.
11:16:04 <shachaf> Is it something to do with aliasing? I'd understand a different behavior if the function wasn't inline, but you'd expect it to be able to figure this out.
11:16:21 <elliott> I FUCKING HATE C++
11:16:46 <elliott> That is all.
11:17:06 -!- Jafet has joined.
11:17:09 <oerjan> i sense some anger issues.
11:17:42 -!- azaq23 has quit (Remote host closed the connection).
11:19:53 <oerjan> *CHOO*
11:20:11 <oerjan> bloody dose
11:21:35 <fizzie> shachaf: I don't know, but I do get almost identical code for the obvious pointer translation, template <typename T> inline const T* min3(const T* a, const T* b) { if (*a < *b) return a; return b; } and a use case of min = *min3(&min, &arr[i]);.
11:22:24 <fizzie> It's inlined, but not vectored, and the loop is essentially the same. Except, uh, now I don't see any stack references in either of use2 or use3 any more.
11:22:33 -!- const has quit (Excess Flood).
11:23:32 <fizzie> (Oh, that last bit was just -march=native.)
11:23:48 <fizzie> Or not. Weird.
11:24:12 <kmc> "IMPORTANT: Any code that relies on wide character support is essentially non-portable and/or broken. the only reason this header exist is because I'm really a nice guy. However, I'm not nice enough to provide you with a real implementation. instead wchar_t == char and all wc functions are stubs to their "normal" equivalent..."
11:24:14 <kmc> says android wchar.h
11:24:16 <fizzie> Oh, okay; g++-4.5 doesn't have the slightly useless stack thing.
11:24:20 <oerjan> -august=bahamas
11:24:29 <elliott> kmc: looks correct to me :P
11:24:44 <ais523> kmc: is that a statement about in general? or just in Android?
11:26:16 <shachaf> fizzie: Well, it's also somewhat odd that it doesn't work with the pointer version.
11:26:31 <shachaf> fizzie: I have another bit of C++ code that gets vectorized with the pointer version but not with the reference version.
11:28:39 <kmc> ais523, it's true in general that you have few guarantees about wchar_t
11:29:25 <kmc> for example on Windows it's only 16 bits, so cannot represent all of Unicode
11:30:57 -!- derdon has joined.
11:33:13 <elliott> interesting factoid, IIRC plan 9 only does 16-bit
11:33:24 <elliott> due to never being updated when the astral planes started existing
11:33:28 <elliott> and it's the first utf-8 impl!
11:36:01 <RocketJSquirrel> <kmc> "IMPORTANT: Any code that relies on wide character support is essentially non-portable and/or broken. the only reason this header exist is because I'm really a nice guy. However, I'm not nice enough to provide you with a real implementation. instead wchar_t == char and all wc functions are stubs to their "normal" equivalent..." // this is the most legit statement on wchar anyone has ever made.
11:36:44 <kmc> you can check the macro __STDC_ISO_10646__ to see if wchar_t supports all of UCS / Unicode / ISO-IEC 10646 / NCC-1701
11:36:50 <kmc> for such important characters as http://www.fileformat.info/info/unicode/char/1f4a9/index.htm
11:36:56 <kmc> RocketJSquirrel, thank you for quoting it in full
11:37:06 <RocketJSquirrel> 'tis my nature X-D
11:37:20 <RocketJSquirrel> Also, GOAT is far more important than PILE OF POO
11:37:33 <elliott> #define wchar_t "NO. STOP."
11:37:39 <kmc> Walter: Am I wrong?
11:37:39 <kmc> The Dude: No you're not wrong.
11:37:39 <kmc> Walter: Am I wrong?
11:37:39 <kmc> The Dude: You're not wrong Walter. You're just an asshole.
11:37:46 <RocketJSquirrel> (Unicode GOAT resents your inability to render Unicode GOAT.)>🐐
11:37:51 <elliott> <kmc> RocketJSquirrel, thank you for quoting it in full
11:37:53 <kmc> https://plus.google.com/109925364564856140495/posts
11:37:53 <elliott> that's how we roll around here
11:38:01 -!- variable has joined.
11:39:12 <kmc> i tried to convince a friend to include a Supplementary Ideographic Elemental in his D&D campaign
11:41:39 <elliott> Hey kmc, I'm getting sick of #haskell!
11:42:57 <shachaf> Ugh.
11:43:10 <elliott> shachaf: Did I cause you to look at #haskell?
11:43:15 <shachaf> Now it turns out that knowing about this gcc optimizer thing would've solved my whole problem a while ago.
11:43:19 <elliott> Oh.
11:43:19 <shachaf> elliott: Not yet.
11:43:21 <elliott> Even WORSE.
11:43:34 <shachaf> I KNOW, RIGHT?
11:44:47 <elliott> shachaf: Allow me to summarise the current discussion for you: "gah, why don't length and (!!) use Integer?!" -> "well, if we were going to change them, it should be to Natural instead anyway" -> "changing (!!) to Natural is pointless, because you can still specify an index above the array's bounds!" -> "it still eliminates a class of errors!" -> "it is literally no more precise than Integer!" -> "what?" -> "it is literally no more precise than I
11:44:47 <elliott> nteger!"
11:44:57 -!- itidus21 has changed nick to BIOC_4_EVA.
11:45:36 <Jafet> Summary of summary: I won
11:45:39 <kmc> why don't length and (!!) use dependent types
11:45:41 <kmc> is the real question
11:45:54 <Jafet> Too many dependencies?
11:46:08 <kmc> too many dependents
11:46:11 <elliott> Jafet: Hey, get out! I'm busy talking about you behind your back.
11:46:16 <elliott> It's the rules.
11:46:25 <Jafet> elliott is just bitter because he didn't win.
11:48:29 <kmc> also the function be64toh is named betoh64 on android
11:49:18 -!- BIOC_4_EVA has changed nick to itidus21.
11:50:11 <kmc> if you ever wanted to program for a platform where the kernel is linux and the userland is half BSD and half crazysauce
11:50:16 <kmc> that platform exists today
11:51:28 <elliott> it can't be worse than desktop linux
11:53:06 -!- pikhq_ has joined.
11:53:10 -!- pikhq has quit (Ping timeout: 240 seconds).
11:55:40 <RocketJSquirrel> Come to think of it, Android is probably as close as current distros come to my purported goal of a NoGNU/Linux.
11:57:44 <kmc> why is that your goal
11:57:52 <elliott> RocketJSquirrel is a militant BSD user.
11:57:53 <RocketJSquirrel> It's a purported goal ;)
11:58:00 <elliott> he doesn't use any gpl software
11:58:06 <kmc> great
11:58:08 <kmc> crazy people itt
11:58:30 <RocketJSquirrel> Watch me pull this license out of my hat!
11:58:50 <RocketJSquirrel> That's apparently the only line I can quote from Rocky and Bullwinkle, and I'm not even the right character.
11:58:57 <itidus21> i am under the delightfully trollish impression that linux and gnu are effectively c and or c++ apps and systems
11:59:32 <RocketJSquirrel> kmc: Anywho, I just want to see a full Linux system with nothing (C) FSF.
11:59:43 <oerjan> <elliott> ais523: well, it's like linear logic, sort of
11:59:49 <RocketJSquirrel> (Except that I'm sure tidbits of the kernel itself have flowed from FSF, but, uh, whoops)
11:59:58 <oerjan> i'd think it's precisely that...
12:00:10 <elliott> oerjan: i try and formulate it in terms of linear logic later.
12:00:14 <elliott> oerjan: without knowing any linear logic.
12:00:16 <oerjan> ok
12:00:20 <elliott> do you know any linear logic? perhaps you can correct me :P
12:00:35 <oerjan> i've read the definition...
12:00:42 <elliott> EXCELLENT
12:00:45 <kmc> the wchar_t quote isn't wrong, it just has the kind of tone that makes me hate programmers
12:01:07 <elliott> I don't think kmc likes anybody.
12:01:12 <itidus21> i think the gnu approach would be to gradually rewrite each module of gnu in haskell until the whole thing is haskell
12:01:48 <RocketJSquirrel> itidus21: Then, in forty years, when you have better languages and Haskell is a dinosaur, at long last you'll have a pure Haskell system 8-D
12:02:07 <Jafet> Haskell wouldn't work; there is an "FFI loophole"
12:02:51 <oerjan> Jafet: that loophole will be closed when the foreign side has been converted to haskell
12:03:04 -!- nortti has joined.
12:04:49 <kmc> the greatest possible achievement of mankind is to rewrite all existing software in haskell
12:04:49 <oerjan> elliott: i think you basically want (P ⊗ ~Q) & (~P ⊗ Q)
12:05:14 <kmc> this amazing new technology is too powerful to be used for new projects and problems
12:05:20 <nortti> Does ⊗ mean XOR?
12:05:25 <elliott> oerjan: so & lets you pick one but not both?
12:05:29 <oerjan> yep
12:05:40 -!- ais523 has quit (Ping timeout: 240 seconds).
12:05:45 <elliott> oerjan: ok then
12:05:48 <elliott> shachaf: you have your answer!
12:06:17 -!- nortti has left.
12:06:28 -!- nortti has joined.
12:06:49 <elliott> RocketJSquirrel: I'm glad you're confident we'll have better languages than Haskell in 40 years.
12:06:54 <elliott> Maybe I can be uncynical enough to join you!
12:07:00 <elliott> I guess @ will exist in 40 years.
12:07:17 <elliott> oerjan: linear logic is cool. I should learn it.
12:07:24 <shachaf> elliott: As much as it ever will!
12:08:49 -!- MSleep has changed nick to MDude.
12:09:34 <elliott> Good grief, I hate thinking.
12:10:02 <oerjan> nortti: ⊗ means that you can use both sides, simultaneously, while & means you can only use one of them, but you get to choose. and there's another operator which gives you one of them, but you _don't_ get to choose, which is sort of like an or. and also another which looks like an upside down & and is dual to ⊗ and which is hard to explain exactly _what_ it gives you.
12:10:39 <oerjan> at least that's my impression of this.
12:10:46 <itidus21> for me, thinking is the hardest thing on earth
12:11:42 <elliott> you can use neither side, simultaneously
12:12:22 <elliott> whoa the linear logic guy is still alive
12:12:23 <oerjan> elliott: i think it makes sense as a kind of lambda thing where you get a ⊗ as argument.
12:12:31 <elliott> i didn't realise it was so modern
12:12:37 <oerjan> a continuation.
12:12:49 <elliott> 1987?!?!?!?!?!?!
12:12:50 <oerjan> (with curry-howard thinking.)
12:12:52 <elliott> wtf
12:13:29 <oerjan> elliott: it takes a kind of leap to invent a logic which isn't really about _truth_...
12:14:03 <elliott> oerjan: well, yeah... the basic idea just seems obvious in retrospect
12:14:52 <itidus21> I am nearly done analyzing the problem. 1)Determine what I want to think about. 2)Visualize myself thinking about it. 3)Using rhonda byrne's The Secret flip through books as if I was really thinking. 4)??? 5)Profit.
12:14:56 <oerjan> oh and that upside down & is _part_ of the definition of implication, like a -> b = ~a or b in classical logic.
12:15:01 <shachaf> I can tell when my program stops running because my computer's fan turns down.
12:15:08 <shachaf> It's pretty instant feedback.
12:15:13 <elliott> hm so I guess this means it might have been explicitly influenced by resource problems in computing
12:15:20 <elliott> rather than just turning out to be useful for that
12:16:28 <oerjan> oh and there are the unary operators ! meaning "as many times as you want" and its dual ? meaning heck if i know
12:17:17 <elliott> one more than you hoped for
12:17:27 <elliott> *less
12:19:52 -!- Jafet has quit (Quit: Leaving.).
12:20:45 <oerjan> and four constants, 0, 1, top and bottom, one identity for each of the basic binary operations
12:23:07 -!- augur has quit (Remote host closed the connection).
12:25:08 <itidus21> i think natural language is ill-equipped for complex logic
12:25:51 <elliott> We just need two more, then we can call them up, down, strange, charm, top, and bottom.
12:26:22 -!- derdon_ has joined.
12:27:13 <oerjan> elliott: ooh maybe that's the secret to the toe!
12:27:42 <oerjan> *t.o.e.
12:27:53 <elliott> i was confused for a second there.
12:29:32 -!- derdon has quit (Ping timeout: 260 seconds).
12:34:50 <oerjan> oh dammit not nausea as well
12:35:35 <elliott> i diagnose oerjan with ill
12:35:38 <elliott> rip
12:35:53 <itidus21> if your nausea isn't caused by disease i find it helps to vomit
12:36:00 <itidus21> ^iff
12:36:32 <oerjan> itidus21: the reason i don't like nausea is because i really, really, really, really, really, really, really, really, really hate vomiting.
12:36:53 <elliott> vomiting is great fun! ok it's not
12:36:54 <oerjan> also it's definitely disease.
12:37:07 <itidus21> i actually enjoy ripping my stomach lining into carrot pieces and depositing them on the ground
12:37:34 <elliott> hi oerjan
12:37:46 <oerjan> hi elliott
12:39:40 -!- derdon_ has quit (Remote host closed the connection).
13:20:21 -!- augur has joined.
13:24:10 <MDude> I've been told that today is Pi Day.
13:24:20 <MDude> Should I celebrate by acting irrationaly?
13:25:30 <elliott> MDude: Celebrate by destroying America
13:25:35 <elliott> 's disgusting date ordering system.
13:26:06 <oerjan> elliott: but the other systems don't even _have_ a pi day!
13:26:14 <oerjan> which clearly must be inferior.
13:26:39 <elliott> Hey, some of us have 14 months.
13:27:16 <oerjan> i mean earth systems.
13:28:27 <shachaf> 2012-0 3-14
13:31:15 <quintopia> pi day in day-first systems is apr 31
13:31:16 <oerjan> > 360%(180-36)
13:31:17 <lambdabot> 5 % 2
13:31:57 <oerjan> quintopia: ...
13:32:38 <oerjan> you may wish to rethink that.
13:33:47 <quintopia> oerjan: i just made may shorter so that i could have one
13:34:10 <oerjan> O KAY
13:34:35 <elliott> its feb 3 obviously
13:34:58 <elliott> 14 mod 12 = 2
13:35:10 <elliott> except you celebrate the previous year's
13:35:16 <quintopia> actually, i've heard that its 22 july (pi approximation day)
13:35:16 <elliott> so feb 3 2012 was pi day 2011
13:35:30 <quintopia> its actually a better approximation than 3.14 so its BETTER
13:36:03 <elliott> 3.1fuck
13:37:58 <elliott> i turned into magnetism
13:42:40 -!- variable has quit (Excess Flood).
13:59:31 -!- variable has joined.
14:21:59 -!- nys has joined.
14:22:01 -!- nortti has quit (Quit: ChatZilla [Firefox 11.0/20120310102926]).
14:26:38 -!- nys has quit (Ping timeout: 252 seconds).
14:27:27 <shachaf> elliott: QUIET
14:28:04 <elliott> quiet
14:39:09 <oerjan> ___ _ _ ___ _____ _____
14:39:09 <oerjan> / _ \| | | |_ _| ____|_ _|
14:39:09 <oerjan> | | | | | | || || _| | |
14:39:09 <oerjan> | |_| | |_| || || |___ | |
14:39:09 <oerjan> \__\_\\___/|___|_____| |_|
14:42:34 <elliott> oerjan how did the four colour theorem take so long to get proved :(
14:43:27 <oerjan> because it so far requires a massive checking of cases that only a computer can do. hth.
14:43:50 <shachaf> They kept trying to prove the "for color theorem".
14:44:03 <shachaf> Silly Americans.
14:44:10 <RocketJSquirrel> They were too busy trying to prove that P!=NP.
14:45:00 <elliott> oerjan: but WHY it's so OBVIOUS ;_;
14:45:20 <elliott> also, it's only a few hundred, isn't it
14:45:35 <oerjan> i'd assume you'd need to look at the different cases to see why it's not obvious.
14:46:06 <oerjan> elliott: iirc _each_ of those few hundred configurations requires a massive computer check.
14:46:19 <elliott> "Their proof reduced the infinitude of possible maps to 1,936 reducible configurations (later reduced to 1,476)"
14:46:40 <elliott> "Since the proving of the theorem, efficient algorithms have been found for 4-coloring maps requiring only O(n2) time, where n is the number of vertices. In 1996, Neil Robertson, Daniel P. Sanders, Paul Seymour, and Robin Thomas created a quadratic time algorithm, improving on a quartic algorithm based on Appel and Haken’s proof (Thomas 1995; Robertson et al. 1996). This new proof is similar to Appel and Haken's but more efficient because it re
14:46:40 <elliott> duced the complexity of the problem and required checking only 633 reducible configurations. Both the unavoidability and reducibility parts of this new proof must be executed by computer and are impractical to check by hand (Thomas 1998, pp. 852–853). In 2001 the same authors announced an alternative proof, by proving the snark theorem (Thomas; Pegg et al. 2002)."
14:46:41 <elliott> ok fine :P
14:46:53 <elliott> how hard can colouring a few thousand graphs be?!
14:47:10 <oerjan> elliott: the configurations are not graphs per se
14:47:33 <elliott> ah
14:47:36 <oerjan> they are graphs with _arbitrary_ colors _preset_ on a boundary
14:47:46 <oerjan> iirc
14:47:49 <elliott> ok, so it's basically just sudoku.
14:47:54 <oerjan> or something like that
14:47:57 <elliott> (hope that was as condescending as possible)
14:48:08 <oerjan> elliott: um it's like having to solve _all_ sudokus.
14:48:42 <oerjan> by "arbitrary" i mean that you have check _all_ possible assignments.
14:49:34 <elliott> oerjan: i was kidding
14:49:36 <elliott> but yes, i see now
14:49:47 <oerjan> this is all from my very vague recall of an overview of the proog, though.
14:49:49 <oerjan> *f
14:49:51 <elliott> still, i am pretty sure i could solve all sudokus if you gave me a few years.
14:50:00 <elliott> it is just numbers!
14:50:01 <oerjan> MAYBE
14:50:15 <elliott> "The following discussion is a summary based on the introduction to Appel and Haken's book Every Planar Map is Four Colorable (Appel & Haken 1989)."
14:50:20 <elliott> the most entertaining book
14:50:34 <elliott> "And now for 2,000 pages of computer printouts!"
14:53:02 <oerjan> it is possible it was that introduction i looked at.
14:54:01 <elliott> oerjan: looks more like a book-sized proof than an introduction going by this article
14:55:52 <MDude> I would tihnk the four color theorem could be somehow made linked to the three utilities problem.
14:57:26 <MDude> Though I guess that might only prove that the minimum is at least four.
15:00:07 <elliott> norway is small
15:00:41 <oerjan> wat
15:00:42 -!- Phantom_Hoover has joined.
15:01:10 <elliott> norway is small
15:01:19 -!- elliott has set topic: norway is small | http://codu.org/logs/_esoteric/.
15:04:18 <oerjan> if you mean by area, that's absurd. if you mean by population, http://www.ssb.no/vis/english/subjects/02/01/10/folkemengde_en/arkiv/art-2012-02-23-01-en.html
15:05:34 <elliott> http://www.ssb.no/english/subjects/02/01/10/folkemengde_en/arkiv/thumb-2012-02-23-01-en.png <-- very small image. very small country
15:05:45 <oerjan> (if you include ocean area, norway is _ridiculously large.)
15:05:53 <elliott> the defendant rests. (hes tired.)
15:05:54 <oerjan> *+_
15:05:59 <elliott> (excuse him.)
15:06:47 <oerjan> ah right, the insanity by sleep deprivation defense.
15:07:23 <elliott> it sounds like you have some issues w/r/t/ the size of norway. i am sorey.
15:07:27 <oerjan> (by ridiculous, i mean the second larges european country after russia.)
15:07:29 <oerjan> *+t
15:07:40 <MDude> There's the fact that K5 is a minimal nonplanar graph, which means that you can't have five areas that all touch each other on a plane.
15:07:42 <elliott> what about france : /
15:07:55 <elliott> "sorry sicnecence" -norway. (probably hates LHC.)
15:07:57 <oerjan> elliott: "if you include ocean area"
15:08:11 <oerjan> i guess france has some outside europe.
15:08:25 <elliott> Key domestic issues include immigration and integration of ethnic minorities, maintaining the country's extensive social safety net with an aging population, and preserving economic competitiveness.[2][9], and being smal.
15:08:58 <oerjan> obviously that's a mistranslation from no:smal = en:narrow.
15:09:03 <elliott> http://upload.wikimedia.org/wikipedia/commons/e/eb/Corded_Ware_culture.png this map i can see but norway i canot
15:09:11 <elliott> maybe it is hiding. or perhaps it is smal.
15:09:12 <oerjan> we will freely admit to being narrow, in the middle.
15:10:04 <elliott> http://upload.wikimedia.org/wikipedia/commons/f/fd/Satellite_image_of_Norway_in_February_2003.jpg <-- picture of sweden
15:10:43 <elliott> oh wow how much do you pay the people who pick the pictures for your wikipedia articles this is pretty
15:11:04 <oerjan> MDude: five colors being enough has been known for more than a century.
15:13:15 <elliott> http://upload.wikimedia.org/wikipedia/commons/1/18/StatfjordA%28Jarvin1982%29.jpg <-- COMOMPENSATING FOR SOMETHING NORWAY,,,?
15:13:40 -!- Deewiant has quit (Read error: Connection reset by peer).
15:13:54 -!- Deewiant has joined.
15:14:18 <elliott> Norway's population numbers roughly 4.9 million.
15:14:19 <elliott> oerjan: smal.
15:14:35 <elliott> whoah trondheim is big
15:14:50 <oerjan> elliott: SOON. you didn't read that first link did you.
15:14:58 <itidus21> a troll-physics alternative to the four colour theorem is to just draw the edges on maps
15:15:09 <oerjan> admittedly it was a bit hidden in the first blockquote.
15:15:32 <elliott> "Statistics Norway has calculated that Norway will reach a population of 5 millions on Monday, March 19. Population in Norway reached the first million in 1822, the second in 1890, the third in 1942 and the fourth in 1975."
15:15:35 <itidus21> because when you have drawn the edges, it doesn't matter so much that 2 adjacent regions are the same colour
15:16:01 <itidus21> this fact enables line art to exist
15:16:02 <elliott> "The Greater London Urban Area is the second-largest in the EU with a population of 8,278,251,[24] while London's metropolitan area is the largest in the EU with an estimated total population of between 12 million[25] and 14 million.[26]"
15:16:09 <oerjan> soon the world will learn to fear the norwegian population singularity.
15:16:14 <elliott> Quod. Erat. Demonstratnoiarniotdmuj
15:16:24 <oerjan> elliott: ah but is london's population _increasing_?
15:16:36 <elliott> oerjan: ask the Conservatives
15:16:44 <elliott> ^ scathing political satire
15:17:00 <elliott> (the joke is that we should kill all the Conservatives and also everyone else)
15:17:10 <itidus21> i imagine it would be exceedingly useful when you can't draw "edges"
15:17:15 <oerjan> ah. subtle british humor.
15:17:18 <elliott> Phantom_Hoover: pls rate my attempt at diplomacy
15:17:26 <elliott> & neutrality & fairness
15:17:35 <Phantom_Hoover> I don't get it
15:17:36 <lambdabot> Phantom_Hoover: You have 2 new messages. '/msg lambdabot @messages' to read them.
15:18:59 <elliott> http://upload.wikimedia.org/wikipedia/commons/c/c7/London_Underground_full_map_complete.svg
15:19:01 <elliott> bigger than norway
15:20:54 <elliott> oerjan: uk population facte. the london underground is actually the 147th largest city in th eworld , thanks to its 24/ 7 population .
15:20:54 <oerjan> chesham, amersham, chalfont & latimer.
15:21:10 <elliott> (norway is the 156th.)
15:21:17 <itidus21> something that could happen that hasnt happened is political territories having official textures for their representation on maps
15:21:23 <oerjan> big indeed, when my browser doesn't resize it. or even provide scrollbars.
15:21:41 <itidus21> i think that would make maps even easier to read if you could associate a country or state with a texture pattern
15:21:55 <elliott> too big to be resized.
15:21:57 <elliott> (ctrl - helps)
15:22:46 <oerjan> by helps you mean "has no effect", i assume.
15:23:13 <oerjan> btw i recall having to download an svg viewer separately in order to view mezzacotta.
15:25:14 <elliott> well it works in chrome.
15:25:15 <elliott> and probably firefo.
15:25:16 <elliott> x.
15:25:18 <elliott> and probably everything but IE.
15:25:32 <elliott> you'll download an /svg viewer/ but not a better browser?
15:25:37 <oerjan> i also note that removing the .svg at the end does not lead me to the full page which you should have linked in the first place.
15:26:04 <oerjan> elliott: i hear firefox is a memory hog, which means it will probably utterly kill my laptop.
15:26:15 <elliott> http://en.wikipedia.org/wiki/File:London_Underground_full_map_complete.svg hth hand
15:26:29 <elliott> oerjan: that's a rather outdated impression
15:26:47 <elliott> certainly firefox/chrome aren't going to use significantly more memory than IE at all (and perfectly likely less).
15:27:10 <elliott> (opera probably uses a tiny fraction, at the expense of sucking.)
15:28:43 <itidus21> starts having ideas but resists as best as i can to say more
15:29:15 <itidus21> the first degree of disclosure as it were, to merely indicate the existence of something that could be disclosed
15:46:53 <MDude> No, I think that K5 being nonplanor would prove that four is the maximum needed.
15:47:12 <MDude> Since for five colors to be needed, you would need five areas that all touch.
15:48:25 <MDude> And if you had five non-overlapping areas that all touch, you could node and each edge as a connection between nodes, and have five points with non-crossing connections.
15:48:52 <MDude> *could replace with a node and eash each with a connection between nodes
15:49:04 <MDude> *could rrpalce each area with a node
15:54:35 <elliott> I rrpalce areas with nodes all the time.
15:58:00 -!- augur has quit (Remote host closed the connection).
15:58:28 <oerjan> MDude: um you are wrong, plain and simple. K5 being nonplanar is trivial in comparison.
15:58:31 -!- coppro has quit (Ping timeout: 245 seconds).
15:59:07 -!- coppro has joined.
15:59:24 <MDude> I'm pretty sure nodes are used in place of areas in topology exactly because shape dones't matter.
15:59:52 <oerjan> i'm talking about <MDude> No, I think that K5 being nonplanor would prove that four is the maximum needed.
16:00:12 <MDude> Yeah, so amI.
16:01:26 <MDude> That and the fact that if you have two areas that are connected by an edge, you can put points in the areas and draw connections that go through the edges.
16:01:39 <elliott> i think if it came down to only one graph being planar or not, the four colour theorem would have been proved a lot earlier.
16:02:07 <coppro> hmm
16:02:14 <coppro> Agora needs "any linear combination of persons is a person"
16:02:57 <elliott> coppro: Are you mister snuggles?
16:03:23 <itidus21> what interests me in all this is how nintendo chips offered up 4 colours per tile region
16:04:41 <itidus21> because yeah.. thats what i'm like.. moving along
16:06:22 <coppro> elliott: no
16:07:09 <elliott> coppro: A SUSPICIOUSLY SLOW response.
16:10:47 * oerjan conjectures that half of coppro is 1/3 of mr. snuggles.
16:13:48 -!- MDude has quit (Ping timeout: 244 seconds).
16:16:12 <elliott> oerjan: wait, are _you_ mister snuggles?
16:16:24 <elliott> ok, i dare you to email one of the lists saying you're mister snuggles.
16:16:31 -!- coppro has set topic: this channel is mister snuggles | http://codu.org/logs/_esoteric/.
16:17:43 <oerjan> elliott: i don't know, they haven't told me
16:18:37 <elliott> oerjan: you're already subscribed to the backup lists, right? i'll, uhhh
16:18:40 <elliott> give up sarcasm for a whole month
16:18:58 <elliott> and be unfailingly nice and patient
16:19:00 <elliott> to EVERYBODY
16:19:24 <oerjan> i'm subscribed to at least some of the backup lists, yes
16:19:42 <elliott> there's just tue and yoyo
16:19:53 <oerjan> right
16:20:39 <elliott> "I am mister snuggles" is the small price for my kindness :P
16:20:49 <oerjan> but that might be lying!
16:21:18 <oerjan> and besides, such a strict regime would probably kill you.
16:21:30 <elliott> i can assure you, there is no way anyone could possibly prove a statement like that true or false before everyone gets sick of it all.
16:21:43 <elliott> also, you're not a player, so there's nothing they can do other than not let you play :P
16:22:37 <RocketJSquirrel> http://championofbirds.com/?p=4991 BEHOLD
16:22:38 * oerjan notes that elliott seems to consider "no one can prove it" to have anything to do with whether to lie or not.
16:23:02 <elliott> oerjan: i call it "nomic"
16:23:15 <elliott> anyway, it's not lying. mister snuggles does not claim to not be any player of agora
16:23:18 <fizzie> @tell MDude You don't need to have "n areas that all touch" to need n colors. There are (admittedly nonplanar) triangle-free graphs of arbitrarily high chromatic number, and the planar W_5 (the 5+1-node wheel; a 5-cycle with a hub) doesn't contain K_4 but needs all four colors.
16:23:18 <lambdabot> Consider it noted.
16:23:23 <oerjan> as a staunch platonist back in my agora days...
16:23:25 <elliott> nor any non-player!
16:23:45 <elliott> oerjan: pfft, it's all about neo-pragtonism these days
16:24:12 <elliott> oerjan: ok i would also settle for "I am not mister snuggles.", which has the added benefit of being factually correct.
16:24:32 <oerjan> but that might be lying!
16:24:41 * oerjan runs away
16:24:55 <elliott> unless you have sent any emails from mr.snuglz@gmail.com in the past few months, it is not :P
16:25:09 <oerjan> fancy.
16:25:26 <elliott> hey were you around for the mousetrap?
16:25:36 <oerjan> the name rings a bell.
16:25:40 <elliott> RocketJSquirrel: "A genius? A madman? A warlock? An emperor? A child? A hero?"
16:25:51 <elliott> RocketJSquirrel: I think "child".
16:26:16 <itidus21> wow the interview
16:26:22 <itidus21> on wednesday
16:26:35 <elliott> RocketJSquirrel: I note that one (1) person has tweeted that thing alreaddy.
16:26:37 <elliott> *d
16:26:42 <RocketJSquirrel> elliott: They tweet their own stuff.
16:26:48 <itidus21> thing happened
16:26:49 <elliott> THAT'S STILL A PERSON
16:26:59 <RocketJSquirrel> lol
16:27:00 <elliott> oerjan: the mousetrap was that contract that bound people into it without agreeing to it.
16:27:03 <Phantom_Hoover> <oerjan> as a staunch platonist back in my agora days...
16:27:13 <Phantom_Hoover> How does Agoran Platonism work?
16:27:40 <elliott> It's not Agoran.
16:27:43 <elliott> It's nomic platonism.
16:27:58 <elliott> tl;dr there is One True Gamestate in the sky, determined solely by application of the rules.
16:28:19 <elliott> The players must adhere to that gamestate or else be accused of playing Calvinball.
16:28:27 <elliott> Wait, why don't I just link you to the thesis.
16:28:54 <elliott> oerjan: fall 1995 was mousetrap it seems
16:28:58 <elliott> Phantom_Hoover: ftp://ftp.cse.unsw.edu.au/pub/users/malcolmr/nomic/articles/agora-theses/lib-vanyel.html
16:29:23 <elliott> wait, wtf.
16:29:33 <elliott> that article reverses the definitions of platonism and pragmatism i am used to.
16:29:42 <elliott> "The most common source of debate seems to lie in the dichotomy between Platonist and Pragmatist interpretations. In the former case it may be assumed that if a Rule says an event shall occur, and doesn't, play can continue *as if* the event had happened as specified. In the Pragmatist view, however, any event which occurs late or not at all, or not as specified in the Rules, can not be retroactively "fixed"--one may only take the game state as i
16:29:42 <elliott> t is at the time, and try to work with what is there."
16:29:48 <elliott> oerjan: that's not the right definition of pragmatism at all, is it?
16:30:05 <elliott> hmm, ah
16:30:11 <elliott> it's the same thing, through a different lens
16:30:26 <oerjan> oh. i guess i was there then. i don't precisely remember more than the name.
16:31:08 <elliott> there is ftp://ftp.cse.unsw.edu.au/pub/users/malcolmr/nomic/articles/agora-theses/lib-swann.html if you require details :P
16:31:37 <elliott> oerjan: red alert.
16:31:42 <elliott> mathnerd is in #haskell.
16:31:55 <oerjan> ...whatever
16:32:11 <elliott> you're meant to ban everyone.
16:32:16 <oerjan> oh.
16:32:27 <elliott> Phantom_Hoover: BTW, read those two theses, Agoran lore is great.
16:32:41 <elliott> oerjan: oh, I'm sure I've asked this before, but I must while we're on the subject -- what do you know of U.N.D.E.A.D.?
16:32:47 <oerjan> well it _is_ pi day, he should be allowed to roam then. ancient custom.
16:32:57 <oerjan> rings a bell, nothing more.
16:33:05 <elliott> that's what everyone says. or maybe just you
16:39:57 <elliott> "Feelings were compounded by an even worse example of timing: A new Player registered in the middle of the post-revelation controversy, and attempted a similar scam before the Mousetrap Compact was itself revealed. E was assured that the Mousetrap forbade this, and the new Player began angrily accusing the members of the Threat of lying about the Mousetrap's priority, e submitted es own CFJs, and eventually deregistered in disgust."
16:39:59 <elliott> this is the bestest bit
16:45:46 -!- kallisti has joined.
16:45:48 <kallisti> fungot: hi
16:45:48 <fungot> kallisti: clearly yome hasn't been made yet. x_x my brother keeps on impersonating my on irc. none of the code
16:45:52 <kallisti> fungot: sup
16:45:52 <fungot> kallisti: some people have the problem. if nothing else. :p no idea how
16:45:55 <kallisti> fungot: yep
16:45:55 <fungot> kallisti: so i shouldn't expect that debian is any different from running lisp on the 370/ 158 stored its global environment in the world of warcraft
16:46:21 -!- kallisti has left.
16:47:05 <itidus21> fungot
16:47:05 <fungot> itidus21: i don't really care either way now.
16:47:14 <itidus21> feh
16:47:34 <itidus21> ^_^
16:48:45 -!- RocketJSquirrel has set topic: This is likely the most important thing you will read all day: http://championofbirds.com/?p=4991 | http://codu.org/logs/_esoteric/.
16:49:12 <elliott> That was a peacefully short visit.
16:53:39 * oerjan somehow read that as necromantic style
16:54:04 -!- myname has joined.
16:54:13 <oerjan> `welcome myname
16:54:14 <myname> hello
16:54:16 <HackEgo> myname: Welcome to the international hub for esoteric programming language design and deployment! For more information, check out our wiki: http://esolangs.org/wiki/Main_Page
16:54:40 <elliott> that's not myname, that's yourname
16:54:56 <myname> just had an idea for a language and thought i ask for opinions here
16:55:06 <myname>
16:55:47 <elliott> oh, oerjan loves reviewing new languages
16:57:48 * oerjan swats elliott -----###
16:59:41 <Phantom_Hoover> So I actually finished my school chemistry experiment today, I never thought I had it in me.
17:01:56 <Phantom_Hoover> elliott, do <math> tags work these days?
17:02:08 <elliott> No; do you want them?
17:02:25 <Phantom_Hoover> They'd be pretty useful on a theory-oriented programming wiki.
17:02:38 <elliott> I don't think that's what we have.
17:02:48 <oerjan> myname: i declare your language probably turing complete, assuming variables are unbounded.
17:03:03 <oerjan> (that _is_ my expertise, right?)
17:03:04 * Phantom_Hoover gives up on fixing [[Graph]].
17:03:12 <elliott> Phantom_Hoover: Hey, I was going to do that.
17:03:15 <elliott> I will now do that.
17:03:17 <elliott> oerjan: Fix [[graph]].
17:03:31 <myname> i think it is, too, but i'm not sure
17:03:47 <oerjan> elliott: no.
17:03:56 <elliott> oerjan: Or else I'll sysop you!
17:04:22 <elliott> Yes. Your BIGGEST FEAR.
17:04:53 <oerjan> but it's my biggest fear _because_ of the stuff you're telling me to do in order to avoid it.
17:05:02 <oerjan> (also, it's not my biggest fear.)
17:05:17 <elliott> oh.
17:05:26 <elliott> ok, i'll sysop you iff you fix [[graph]].
17:06:00 <oerjan> watattacatgacattaccaga
17:06:11 * Phantom_Hoover starts fixing [[graph]].
17:06:43 <elliott> I bet Phantom_Hoover will fix it wrong and I'll have to re-fix it.
17:06:57 <Phantom_Hoover> WELL FINE IF YOU DON'T WANT MY FIXING
17:07:59 <elliott> http://stackoverflow.com/questions/9706589/why-is-the-tail-call-optimization-not-used-in-this-haskell-program Do I have the energy... do I have the energy...
17:08:08 <elliott> Phantom_Hoover: attn. <tromp__> Happy Half-Tau Day!
17:09:05 <oerjan> is that john tromp
17:09:37 <oerjan> assuming it's the same guy, he made this lambda calculus post recently
17:09:59 <elliott> yes
17:10:13 <elliott> he seems to have a knack for inappropriate venues to post things.
17:10:19 <oerjan> aha
17:10:22 <elliott> (http://en.wikipedia.org/wiki/Binary_lambda_calculus is 100% OR)
17:17:16 -!- Taneb has joined.
17:18:50 <Taneb> Hello!
17:19:19 <oerjan> de hi
17:23:32 <Taneb> @ping
17:23:32 <lambdabot> pong
17:24:31 <Taneb> So, what's happening in the world of esoteric programming?
17:24:39 <elliott> nothing
17:27:08 <oerjan> elliott has a _very_ short term memory.
17:37:03 -!- Taneb has quit (Read error: Connection reset by peer).
17:37:33 -!- Taneb has joined.
17:38:48 <myname> oerjan: i think i have to add a signum to my language - i don't see a way to compare values otherwise... do you?
17:39:21 <elliott> JUMP
17:39:36 <oerjan> myname: you can test the lower bits by shifting and subtracting
17:40:15 <myname> the question is: how to test the lower bits
17:41:33 <oerjan> b = a<<1 c=b<<-1 d=a-c
17:41:56 <oerjan> er
17:42:02 <oerjan> switch 1 and -1
17:42:28 <Taneb> Which language?
17:42:47 <oerjan>
17:43:18 <myname> interesting
17:43:48 <Taneb> What happens if you attempt to read from E?
17:44:00 <Taneb> Or EXIT?
17:44:00 <oerjan> syntax error, i think
17:44:16 <myname> it's not yet implemented, bit i will throw a syntax error
17:44:32 <myname> (implementation should be fairly easy, i think)
17:44:45 <Taneb> It'd be nice if reading from JUMP tells you the line number.
17:44:52 <oerjan> heh
17:44:57 <Taneb> Well, less nice and more making-sense
17:45:21 <oerjan> would make relative jumping easier
17:45:25 <myname> indeed
17:45:31 <myname> maybe i'll add that
17:46:23 <myname> okay, so you change the last bit to 0
17:46:38 <myname> how does that help me for comparing 2 vars?
17:46:46 <oerjan> hm i have a hunch you need to consider exactly when JUMP is incremented on ordinary execution if you do that.
17:47:30 <oerjan> myname: you can check the difference in the lower bits. i agree this doesn't help with ordinary < comparison
17:48:11 <myname> as i said i thought of add something like k=i-j k=SIGN JUMP=6+k
17:48:34 <myname> so i will jump to line 5 if j > i, to 6 if they are equal and to 7 otherwise
17:48:49 <elliott> you don't necessarily need such comparisons
17:48:58 <myname> i don't?
17:49:18 <oerjan> not for turing completeness, no
17:49:24 <elliott> sure. for instance I can extend Python with frobnicates, which are numbers that you can increment but not compare to each other
17:49:31 <Taneb> brainfuck, Underload, Lazy K do not have them
17:49:41 <elliott> that doesn't make the resulting language any less TC, because of this limitation :)
17:49:54 <elliott> you just need the absolute bare minimum to implement a turing-complete language
17:50:01 <myname> well, how do i write a programm that compares numbers then?
17:50:14 <oerjan> what you have is enough to treat a number as a stack of bits.
17:50:24 <myname> Taneb: brainfuck has a "is this var 0?" thing with []
17:50:30 <elliott> myname: by simulating the numbers as something else
17:50:38 <oerjan> which is enough for TC.
17:51:02 <Taneb> myname, "is this var 0?" is not "are these two vars the same?"
17:51:34 <oerjan> Taneb: he has subtraction already, so he can get one from the other
17:51:35 -!- Taneb has quit (Read error: Connection reset by peer).
17:51:35 <myname> Taneb: i could just decrement both vars and check if one ore both are zero at one point and have my comparison
17:52:10 <oerjan> but as it is now, i think comparing arbitrary numbers for equality is impossible.
17:52:13 <myname> i don't see how to compare without signum or zero-checking
17:52:40 <elliott> you don't need to compare the native numbers of the language
17:52:48 <elliott> as an analogy: brainfuck's integers are usually fixed-size
17:52:55 <elliott> however you can write algorithms on arbitrary-size integers by encoding them in the tape
17:53:06 <elliott> similarly, you might be able to write a program to compare two integers _encoded_ differently in the integers of your language
17:53:09 <elliott> by using simpler operations
17:53:11 <oerjan> there is boolfuck, which has _only_ bits.
17:54:02 <myname> i'll have to think of this
17:54:07 -!- Ngevd has joined.
17:54:17 <myname> if i can't find a way i'll just go with SIGN
17:54:30 <elliott> Don't worry, oerjan will think of a way for you.
17:55:22 <oerjan> i'm pretty sure you cannot do it without encoding the numbers.
17:56:09 <oerjan> oh hm wait
17:57:24 <oerjan> hm no. there will always be some possibility that there is a very high significance bit you haven't checked yet.
17:57:45 <oerjan> ...i'm wrong.
17:58:06 <elliott> me too
18:00:16 <oerjan> x<<(1-x) can be used to check if a positive number is 1 or 2.
18:01:47 <oerjan> 1<<x is 0 if x is negative, positive otherwise.
18:01:59 <oerjan> myname: you can construct comparisons from this.
18:02:23 <myname> sounds promising
18:02:43 -!- pikhq has joined.
18:02:58 -!- pikhq_ has quit (Ping timeout: 252 seconds).
18:03:50 <oerjan> (2+(1<<x))<<(-1-(1<<x)). hopefully that can be simplified :P
18:04:32 <oerjan> :t shiftl
18:04:32 <lambdabot> Not in scope: `shiftl'
18:04:37 <oerjan> @hoogle shift
18:04:37 <lambdabot> Data.Bits shift :: Bits a => a -> Int -> a
18:04:37 <lambdabot> Data.Bits shiftL :: Bits a => a -> Int -> a
18:04:37 <lambdabot> Data.Bits shiftR :: Bits a => a -> Int -> a
18:05:01 <oerjan> > map (1 `shiftL`) [-2..2]
18:05:02 <lambdabot> Ambiguous type variable `t' in the constraint:
18:05:02 <lambdabot> `Data.Bits.Bits t'
18:05:02 <lambdabot> a...
18:05:10 <oerjan> > map (1 `shiftL`) [-2..2] :: [Integer]
18:05:11 <lambdabot> [0,0,1,2,4]
18:05:31 <oerjan> fine, haskell's shiftL works the same way
18:06:15 <oerjan> > let (<<) = shiftL in [(2+(1<<x))<<(-1-(1<<x)) | x <- [-10..10::Integer]]
18:06:16 <lambdabot> Couldn't match expected type `GHC.Types.Int'
18:06:16 <lambdabot> against inferred type ...
18:06:21 <oerjan> wat
18:07:01 <oerjan> > let x << y = shiftL x y in [(2+(1<<x))<<(-1-(1<<x)) | x <- [-10..10::Integer]]
18:07:02 <lambdabot> Couldn't match expected type `GHC.Types.Int'
18:07:03 <lambdabot> against inferred type ...
18:07:10 <elliott> -1- looks suspicious
18:07:33 <oerjan> why, - does not make a section
18:07:50 <elliott> hm ok
18:07:52 <elliott> i thought it would be
18:07:55 <elliott> -(1-...)
18:08:27 <oerjan> @undef
18:08:38 <oerjan> now what.
18:08:47 <elliott> @undefine
18:09:23 <elliott> wat
18:09:40 <oerjan> by killing lambdabot
18:09:46 <oerjan> @ping
18:09:46 <lambdabot> pong
18:10:00 <oerjan> oh wait that doesn't give a response?
18:10:07 <oerjan> @undefine
18:10:13 <oerjan> that's awkward
18:10:20 <oerjan> > let (<<) = shiftL in [(2+(1<<x))<<(-1-(1<<x)) | x <- [-10..10::Integer]]
18:10:21 <lambdabot> Couldn't match expected type `GHC.Types.Int'
18:10:21 <lambdabot> against inferred type ...
18:10:26 <oerjan> well that didn't help
18:10:35 <oerjan> oh wait duh
18:11:01 <oerjan> > let x << y = shiftL x (fromIntegral y) in [(2+(1<<x))<<(-1-(1<<x)) | x <- [-10..10::Integer]]
18:11:02 <lambdabot> Ambiguous type variable `t' in the constraint:
18:11:03 <lambdabot> `Data.Bits.Bits t'
18:11:03 <lambdabot> a...
18:11:09 <oerjan> WHAT NOW
18:11:31 <elliott> IDGI, what was the duh?
18:11:32 <myname> why don't you just try (-1)-
18:11:41 <oerjan> elliott: second argument is Int
18:11:41 <elliott> myname: that's not the problem
18:11:45 <elliott> oerjan: ah.
18:11:54 <elliott> :t shiftL
18:11:55 <lambdabot> forall a. (Bits a) => a -> Int -> a
18:12:01 <elliott> :t \x y -> shiftL x (fromIntegral y)
18:12:02 <oerjan> oh hm
18:12:02 <lambdabot> forall a a1. (Integral a1, Bits a) => a -> a1 -> a
18:12:08 -!- augur has joined.
18:12:09 <elliott> oerjan:
18:12:11 <elliott> oerjan: "2+"
18:12:12 <elliott> erm
18:12:14 <elliott> "1<<x"
18:12:15 <elliott> what's 1
18:12:17 <oerjan> > let x << y = shiftL (x::Integer) (fromIntegral y) in [(2+(1<<x))<<(-1-(1<<x)) | x <- [-10..10::Integer]]
18:12:17 <lambdabot> [1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0]
18:12:21 <oerjan> there you go
18:12:25 <elliott> clap
18:12:39 <oerjan> well seems to work
18:12:52 <myname> great
18:12:57 <oerjan> myname: mind you this method is going to give some huge numbers
18:13:09 <oerjan> intermediately
18:14:28 <myname> well, depending on the language of choice for writing the interpreter, that's not such a big deal
18:14:45 <elliott> it depends on your definition of "big".
18:14:53 <elliott> oerjan has a ph.d. his definition of "big" is very big indeed.
18:14:55 <elliott> :P
18:15:08 <oerjan> well i don't think this is _quite_ ackermann size :P
18:15:17 <elliott> oerjan: so _how_ inaccessible will the cardinals be, eh:?
18:15:45 <oerjan> 1<<x is 2^x if x is positive.
18:16:02 <elliott> Bad Functional Programmer Band Names #893434: Inaccessible Cardinals
18:16:07 <myname> well, ruby for example has infinitely large integers (just like haskell should have, but obviously you have some downsides here)
18:16:21 <elliott> (What downsides?)
18:16:32 <oerjan> myname: haskell Integer is bignum.
18:16:35 <elliott> Anyway, how big the integer type is is irrelevant if they won't fit into any RAM money can buy.
18:16:48 <myname> oerjan: yeah, but shiftL wants an int
18:16:55 <oerjan> indeed. if x is already big you've got a problem.
18:17:11 <elliott> (Inaccessible Cardinals must, of course, dress the part when performing.)
18:17:20 <oerjan> myname: well that's presumably because they didn't bother to support results that won't fit in memory.
18:18:38 <oerjan> i think you could construct a representation for this that won't blow up like that, though.
18:19:18 <oerjan> by having a sum-of-powers-of-2 representation for huge cases
18:20:05 <oerjan> reminds me of cantor normal form (which are for cardinals, although mostly accessible ones)
18:20:09 <oerjan> *is
18:20:11 <elliott> i have to say, i did not expect the theory here to be interesting.
18:20:12 <oerjan> er
18:20:15 <oerjan> *ordinals
18:21:09 <oerjan> you can make cantor normal form with base 2, although omega is more useful for actually getting to the infinite ones.
18:21:31 -!- Ngevd has quit (Quit: Goodbye).
18:23:55 <myname> maybe i'll have to write an interpreter for this to check if my signum based on that bitshifting monster is valid :D
18:24:05 <oerjan> heh
18:26:04 <oerjan> > let x << y = shiftL (x::Integer) (fromIntegral y) in [x<<(1-x) | x <- [0..10::Integer]]
18:26:05 <lambdabot> [0,1,1,0,0,0,0,0,0,0,0]
18:26:32 <myname> what?
18:27:47 <oerjan> i just tested one of the pieces of this
18:28:20 <myname> the result kind of confuses me
18:28:38 <myname> oh
18:28:44 <myname> nevermind
18:28:44 <oerjan> x<<(1-x) is 1 for x 1 or 2, but 0 for any other nonnegative number
18:47:54 <myname> well, tried a signum implementation and added it as example
18:47:58 <myname> have to test that later
18:49:54 -!- sebbu has quit (Read error: Connection reset by peer).
18:52:33 -!- sebbu has joined.
18:52:42 -!- sebbu has quit (Changing host).
18:52:42 -!- sebbu has joined.
19:09:53 -!- sebbu2 has joined.
19:11:21 -!- sebbu2 has quit (Read error: Connection reset by peer).
19:11:43 -!- sebbu2 has joined.
19:11:44 -!- sebbu2 has quit (Changing host).
19:11:44 -!- sebbu2 has joined.
19:13:05 -!- sebbu has quit (Ping timeout: 246 seconds).
19:15:46 -!- sebbu2 has changed nick to sebbu.
19:22:36 -!- NihilistDandy has joined.
19:39:41 -!- monqy has joined.
19:41:37 -!- elliott has quit (Ping timeout: 244 seconds).
19:45:08 -!- sebbu2 has joined.
19:45:08 -!- sebbu2 has quit (Changing host).
19:45:09 -!- sebbu2 has joined.
19:46:58 -!- Taneb has joined.
19:47:05 <Taneb> Hello!
19:47:11 <Taneb> I'm gonna hovercraft for a bit
19:47:16 -!- Taneb has changed nick to Taneb|Hovercraft.
19:47:16 <oerjan> olleH!
19:47:27 <oerjan> wait what does that mean, actually
19:47:32 -!- asiekierka has quit (Remote host closed the connection).
19:47:55 <Taneb|Hovercraft> The way I use it, it means that my internet's dodgy
19:48:02 <oerjan> ah
19:48:25 <olsner> crafting the hovers
19:48:26 -!- sebbu has quit (Ping timeout: 246 seconds).
19:49:26 -!- KingOfKarlsruhe has joined.
19:50:00 -!- Dr_Frankenstein has joined.
19:50:04 -!- Taneb|Hovercraft has quit (Read error: Connection reset by peer).
19:50:11 <itidus21> i'm a hoversmith
19:50:34 -!- Taneb has joined.
19:51:03 <itidus21> I have been smithing hovers since, a long time ago.
19:51:17 <Taneb> I was right
19:51:23 -!- Taneb has changed nick to Taneb|Hovercraft.
19:51:34 <itidus21> sorry olsner, its your line
19:51:44 <itidus21> i just want to get the most out of it
19:52:11 <olsner> itidus21: no, go ahead, we can share the line
19:52:58 <itidus21> Actually I am not a hoversmith, although I did attend the hoversmith guild annual meeting this year.
19:53:11 -!- sebbu2 has changed nick to sebbu.
19:53:38 -!- Taneb|Hovercraft has quit (Read error: Connection reset by peer).
19:53:56 <itidus21> There is this young upstart who thinks he may have discovered proof of the existence of subhovers.
19:54:01 -!- Taneb|Hovercraft has joined.
19:54:34 -!- NihilistDandy has quit.
19:57:42 <Taneb|Hovercraft> @unpl \(x:y:_) -> (x,y)
19:57:42 <lambdabot> \ (x : y : _) -> (x, y)
19:57:49 <Taneb|Hovercraft> :/
19:57:56 <Taneb|Hovercraft> Wait, I wanted pl
19:58:00 <Taneb|Hovercraft> @pl \(x:y:_) -> (x,y)
19:58:00 <lambdabot> ap ((`ap` tail) . (. head) . (const .) . (,) . head) tail
19:58:05 <Taneb|Hovercraft> Not worth it
19:58:07 <oerjan> MUCH BETTER
19:59:42 <oerjan> :t head &&& (!!1)
19:59:43 <lambdabot> forall c. [c] -> (c, c)
19:59:45 -!- Taneb|Hovercraft has quit (Read error: Connection reset by peer).
19:59:56 -!- Taneb|Hovercraft has joined.
20:00:17 <oerjan> :t head &&& (!!1) -- /me swats Taneb|Hovercraft for leaving during the demonstration -----###
20:00:18 <lambdabot> forall c. [c] -> (c, c)
20:00:55 <olsner> while crafting the hovers you can't always be present on IRC, apparently
20:01:25 <oerjan> UNACCEP43)%Y¤#NO CARRIER
20:01:49 <olsner> can you do it with unsafeCoerce?
20:02:05 <oerjan> no.
20:02:23 -!- Taneb|Hovercraft has quit (Read error: Connection reset by peer).
20:06:52 <olsner> maybe I should draw a bath
20:06:57 <olsner> `quote bath
20:07:00 <HackEgo> 821) <oklofok> you tell us you're making a lisp interpreter, but you don't mention its polterchrist is c++ templates? <oklofok> isn't that like telling us you're taking a bath and not mentioning you're bathing in a WORLD FULL OF SNAKES
20:08:06 <oerjan> i am starting to wonder if oklofok is crossing over into the cthulhu mythos.
20:08:54 <olsner> more like a resident there who occasionally crosses over to our realm
20:10:34 <oerjan> ah
20:16:13 <olsner> trending twitter topics in Sweden (translated): when, sounds, for, why, "oh"
20:16:45 <olsner> seems to be relying on tweets being in english or something
20:16:59 <oerjan> ah
20:17:21 <oerjan> när ljudar för varför, "å"?
20:18:11 <olsner> när låter för varför jaså
20:18:38 <oerjan> oh the verb
20:18:39 <olsner> also håller, but that has too many fuzzy meanings to bother translating
20:18:56 <olsner> ljudar is also a verb
20:20:23 <olsner> another meaning, similar to sound as in "to utter audibly, pronounce, or express: to sound each letter."
20:21:08 <oerjan> lyder and låter may have slightly different meanings in norwegian.
20:21:12 <olsner> plural of the noun sound would be ljud (it's the same in plural and singular)
20:21:44 <oerjan> right, i was guessing the gender wrong
20:22:39 <oerjan> it's masculine in norwegian
20:23:01 <olsner> no idea what it is in swedish, it's just irregular :)
20:23:39 <oerjan> oh
20:37:48 -!- Taneb has joined.
20:38:18 <Taneb> Hello
20:38:53 <olsner> Hovercraft
20:39:29 -!- Taneb has changed nick to Taneb|Hovercraft.
20:39:31 <Taneb|Hovercraft> Yes?
20:40:00 -!- cswords has joined.
20:42:32 -!- zzo38 has joined.
20:48:08 -!- Taneb|Hovercraft has changed nick to Taneb.
20:58:02 <myname> should work as an implementation, but my second example seems to be wrong :D
21:00:53 -!- azaq23 has joined.
21:01:03 -!- azaq23 has quit (Max SendQ exceeded).
21:02:06 -!- azaq23 has joined.
21:08:20 <RocketJSquirrel> I'm the only IOCCC entry with a cleanly-indented submission X-D
21:08:24 <RocketJSquirrel> s/entry/winner/
21:09:09 <oerjan> i guess that only increases the horrificness
21:09:30 <RocketJSquirrel> I decided it was ballsy to not bother with that particular obfuscation.
21:09:47 <RocketJSquirrel> And the judges comments still amount to "We have no idea why this works, but it does."
21:09:48 <olsner> oh, the source for the winners is still not public
21:09:58 <RocketJSquirrel> No, but the winners have all the other winners' sources.
21:10:23 <oerjan> running a reformatter is probably the first step they apply anyhow
21:11:02 <Taneb> I decided to try some Haskell Golf the other day
21:11:06 <RocketJSquirrel> oerjan: I would assume so.
21:11:13 <Taneb> import Random;main=newStdGen>>=putStr.randomRs('!','~')
21:11:21 <RocketJSquirrel> oerjan: But one of these entries in particular has absolutely beautiful crazysauce source :)
21:11:29 <oerjan> ah
21:12:25 <Taneb> Prints an endless sequence of ASCII printing characters
21:15:48 <RocketJSquirrel> Still, I think being the only one with well-indented source makes me a different breed of winner.
21:15:50 <RocketJSquirrel> It's a good thing.
21:16:39 <oerjan> myname: your when "JUMP" will match JUMP as a _part_ of the string, which will break on "JUMP-c" and such
21:16:52 <oerjan> er wait
21:16:55 <oerjan> forget that
21:21:57 <myname> i'll clean my signum implementation up a bit by abusing the ability to JUMP=JUMP-0-x
21:22:40 <myname> i also forgot to add 48 before IOing
21:23:43 <Taneb> -26529
21:26:38 <oerjan> myname: does your interpreter do what you want for NOP=IO ?
21:27:21 <myname> i could remove NOP, it was just an idea to handle otherwise empty lines
21:27:53 <oerjan> oh so it's really a comment marker?
21:28:06 <myname> it kind of was, yes
21:28:28 <myname> but since everything after the first space is a comment, it's not really necessary
21:29:14 <myname> i'm a bit confused about the result of
21:29:19 <myname> i=IO-48
21:29:21 <myname> j=IO-48
21:29:39 <myname> it just asks about i
21:30:19 <oerjan> well it probably asks per line, but reads per char?
21:30:51 <myname> i'll try that later, it should be a ruby issue
21:30:54 * oerjan doesn't _actually_ know ruby
21:31:13 <oerjan> but it seems easy to guess most of it from the languages i know
21:31:38 <myname> ruby is really easy to read imo
21:35:02 <kmc> @where zalgo
21:35:02 <lambdabot> import Random;main=mapM_((>>(י=<<randomRIO('̀','ͯ'))).י)=<<getContents;י=putChar
21:35:03 <kmc> Taneb, ^^^^
21:35:46 <Taneb> Mine's... shorter?
21:35:53 <kmc> mine... does something completely different
21:35:59 <Taneb> Yay
21:36:30 <kmc> ruby is easy to read as long as your intuition agrees with that of every library author regarding all manner of unstated conventions
21:38:50 <kmc> if you give rails a class named 'Child' it will look for a DB table named 'children'
21:38:59 <kmc> to do this, it has a big list of irregular English plurals
21:39:17 <kmc> and of course there are some errors in the list, but they can't be changed now!
21:40:30 <kmc> i dislike this kind of thing because 'grep' is like my main tool for understanding code
21:40:48 <kmc> if there's a table named 'children' and I grep the code for that name and don't find it...
21:41:27 <myname> well yeah, but don't curse a language because of a popular framework
21:41:40 <myname> e.g. php sucks, but smarty sucks even more
21:42:17 <kmc> rails is hardly the only ruby library with this philosophy
21:43:20 <Taneb> I really need to learn more programming languages
21:43:32 <Taneb> Ruby is about 10th on my list to learn
21:43:51 <Taneb> I may never get past 3
21:44:04 <monqy> what is 3
21:44:20 <Taneb> I think it's C
21:44:27 <Taneb> May be Lisp
21:44:40 <Taneb> Or even Java
21:44:42 <myname> whenever i think "hey, let's learn a new language" i come up with "well, why the fuck do i even need another one?"
21:45:16 <kmc> Ruby and Rails are pretty well intertwined as far as history and destiny
21:45:36 <myname> never ever used rails for anything
21:47:13 <monqy> myname: bad attitude
21:47:14 <Taneb> My order goes Haskell -> C -> Lisp -> Inform 7 -> Java -> Perl -> Objective C for use on iOS -> Some ML language -> JavaScript -> PHP -> Ruby
21:47:37 <KingOfKarlsruhe> and C#?
21:47:38 <Phantom_Hoover> > 200 / 16
21:47:39 <lambdabot> 12.5
21:47:39 <Taneb> (subject to change)
21:47:42 <Phantom_Hoover> > 200 / 25
21:47:43 <lambdabot> 8.0
21:47:44 <myname> i always wanted to learn perl for the single purpose of being exactly as old as it
21:47:57 -!- pikhq_ has joined.
21:48:02 <Taneb> COBOL's sorta floating about somewhere, too
21:48:06 -!- pikhq has quit (Ping timeout: 252 seconds).
21:48:13 <kmc> there's some quote (which escapes me) to the effect that learning a new programming language is only worthwhile if it gives you a new way to think
21:48:45 <Taneb> kmc: I always forget the old way...
21:49:01 <myname> kmc: that's the main reason i learned befunge
21:49:06 <myname> (really like it)
21:49:38 <kmc> for most programmers Haskell, C, and Lisp are all promising on that front
21:49:42 -!- Ngevd has joined.
21:49:58 <kmc> C won't teach you "how the machine really works" but it will teach you a layer which is hidden by most languages
21:49:59 <myname> haskell is nice as long as you don't have to use monads
21:50:23 <monqy> myname: what
21:50:54 <myname> i don't understand that question
21:51:02 <Ngevd> Monads are easy when you get the hang of them
21:51:02 <monqy> ok
21:51:08 -!- Taneb has quit (Read error: Connection reset by peer).
21:51:15 -!- Ngevd has changed nick to Taneb.
21:51:26 <kmc> Lisp will teach you that "never, ever repeat yourself" is an achievable goal, and that it's not always good for readability
21:51:28 -!- derdon has joined.
21:51:37 <monqy> myname: what don't you like about monads? they aren't the best thing, sure, but it's not like they're really hard to use or anything
21:51:55 <Taneb> They've got a pretty bad rep
21:51:56 <monqy> monads are severely overhyped as being difficult
21:51:59 <monqy> they really aren't at all
21:52:02 <Taneb> But it's undeserved
21:53:22 <myname> okay, my signum works now
21:53:41 <Taneb> Basically, monads are like monads
21:53:55 <myname> Taneb: indeed
21:54:16 <Taneb> You just need to forget they're there and before you know it, you're using them all the time.
21:55:33 <itidus21> like all esolang stuff
21:55:40 <oerjan> lower=tlb<<tlc that whole thing is a (2+(1<<x))<<(-1-(1<<x)) - thanks to oerjan <-- i'm not convinced your parser treats the last part there as a comment
21:56:02 <monqy> itidus21: ??? do you know this from experience or is this a wild guess
21:56:06 <myname> oerjan: ?
21:56:44 <Taneb> itidus one day was walking along the beach when he thought: "hmm... a function can be used as the input to another function"
21:56:48 <oerjan> myname: oh wait, found it
21:56:57 <myname> oerjan: it just splits at " "
21:57:24 <Taneb> I've got a friend who's planning on moving to Sweden.
21:57:35 <itidus21> brb
21:57:38 <Taneb> Completely off-topic, I know, but...
21:58:02 <Taneb> There is at least one swede who frequents this channel?
21:58:20 <oerjan> those pesky root vegetables
21:58:51 <myname> txt file updated with working signum
22:02:04 <oerjan> hm...
22:02:23 <myname> hm?
22:02:27 <oerjan> > let x << y = shiftL (x::Integer) (fromIntegral y) in [x<<(2-x) | x <- [0..10::Integer]]
22:02:28 <lambdabot> [0,2,2,1,1,0,0,0,0,0,0]
22:02:33 <oerjan> bah
22:02:55 <myname> you still think of ways to optimize that bitshifting part?
22:03:04 <oerjan> i was just wondering if you could get a three-way test shorter
22:03:44 <myname> i didn't even recheck what it does :p
22:03:53 <myname> the results were enough
22:06:57 <oerjan> oh well
22:08:45 <oerjan> i see - is officially right associative now :P
22:09:17 <myname> it is
22:09:30 <myname> easiest case to implement without downsides
22:19:02 -!- Taneb has quit (Read error: Connection reset by peer).
22:28:59 <zzo38> Another programming language worth to learn is Forth, I think
22:29:40 <zzo38> It is also worth to learn Haskell, C, and Lisp
22:30:14 <oerjan> i also don't think anyone mentioned Prolog
22:31:12 <zzo38> myname: I can explain my view of monads. But you should learn a endofunctor at first, before trying to understand monads. At least, that is how I understood it best.
22:31:38 <myname> what is an endofunctor?
22:31:54 <oerjan> `? endofunctor
22:31:57 <HackEgo> Endofunctors are just endomorphisms in the category of categories.
22:32:06 <oerjan> HOPE THIS HELPS
22:32:21 <myname> what the
22:32:23 <oerjan> `? monad
22:32:26 <HackEgo> Monads are just monoids in the category of endofunctors.
22:32:37 <zzo38> myname: Notice the Haskell typeclass: class Functor f where { fmap :: (a -> b) -> f a -> f b; };
22:33:15 <zzo38> It must follow the law: fmap id = id; fmap f . fmap g = fmap (f . g); An example would be useful. One example is a list: fmap succ [1,2,4] = [2,3,5]
22:33:43 <myname> and the advantage to map succ [1,2,4] is...?
22:34:01 <ion> map can be thought of just fmap specialized to lists.
22:34:06 <zzo38> myname: I am simply explaining the use of a mathematical structure
22:34:26 <myname> ion: that kinda makes sense
22:35:13 <oerjan> back in the glorious days of Haskell 1.4, map _was_ fmap.
22:35:36 <myname> so... should i give "hello world" a try in my little experiment?
22:35:39 <zzo38> A monad has two additional operations (although the Haskell typeclass for Monad is defined badly): return :: a -> m a; join :: m (m a) -> m a; Which again must follow certain laws (in mathematics, return is usually called eta and join is called mu).
22:36:20 <zzo38> A list is also a monad: return makes a single element list, and join makes a list of list flatten to a list. Example: return 5 = [5] join [[5,6,7],[9,100,1000,10000],[2]] = [5,6,7,9,100,1000,10000,2]
22:36:35 <zzo38> And there is >>= which is like: x >>= f = join (fmap f x);
22:36:45 <zzo38> Which is convenient in many cases.
22:36:48 <myname> maybe that whole mathematic based stuff in haskell shouldn't be explained on the first semester
22:37:14 <oerjan> myname: zzo38 has his own views of many things.
22:37:59 <zzo38> It is also possible to define a monad in terms of >>= (and Haskell unfortunately requires you to): fmap f x = x >>= return . f; join x = x >>= id;
22:38:26 * myname puts his hands over his ears
22:38:28 <myname> lalalalalalala
22:39:49 <oerjan> <myname> so... should i give "hello world" a try in my little experiment? <-- that _should_ be rather trivial, shouldn't it?
22:40:35 <oerjan> zzo38: i don't think myname is the right level of audience for this.
22:41:01 <zzo38> oerjan: Well, you cannot learn monads without this.
22:41:43 <myname> oerjan: well, i could just do a bunch of IO=, indeed
22:41:47 <shachaf> I don't think "learning monads" is a particularly useful goal.
22:43:09 <oerjan> zzo38: you cannot learn to _design_ monads without this, maybe. using them is quite possible.
22:43:28 <zzo38> Monads is a useful thing in Haskell especially since the I/O is based on working of monads.
22:43:37 <myname> well, everything depends on what the prof wants to know *g*
22:43:41 * shachaf sighs.
22:46:07 <oerjan> `? shachaf
22:46:09 <HackEgo> No output.
22:46:13 <oerjan> hm...
22:46:18 <myname> "proof that the following made monad follows the laws of monads"
22:46:19 <zzo38> IO is also monad. fmap applies a function to the result of the I/O. return makes a I/O action of doing nothing, and always resulting in the same value (instead of determining the result by user input or whatever). join means if the result is another I/O action, the resulting action will be executed after the one that resulted in it. >>= will apply a function to the result to determine the action to do next.
22:46:25 <myname> i was like "fuck you"
22:46:35 <zzo38> So then you might understand a code like this: main = getLine >>= putStrLn;
22:46:49 <oerjan> myname: oh you've had haskell in class?
22:46:55 <myname> i did
22:46:58 -!- KingOfKarlsruhe has quit (Quit: ChatZilla [Firefox 11.0/20120312181643]).
22:47:30 <myname> it's an interesting language and i like much of it's aspects
22:49:49 -!- Dr_Frankenstein has left ("Konversation terminated!").
22:50:17 <zzo38> There are some things I dislike about Haskell which is why I try to design my own, where one thing is Haskell's "fmap" is now called "map" in mine, and various other differences too in how kinds work and typeclasses and macros and so on.
22:57:18 <oerjan> myname: you might look at http://esolangs.org/wiki/Popular_problem
22:59:19 -!- augur has quit (Remote host closed the connection).
23:00:51 * oerjan suddenly realizes myname is part of the recent "same first three letters as a regular nick" invasion
23:02:08 <kmc> cool, a monad tutorial
23:02:23 <oerjan> Monaden er som lefsa
23:03:00 <kmc> monadum delenda est
23:05:36 -!- ais523 has joined.
23:19:58 <RocketJSquirrel> RocketJSquirrel is unique at three characters, but ambiguous at two :(
23:22:49 * kmc sighs with shachaf
23:23:28 <pikhq_> Monad tutorials are like burritos.
23:23:37 <myname> what
23:24:13 <Phantom_Hoover> pikhq_ is beating a joke into the ground to see if he can get a bit of humour out of it.
23:25:31 <ais523> ooh, Yahoo! Mail's POP thing started working again
23:25:35 <ais523> 187 new emails!
23:25:46 <pikhq_> ais523: ... You still have Yahoo! Mail?
23:25:49 <oerjan> only 185 of which are spam!
23:26:00 <ais523> pikhq_: "still"? I joined it relatively recently
23:26:22 <ais523> oerjan: actually, few are, I don't receive much spam on that account
23:26:25 <pikhq_> I see ais523 is computing like it's 1998.
23:26:29 <ais523> and the spam filter has more false-positives than true positives
23:26:42 <ais523> pikhq_: I distrust them the least out of the three major webmail providers
23:27:29 -!- HackEgo has quit (Remote host closed the connection).
23:27:35 <pikhq_> Okay, true, your greatest risk with Yahoo! is that they terminate the service and throw everything away.
23:27:40 -!- HackEgo has joined.
23:27:41 <pikhq_> (Yahoo! *loves* that)
23:28:08 <ais523> pikhq_: indeed, and I don't use it for long-term storage of anything
23:28:09 <ais523> just as a spool
23:28:16 <myname> or they lose all their money fighting facebook
23:29:50 <RocketJSquirrel> Monad tutorials are like bad analogies: They do little to illustrate anything usefully, and yet allow the author to maintain an undeserved sense of smug superiority.
23:29:50 -!- RocketJSquirrel has quit (Excess Flood).
23:29:56 -!- Gregor has joined.
23:30:04 <pikhq_> TIL that was an excess flood.
23:30:12 <ais523> isn't the /main/ purpose of monad tutorials to annoy elliott?
23:30:17 -!- Gregor has changed nick to RocketJSquirrel.
23:30:44 <oerjan> ais523: shhh, that's secret!
23:30:48 -!- EgoBot has quit (Ping timeout: 260 seconds).
23:30:50 <monqy> does eliot still logread
23:31:02 -!- EgoBot has joined.
23:31:20 * Phantom_Hoover -> sleep
23:31:22 -!- Phantom_Hoover has quit (Quit: Leaving).
23:31:23 <pikhq_> Probably.
23:31:31 <pikhq_> And more importantly, he actually comes in!
23:31:41 <oerjan> WHOOPS
23:31:55 <zzo38> Do you think monad tutorials are like burritos? I think my description of monad seems reasonable at least to me it does; but perhaps other people prefer a different one or none at all, or multiple ones.
23:32:14 <pikhq_> zzo38: No, just riffing on the meme "monads are like burritos".
23:32:52 <zzo38> Yes, I know; but, which monad tutorials do you prefer (if any)?
23:33:13 <RocketJSquirrel> Wow, wtf excess flood ... random.
23:33:17 <zzo38> Can you make "where is my keys" soup?
23:34:46 <myname> i prefer monat tutorials like buttiros, delicious if it comes in, but what's left is just poo
23:35:32 <monqy> what
23:37:52 <kmc> @remember myname i prefer monat tutorials like buttiros, delicious if it comes in, but what's left is just poo
23:37:52 <lambdabot> I will remember.
23:38:02 <kmc> buttiros -- worst breakfast cereal ever
23:39:29 <oerjan> a cereal killer
23:40:34 -!- augur has joined.
23:40:40 -!- augur has quit (Remote host closed the connection).
23:40:53 -!- augur has joined.
23:44:12 -!- myndzi\ has joined.
23:45:32 -!- jix_ has joined.
23:45:37 -!- jix has quit (Read error: Operation timed out).
23:45:37 -!- cheater has quit (Read error: Operation timed out).
23:45:38 -!- elly has quit (Read error: Operation timed out).
23:45:38 -!- olsner has quit (Read error: Operation timed out).
23:45:38 -!- variable has quit (Read error: Operation timed out).
23:45:38 -!- FireFly has quit (Read error: Operation timed out).
23:46:10 -!- olsner has joined.
23:46:37 -!- elly has joined.
23:46:53 -!- cheater has joined.
23:47:34 -!- myndzi has quit (Ping timeout: 252 seconds).
23:48:31 -!- variable has joined.
23:56:55 <kmc> <zzo38> ... I think my description of monad seems reasonable at least to me it does
23:57:02 <kmc> http://byorgey.wordpress.com/2009/01/12/abstraction-intuition-and-the-monad-tutorial-fallacy/
23:57:39 <kmc> not to say your explanation is bad, just that it making sense to you is not much evidence either way
←2012-03-13 2012-03-14 2012-03-15→ ↑2012 ↑all