00:02:33 -!- sebbu has joined.
00:02:34 -!- sebbu has quit (Changing host).
00:02:34 -!- sebbu has joined.
00:03:05 <kmc> Sgeo: why is it esaier to donate via SL? Is SL already hooked up to some payment mechanism?
00:03:54 <nooodl> hagb4rd: i can't find any reliable source on that
00:04:05 <kmc> de.wikipedia.org has it
00:05:01 <hagb4rd> nooodl: actually it's called cyclosophie in english.. but there are very few english sites providing information on that
00:05:10 <Sgeo> kmc, it's currently rather difficult for me to take my SL money and bring it into RL
00:05:16 <nooodl> what bothers me most is, it *only* exists in german sources
00:05:19 -!- sebbu2 has quit (Ping timeout: 260 seconds).
00:05:33 <nooodl> it doesn't even appear to have a dutch name
00:06:02 <Taneb> nooodl, I have a dutch name
00:06:11 <Taneb> That doesn't mean much
00:09:11 -!- nooodl_ has joined.
00:09:41 <oerjan> isn't dutch similar enough to german that the word might work in both?
00:10:22 <hagb4rd> and i believe it's originally called "radosophie"
00:11:33 <hagb4rd> it's translated to cyclosophie but there a very few sources on cyclosophie anyway
00:11:57 <oerjan> google translate seems to think rad means wheel in both
00:12:04 -!- nooodl has quit (Ping timeout: 248 seconds).
00:12:53 <hagb4rd> actually rad is wheel but colloquially it means bike
00:14:08 * oerjan wonders what the etymology of that is
00:14:18 <nooodl_> oerjan: literally nobody knows for sure
00:14:30 <nooodl_> there's no cognates for it at all
00:14:48 <nooodl_> wait. whoa what http://www.24oranges.nl/2012/02/23/etymology-of-dutch-word-for-bicycle-cracked-after-140-years/
00:14:55 <oerjan> hm also means machine?
00:15:01 -!- sebbu has quit (Read error: Connection reset by peer).
00:15:28 -!- sebbu has joined.
00:15:29 -!- sebbu has quit (Changing host).
00:15:29 -!- sebbu has joined.
00:15:41 <hagb4rd> you see the list of mystical facts on the dutch and their bikes is getting longer and longer :D
00:15:49 -!- DHeadshot has joined.
00:16:49 <Bike> it's hard to beat "vélocipède", really.
00:20:14 <zzo38> I was playing Dungeons&Dragons game yesterday. We were trying to hide in the storage room, but we got chased around by all over the place, by guards, invisible wizards, an undead shadow, the wizard who was invisible was putting candles on the floor and eventually made some spell to light the fire much bigger...
00:23:46 <zzo38> It is a little bit like a game of chess. But, this game is much more complicated and has incomplete information, as well as nearly everything else different.
00:24:17 -!- Taneb has quit (Quit: goodnight).
00:30:30 <zzo38> I managed to reverse the hinge on a door to prevent it from opening; I was trying to change it so that it would open into the hallway instead of opening into the room, but now it doesn't open at all. Well, at least this helps a bit.
00:33:12 <kmc> Sgeo: oh, you can donate SL money, i see
00:33:48 <kmc> my friend says in NL it is common to have two bikes, one at each end of your commute by train
00:35:25 <kmc> i guess this is needed because cities in NL don't have dense rapid transit networks
00:40:46 <kmc> wheeee template templates
00:41:04 <kmc> template <class A, template <class> class B> class C
00:45:05 <hagb4rd> often used that to build some kind of dictionary of dictionaries for example
00:45:47 <hagb4rd> mutidimensional dictionaries
00:49:43 <fizzie> That's just using a template class as the type parameter of a class template, not a template template thing?
00:51:16 <fizzie> I don't know how template templates work, so I can't answer that. But you certainly don't write something like that just to make a map< string, map<string, string> >.
00:51:16 <kmc> map<a, map<b, v> > is not template templates
00:51:32 <kmc> because map<b, v> is a fully instantiated type
00:51:48 <kmc> template templates lets you do things like Foo<a, map>
00:51:58 <kmc> where the body of Foo then gets to instantiate 'map' however it wants
00:52:03 <kmc> and you could pass in some other two-argument template there
00:52:38 <kmc> if I have template <class A, template <class> class B> class C
00:53:08 <kmc> then within C i can use B<int>, B<A>, B< B<A> >, etc.
00:53:29 <kmc> and the code that uses C gets to decide which template B ultimately is
00:53:59 -!- TodPunk has quit (Ping timeout: 260 seconds).
00:54:03 <kmc> this corresponds to higher-kinded types in Haskell
00:54:12 <kmc> type constructors that take other type constructors as arguments
00:54:17 <kmc> :k ReaderT
00:54:50 <Jafet> "Very nice, but does g++ have it"
00:57:29 <kmc> template templates? yes
00:57:42 <kmc> they're a standard C++98 feature i believe
00:58:36 <Jafet> Well, there is at least one C++98 feature that no one supports
00:58:53 <kmc> ok, fair enough
00:59:10 <Jafet> Except the edison people who get paid millions of dollars to implement C++98
00:59:34 <Jafet> And I believe people who buy their compilers then turn it off
00:59:55 <kmc> is this the precompiled templates or whatever?
01:00:25 <etb> template templates?
01:00:26 <Jafet> Templatium exportium
01:00:52 <kmc> etb: template templates are what we were discussing above
01:01:04 <kmc> they are widely implemented afaik
01:01:32 * etb looks in the logs
01:02:55 <hagb4rd> i believe the notation of this simplified by generics in c#
01:03:21 <etb> give it to me raw
01:04:10 <etb> wow, it works
01:04:18 <etb> template<class A, template<class> class B> class C { }; int main(){}
01:07:05 <kmc> template <template <template <class> class> class T> class C {};
01:07:55 <Jafet> This is like python at the type level
01:07:59 <etb> how do you instantiate it?
01:08:21 <etb> C<vector<vector<int>>> x?
01:08:37 <kmc> int, vector<int>, and vector<vector<int>> are all ordinary types
01:08:49 <kmc> they aren't uninstantiated templates
01:09:21 <kmc> with that C and "template <template <class> class T> class D {};" you could then use C<D>
01:09:25 <Bike> kmc, you're making me want to find that book on template metaprogramming. make it stop
01:10:29 <kmc> likewise with that D you could do D<std::set> or any other one-argument template
01:10:35 <Jafet> @google c++ template metaprogramming abrahams
01:10:36 <lambdabot> http://www.amazon.com/Template-Metaprogramming-Concepts-Techniques-Beyond/dp/0321227255
01:10:42 <kmc> though std::set also has some default template arguments and I don't know how that interacts
01:12:00 <kmc> you could imagine that D implement some high-level algorithm, and you tell it what data structure template to use
01:12:20 <kmc> maybe D<std::list> is more efficient in some cases and D<std::vector> is better in other cases
01:12:40 <kmc> but D can just use T<float> and T<int> and whatever, and not care whether T is list or vector
01:12:54 <kmc> so long as the way it uses T is compatible with both
01:13:21 <Jafet> But I presume you can pass template typedefs as parameters
01:13:33 <kmc> of course that idea of templates conforming to some interface does not exist inside the language, it's a matter of documenting method signatures and such
01:13:40 <kmc> they were going to add it to the language for C++11 but ultimately did not
01:13:47 <Jafet> using template <class T> vector1 = vector <T>;
01:14:05 <kmc> template instantiation is totally duck-typed which is kinda funny
01:14:15 <Jafet> Python at the type level
01:14:29 <kmc> a dynamically typed language at compile time and a statically typed language at run time
01:14:32 <kmc> what a country
01:14:47 <kmc> of course it would just be TOO INSANE to have a language where the metalanguage is the same language you already know
01:15:04 <kmc> so let's keep inventing shitty half-baked metalanguages and then hacking them to do unexpected things
01:15:11 <olsner> also that it's turing complete at compile time but not at runtime
01:15:33 <Bike> ope, and with that the interest is dead. artful
01:15:39 <kmc> what do the C++ standards say about maximum template expansion depth
01:15:52 <kmc> if they allow implementations to set a max depth (which they all do) then it's not TC at compile time either
01:16:15 <olsner> ah, yes, there is that ... hopefully it merely allows a max depth to exist
01:19:20 <oerjan> u cannot use the same language as the metalanguage bcs gödel's theorem duh
01:22:56 -!- oerjan has quit (Quit: Good night).
01:24:19 <etb> what's wrong with template language?
01:24:53 <zzo38> What I think is wrong with it is how it uses < >
01:25:35 <kmc> it's just not a good language for writing general purpose metaprograms
01:25:49 <kmc> getting even basic data structures in your metalanguage is annoying
01:26:40 <kmc> and compilers implement it very poorly, with horrible error messages
01:27:08 <kmc> and you can't really inspect the structure of your template arguments, which rules out a lot of useful metaprograms
01:27:24 <kmc> i can't write a template that takes some other class and serializes it to JSON using the names of its data members as strings
01:27:48 <kmc> C++ templates are okay for generic data structures and other very simple metaprograms, which is what they were designed for
01:28:24 <Bike> why would you do that in a template?
01:28:50 <kmc> well it's pretty clearly a metaprogram, at least in a static language
01:29:02 <kmc> you read the description of some data structure and then you emit code which serializes that data structure
01:29:11 <kmc> templates are the only popular form of metaprogramming in C++
01:29:28 <Bike> i suppose qt's... stuff, doesn't count
01:29:37 <kmc> maybe it does actually
01:29:42 <kmc> i have heard of this stuff but don't know much about it
01:29:57 <kmc> there are some other extensions to C++
01:30:16 <kmc> and you can write custom preprocessors
01:30:18 <Jafet> I wonder how the vampire hunting language is developing
01:30:20 <kmc> and custom compiler passes
01:30:22 <Bike> well, i think it allows enough introspection of classes to do json serialization, but i don't think it's at compile time
01:30:27 <kmc> but it's a pretty bad situtaion
01:31:12 <kmc> especially since C++ is so rigid and static that you really want metaprogramming
01:32:01 <kmc> of course a lot of C++ programmers think that metaprogramming is synonymous with template metaprogramming
01:32:23 <kmc> they can't even conceive of a language where you can write -straightforward- programs that manipulate other programs
01:32:53 <etb> even template metaprogramming is looked down upon by some foolish c++ programmers
01:35:23 <kmc> well they are right to look down on it, because it's cumbersome and annoying
01:35:46 <kmc> but it's fallacious to conclude that metaprogramming in general is simply beyond human understanding and we should all write boilerplate all day
01:36:24 <kmc> as usual, the existence of a popular, bad implementation of an idea is enough to damn the idea entirely
01:36:49 <kmc> MySQL sucks, therefore relational databases suck
01:37:03 <kmc> Python and Ruby suck at threading, therefore threads are a horrible and useless concept
01:37:11 <kmc> rantrantrant
01:37:20 <etb> i see what you mean. it's a shame :(
01:37:30 <Bike> have you worked out that python threading business yet?
01:37:51 <Bike> the one you've been intermittently complaining about
01:37:56 <etb> though, i am personally at least lukewarm to C++ templates. they leave something to be desired, but i like them so far
01:38:05 <kmc> Bike: probably not, then
01:38:07 <Bike> also: i wonder if this is why my python-user friend was so big on me not using threads
01:38:57 <kmc> well you should not use threads in python
01:39:18 <Bike> i mean, maybe he got a(n especially) bad impression of them from python.
01:39:21 <zzo38> Can we make a better preprocessor for C which runs after the C preprocessor?
01:39:23 <kmc> yes, most likely
01:39:41 <zzo38> Is there a way to tell GCC to add a step after the preprocessor?
01:39:43 <Jafet> The python threading business is that python does not implement threads correctly
01:39:56 <Jafet> Also, they don't want to implement threads correctly, ever
01:39:58 <kmc> it's kind of sad that GHC has put all this effort into an actually good implementation of shared-memory multiprocessing, and the rest of the world has just decided that shared-memory multiprocessing is a lost cause
01:40:28 <kmc> history has passed them by
01:40:29 <Jafet> zzo: you can override what preprocessor gcc uses
01:41:03 <kmc> they've also put all this effort into a statically-typed language where the type system doesn't hate you, and the rest of the world has decided that type systems are a lost cause
01:41:22 <kmc> anyway this is a pointless rant
01:41:24 <Bike> you feelin' down, kmc?
01:41:30 <etb> is it possible to have code executed at compile time during template expansion?
01:41:38 <zzo38> Jafet: I want to make it still use the C preprocessor but to add something else afterward; perhaps if the other program knows where the real C preprocessor is then it can use that with it.
01:41:58 <Jafet> Pass a shellscript that runs cpp
01:42:01 <kmc> etb: C++ code? no. template code? yes
01:42:02 <Bike> can't you just pipe gcc -E through whatever
01:42:25 <FreeFull> I don't understand monads as well as I should
01:42:38 <Jafet> Bike: gcc can compile multiple TUs at once, so a pipe won't work
01:42:39 <kmc> etb: but the compiler *is* free to evaluate constant expressions at compile time, and C++11's constexpr keyword greatly expands the scope of that
01:42:47 <FreeFull> Why does it print "moomoomoo" rather than "moo"
01:43:21 <zzo38> FreeFull: It is like (join ("moo" <$ [5,5,3])) = (join ["moo","moo","moo"])
01:43:22 <Bike> free to? so it doesn't have to.
01:43:27 <kmc> FreeFull: look at the definition of (>>=) for "instance Monad []"
01:43:52 <Jafet> You can force it to
01:43:57 <kmc> which is... somewhere
01:44:03 <Jafet> Leather cuffs and paddle optional
01:44:42 <zzo38> x >>= f = join (fmap f x); x >> y = x >>= \_ -> y; therefore [5,5,3] >> "moo" = [5,5,3] >>= \_ -> "moo" = join (fmap (\_ -> "moo") [5,5,3])
01:44:59 <Jafet> int a[fact<10>::value];
01:45:05 <zzo38> FreeFull: To me that is how I can understand why it does that.
01:45:15 <lambdabot> Source not found. Wrong! You cheating scum!
01:45:19 <kmc> sorry that i can't find it
01:45:32 <etb> i'm picturing a system in which `using x = T<int>; using y = T<int>;` will be like `using x = T<int,0>; using y = T<int,1>;` so that the expression `x = y;` results in a compile-time error
01:45:39 <etb> harder types!
01:46:27 <zzo38> Yes, it is like concatMap
01:46:31 <Jafet> etb: dude, you can't do that in a pure language like C++
01:46:37 <Jafet> It doesn't make sense
01:46:58 <lambdabot> Source not found. Listen, broccoli brains, I don't have time to listen to this trash.
01:47:03 <kmc> > [1,2,3] >>= (\x -> [x*10, x*100])
01:47:14 <kmc> FreeFull: ^^^ do you understand why it does this?
01:47:17 <Jafet> C++ is a pure functional language
01:47:41 <zzo38> FreeFull: A monad mathematically may be defined two ways, either fmap return join or return =<< and Haskell normally does it by return >>=
01:47:44 <Jafet> You can probably, however, implement a state monad at the type level or something
01:47:51 <zzo38> But either way it defines the same monad.
01:47:56 <kmc> > [1,2,3] >>= (\x -> ['m', 'o', 'o'])
01:47:59 <etb> you can do everything i said after "will be like"
01:48:53 <zzo38> So in the list monad that is what happen; join = concat; fmap = map; return x = [x]; x >>= f = concatMap f x = concat (map f x); and it follow the monad laws (such as (>>= return) = id) so it work.
01:48:57 <Jafet> Actually x = y is a compile error because it's not an expression
01:49:21 <etb> i mean x a, y b; a = b;
01:49:49 <Jafet> That's also a compile error
01:50:01 <etb> ; instead of , :P
01:50:18 <Jafet> Then it depends on which operator= is defined
01:50:25 <zzo38> The other way would be by join = (>>= id) and fmap f x = x >>= return . f; so it recovers either way. There are many different kind of monad, as long as they follow the monad laws.
01:50:46 <kmc> most things could be
01:50:54 <kmc> AIDS could be worse
01:51:18 <etb> right, except using x and using y both = T<int>; then it will use the default assignment operator unless you overwrote it
01:51:28 <etb> except if *
01:53:16 <etb> i'm saying that the user-defined type system breaks down when you want to use the same POD to mean two different things
01:53:23 <Jafet> T<int> is always the same type. How would you feel if it suddenly went off and became another type?
01:53:52 <etb> i would feel ok with it if there were a way to specify that you want that to happen
01:53:55 <Jafet> It's pretty important that C++ is a pure, functional language.
01:54:32 <etb> such as with using
01:55:35 <Jafet> Actually, the preprocessor is a PSPACE-complete sequential state machine, so you could use that to generate newtypes
01:56:26 <etb> the case where this would matter is here: void calc_something(feet_per_second); /* ... */ meters_per_second x = 9.0; calc_something(x); // duh
01:56:34 <etb> Jafet: oh?
01:57:20 -!- TodPunk has joined.
01:58:04 <Jafet> Why would templates matter
01:58:42 <etb> cause they would be used as a wrapper for a POD
01:59:14 <Jafet> Why do you need some crazy mutable state
01:59:33 <etb> they wouldn't matter actually if you could just using fps_value = double; or whatever and have it mean something
01:59:54 -!- Vorpal has quit (Ping timeout: 276 seconds).
02:01:48 <Jafet> typedef meter = make_unit <"meter">::type; typedef second = make_unit <"second">::type; typedef meter_per_second = unit_mul <meter, unit_recip <second>>::type;
02:04:17 -!- calamari has joined.
02:05:20 <etb> now we're talking
02:06:50 <etb> const char* for template parameter?
02:06:54 -!- NihilistDandy has joined.
02:08:11 <Jafet> template <char const* U> struct make_unit { /* HOMEWORK */ };
02:08:33 <etb> error: '"Hello"' is not a valid template argument for type 'const char*' because string literals can never be used in this context
02:09:16 <Jafet> Your compiler sucks
02:09:28 <Jafet> I'm not sure if this works across TUs, though
02:10:07 <etb> gcc 4.7.0 lol?
02:10:37 <olsner> I think you can give it the address of an extern symbol
02:10:37 <etb> what compiler do you use?
02:12:11 <Jafet> http://farm4.staticflickr.com/3496/3994758072_8c05cbb55b.jpg
02:13:26 <Jafet> Okay, so you can only pass strings with extern linkage
02:13:35 <Jafet> So it will always work across TUs
02:13:49 <Jafet> C++, always protecting the programmer from mistakes
02:16:25 <etb> except failing :(
02:16:28 <etb> surely we can agree there
02:19:18 <etb> who said otherwise? it can't protect programmers from mistakes
02:45:34 <Sgeo> Is PLAI considered a good book?
02:47:45 <Sgeo> "and it makes the book a poor reference guide (you cant open up to a random page and be sure what it says is correct)."
02:47:51 <Sgeo> ^^from the book
02:48:33 <Bike> the programming langage book..... of lies
02:49:33 <Sgeo> "We will include mistakes, not because I dont know the answer, but because this is the best way for you to learn. Including mistakes makes it impossible for you to read passively: you must instead engage with the material, because you can never be sure of the veracity of what youre reading."
02:49:46 <olsner> Programming with Lies And Incorrectness
02:51:08 -!- DHeadshot has quit (Read error: Connection reset by peer).
02:56:44 -!- kallisti has quit (Ping timeout: 255 seconds).
02:57:59 -!- nooodl_ has quit (Ping timeout: 260 seconds).
03:02:20 <kmc> "Plain text is software and operating system agnostic. It’s searchable, portable, lightweight and easily manipulated.... Since it’s been around since the dawn of computing, it’s safe to say it’s completely future-proof."
03:02:21 <Sgeo> Racket's custodian stuff is pretty neat
03:02:53 <Bike> kmc: does that predate unicode or no?
03:03:14 <kmc> https://github.com/ginatrapani/todo.txt-cli/wiki/The-Todo.txt-Format
03:03:29 <Sgeo> kmc, well, in fairness, I think it is safe to say that if current models of text become outdated, there will be converters
03:03:43 <Sgeo> I'm sure there's EBIKLSJDFKLJSF->ASCII somewhere
03:03:50 <kmc> i don't think it would be any better if it predated Unicode
03:03:55 <kmc> there were many text formats back then
03:04:10 <Bike> of course not, was just curious if it was something in unix's design philosophy or whatever
03:04:32 <Bike> Sgeo: even better, there's unicode ebcdic.
03:04:57 <kmc> UTF-EBCDIC
03:05:03 <Bike> for dealing with the software that still uses ebcdic, of course.
03:05:07 <kmc> for the same reason as UTF-8 I expect
03:05:20 <kmc> "Its advantages for existing EBCDIC-based systems are similar to UTF-8's advantages for existing ASCII-based systems."
03:06:02 <kmc> anyway there's no such thing as "plain text", that concept only exists in the mind of english speakers :)
03:06:16 <Sgeo> Why does EBCDIC still exist?
03:06:27 <Bike> nah i'm pretty sure europeans or whoever don't actually need all those line dealies around their letters
03:06:27 <Sgeo> Next you'll tell me that COBOL programmers make a lot of money
03:06:48 <Bike> Sgeo: modern cobol is apparently a pretty good language, i've heard. used in banks and all
03:07:04 <Sgeo> The latter point does not support the former point.
03:07:26 <Bike> well, read "pretty good" as "better than what you imagine cobol to be based on horror stories from the 70s"
03:07:47 <Sgeo> Does it have non-global variables yet?
03:07:54 <Sgeo> (Actually, I think it does?)
03:07:56 <Bike> i think it's even object oriented
03:08:05 <Bike> anyway it's just the same as legacy anything, you may as well ask why English still uses "'s" to indicate the possessive
03:09:04 <Jafet> It's status's above reproach
03:09:36 <Bike> jokes are hard.
03:10:01 <NihilistDandy> I couldn't tell if it was intentional and that was the joke, or the right way was supposed to be the joke.
03:10:15 <Bike> it works either way! that's why it's a good joke.
03:10:30 <Bike> «"it's"'s status's above reproach», there, grammar
03:10:46 <Bike> except that doesn't actually mean the same thing! language is a trip
03:11:19 <kmc> there's a lot of code written for these mainframes
03:11:21 <kmc> it works fine
03:11:25 <kmc> it has had the bugs ironed out over decades
03:11:53 <kmc> open source and startup types want to rewrite everything from scratch every 2 years for fun
03:11:59 <kmc> but that's very much not how banks and the like work
03:12:01 <kmc> for good reason
03:12:09 -!- sebbu2 has joined.
03:12:28 <Bike> great now i'm going to be thinking of startup people in the same category that i put esperantists in
03:12:28 -!- sebbu2 has quit (Changing host).
03:12:28 -!- sebbu2 has joined.
03:13:34 <Sgeo> I no longer like Racket Custodians
03:13:39 <Bike> (but english is so illogical! "though"!!!)
03:14:02 <Sgeo> They error if you close one that's not managing anything
03:14:05 <kmc> also these 40 year old mainframes have features -- hard-core virtualization, fault tolerance, auditing, management, etc. -- that commodity PC hardware is only starting to catch up to
03:14:30 <Jafet> The best batch processing ever, dude
03:15:56 -!- DHeadshot has joined.
03:16:04 -!- sebbu has quit (Ping timeout: 260 seconds).
03:31:05 <DHeadshot> I should learn APL one of these days - it seems like a good idea from a historical perspective...
03:31:16 <kmc> startup types love to feel superior about how much more "agile" they are, but a lot of it comes down to different risk / reward structures
03:31:24 <kmc> nobody really cares if twitter is down for 2 minutes
03:31:37 <kmc> but if VISA is down for 2 minutes, or charges everyone $1 more than they should have, that's a big fucking deal
03:32:36 <kmc> so yeah I'm glad the banks aren't rushing out to rewrite everything in agile rails at a red bull fueled hackathon
03:33:35 <kmc> nuclear power plant software rewritten in node.js coffescript
03:33:39 <kmc> civilization collapses
03:33:57 <Bike> DHeadshot: it's pretty easy to find the book online.
03:34:29 <kmc> http://www.foo.be/docs/tpj/issues/vol2_1/tpj0201-0004.html "Perl and Nuclear Weapons Don't Mix"
03:35:31 <Jafet> http://www.theregister.co.uk/2012/06/08/us_navy_linux_drones/
03:35:45 <Bike> is this going to be a floating point thing
03:35:53 <kmc> Jafet: nice
03:36:06 <Bike> associativity, even better.
03:36:28 <kmc> i look forward to hackers taking over these drones using built-in support for the Econet protocol or the Rez Trance Vibrator
03:36:53 <Bike> terrorism's gonna get even more fun
03:37:08 <kmc> that's the plot of call of duty modern warfare 2
03:37:16 <Bike> don't remind me
03:37:18 <Jafet> That sounds better than UAV bombers with ILOVEYOU virus
03:37:22 <kmc> wait not that one
03:37:34 <kmc> black ops 2
03:37:35 <Bike> anyway, this guy assumed exponentiation is left associative? i thought everyone used it right associatively
03:37:44 <Bike> (where "everyone" = "people who seriously chain exponentiation")
03:37:51 <Fiora> "That's a big problem when your $a, or 2 * ($p - $p0) / $rho in my code, is about two million, your $b is 0.52, and your $c is 2. Perl ends up disagreeing with physics by a factor of more than four, and in such battles physics wins. This error went undetected as my Perl code was translated into C using the Perl Compiler, from C into machine code, and then was burned into missile EPROMs. Six weeks later, the missiles were interred in
03:37:52 <kmc> "Menendez is successfully captured, but this was a ruse for Menendez to hack into the U.S. military's computer infrastructure on the aircraft carrier the U.S.S. Obama, seizing control the the United States' entire drone fleet"
03:37:56 <kmc> bahahahaha
03:38:27 <kmc> "The US government can directly combine GPL and proprietary/classified software into a single program arbitrarily, as long as the result is never conveyed outside the U.S. government"
03:38:29 <Bike> "U.S.S. Obama"
03:38:33 <Bike> you're not serious
03:38:39 <kmc> cool, the US government has realized what Google and friends realized a long time ago
03:38:53 <kmc> which is that open source is great if you are a big org that can do all modifications in-house
03:39:58 -!- sebbu2 has quit (Read error: Connection reset by peer).
03:40:44 -!- sebbu has joined.
03:40:49 <Sgeo> I guess Haskell's =~ is also bad
03:40:53 <Sgeo> (Reading article now)
03:41:04 -!- sebbu has quit (Changing host).
03:41:04 -!- sebbu has joined.
03:41:27 <Bike> this reminds me a bit of that aritlce on NORAD's response to 9/11
03:45:54 <Sgeo> "Ray Piodasoll no longer works for NORAD in Colorado Springs, but occasionally writes articles intended to be published in April, toward the beginning of the month."
03:47:22 <lightquake> http://www.foo.be/docs/tpj/issues/vol3_1/tpj0301-0010.html
03:47:28 <lightquake> "For users with typing - aggravated injuries, the Perl Machine comes with three foot pedals, for $, @, and %."
03:50:10 <kmc> that's no joke
03:50:22 <kmc> my coworker has the 3 foot pedal add-on for the Kinesis contoured keyboard
03:56:46 <DHeadshot> A CyKey would make much more sense...
03:58:13 <kmc> skeptical of the claim that CyKey can be learned up to speed within a few hours
03:58:17 <kmc> but yeah, chording keyboards are cool
03:58:46 <DHeadshot> Or, y'know, a better programming language, given the limitations of scripting languages...
04:00:58 -!- tbc has joined.
04:02:27 <tbc> Any fans of the TV show Elementary here?
04:03:28 <NihilistDandy> Haven't watched it. I can't imagine it topping Sherlock.
04:05:26 <tbc> It's an interesting take on the Holmes character. I popped in here because Malbolge was part of the plot in the episode titled The Leviathan.
04:05:32 <kmc> is this a show where they solve mysteries but each episode also revolves around a particular element of the periodic table?
04:05:44 <kmc> i would watch that
04:05:54 <Bike> oh, hey, the malbolge thing was brought up here before
04:06:21 <tbc> Well, I googled it, found esolang.org, and popped in to say hi.
04:06:49 <tbc> I watched it on DVR, so i guess I'm behind.
04:06:56 <Bike> guh, bots are hard.
04:07:02 <tbc> Thanks, Bike.
04:07:16 <HackEgo> tbc: 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. (For the other kind of esoterica, try #esoteric on irc.dal.net.)
04:07:55 -!- elliott has joined.
04:08:03 <Bike> i wonder if getting onto BBC constitutes deployment
04:08:08 <elliott> i hear someone watched that malbolge episode
04:08:35 <tbc> Hey, elliott.
04:09:22 <elliott> I should grep the wiki logs to see if I can find out where the people behind it looked at the article on Malbolge, assuming they used the wiki
04:10:10 <Bike> did they actually use information they couldn't have just guessed from the wikipedia article?
04:10:19 <tbc> Might be hard to correlate.
04:10:28 <monqy> well malbolge is--yes it's ``notable'' enough to have a wikipedia article
04:11:46 <elliott> I think the wikipedia article is a bit copied from ours
04:11:49 <tbc> Grr. I already deleted the episode. I should have transcribed the frame where they showed a fragment of a Malobolge program. It was a romping story.
04:12:02 <monqy> https://en.wikipedia.org/wiki/Category:Non-English-based_programming_languages wow what a list
04:12:05 <kmc> wikipedia says it's the hello world program from wikipedia
04:12:08 <kmc> with some arbitrary changes
04:12:09 <zzo38> tbc: Do you remember some about it?
04:12:19 <Bike> thanks, wikipedia
04:12:21 <elliott> I should actually watch that I guess
04:12:31 <tbc> zzo38 about the episode, you mean?
04:12:50 <tbc> I just finished watching it. Why do you ask?
04:12:53 <Bike> «Hindawi Programming System (hereafter referred to as HPS) is a suite of open source programming languages. It allows non-English medium literates to learn and write computer programs.» "literates"
04:13:13 <monqy> https://en.wikipedia.org/wiki/Fj%C3%B6lnir_(programming_language) an exciting new world of programming languages i cant read
04:13:35 <Bike> "HPS uses Romenagri transliteration to first convert the high level source code into a compiler acceptable format and then uses an existing compiler to produce machine code." ...transliteration?
04:13:37 <zzo38> tbc: Because I am curious what they did with malbolge.
04:16:20 <tbc> zzo38 to summarize: The story was about a copycat breakin to a high security vauilt called Leviathan. Malbolge was the original mastermind's choice for cracking the RNG portion of the vault's secuirty system. Total Hollywood. But it made me curious about Malbolge. Other than the fact that the language is impractical, they did a decent job of representing it.
04:17:39 <tbc> It only played a small part of the plot. But crucial. Relied on a software engineer recognizing a Malbolge program printed on a scrap of paper.
04:18:32 <tbc> A good excuse to watch the episode. I'd never heard of the language or esolang.org. So I'm glad I dropped by.
04:18:36 <tbc> (Here, I mean.)
04:18:48 <Bike> i'm not sure how anyone could reliably distinguish malbolge from line noise (not that line noise is really produced anymore)
04:19:14 -!- NihilistDandy has quit (Ping timeout: 252 seconds).
04:19:48 <tbc> Bike, Holmes even made a reference to the crypic nature of the language. Maybe the writers googled "cryptic programming language."
04:20:26 <zzo38> I have seen an article about esoteric programming in some magazine.
04:20:41 <Bike> tbc: heh, intercal is the fourth result for that on google.
04:21:08 <zzo38> My own esolangs seem to be mentioned only in Japanese, somehow.
04:21:42 <Bike> with quotes, it's LOLCODE. glad they didn't go with that
04:21:48 * tbc is using webchat on an iPad and begs forgiveness if his connection goes stale while he shifts focus to another browser tab
04:21:55 <Bike> ooh, and Kvikkalkul, gotta dig that
04:22:34 <zzo38> I like INTERCAL and Kvikkalkul too.
04:25:28 <Sgeo> #' is the functor of the Lisp world.
04:26:02 <Bike> what on earth does that mean
04:26:20 <Sgeo> Every Lisp and its mother uses #' to mean something unrelated from what other Lisps use it for
04:26:32 <Bike> what's racket use it for?
04:26:49 <Sgeo> #'(+ 1 2) is (syntax (+ 1 2)) which is a syntax object
04:27:12 -!- sebbu2 has joined.
04:27:31 -!- sebbu2 has quit (Changing host).
04:27:31 -!- sebbu2 has joined.
04:27:40 <tbc> Fascinating. I've never had occasion to use #' in Emacs Lisp.
04:27:50 <Sgeo> <technomancy> Sgeo: elisp uses it to mean "hey everyone, I'm a CL programmer who either doesn't understand that this doesn't do anything in elisp or wants to vaguely protest that fact."
04:27:50 <tbc> FWIW, a few fans twittered about Malbolge this week in connection with Elementary.
04:28:12 <Bike> oh, right, elisp doesn't have reder macros.
04:28:27 <elliott> doesn't the iPad keep tabs properly or something
04:28:33 <elliott> I thought it was just the iPhone browser that was awful at that
04:28:37 <Bike> also, how do you use "functor" for something unrelated, it has a pretty straightforward definition
04:29:03 <Sgeo> Bike, in Prolog, in a term like foo(1, 2), the functor is foo
04:29:21 <shachaf> It's like FUNCTion -- OR is it?
04:29:29 <Sgeo> In Standard ML, it's something to do with the module system, I think, I'm not really sure
04:29:29 <elliott> Bike: ML uses "functor" for "module function"
04:29:32 <tbc> ellliott, I've found Safari on iPad to lose its mind on a regular basis. Bad caching algorithm, IMO. But so far so good. I've been able to jump around and still stay connected.
04:29:39 <elliott> C++ uses it for, um, "closure", more or less
04:29:53 -!- sebbu has quit (Read error: Operation timed out).
04:29:54 <Bike> well, that sucks
04:30:00 <shachaf> "things that have operator()"
04:30:17 -!- glogbackup has quit (Remote host closed the connection).
04:31:35 <Sgeo> Haskell functions are functors too! See how much C++ and Haskell have in common?
04:32:04 <zzo38> Shouldn't a functor be, a homomorphism from one category to another (possibly same one)?
04:36:43 -!- sebbu has joined.
04:37:03 -!- sebbu has quit (Changing host).
04:37:03 -!- sebbu has joined.
04:38:58 -!- tbc has quit (Quit: Page closed).
04:40:04 -!- sebbu2 has quit (Ping timeout: 260 seconds).
04:40:18 -!- glogbackup has joined.
04:44:08 -!- tbc has joined.
04:44:49 * tbc finds the limit to iPad Safari's buffering
04:45:20 <Bike> zzo38: apparently it's not always!
04:45:50 <tbc> Yeah, I had a lot of tabs open. Switched to Chrome now. Hoping that helps. I like to multitask. iPad is wrong platform for me. :)
04:54:16 <tbc> Well, capping off my fascination, http://www.google.com/search?q=malbolge+sherlock points to some good chatter. The first search result includes a screenshot from the show. They just reproduced the hello, world program. Fun.
04:58:10 <elliott> hm, I wonder if Ben Olmstead (the language's inventor) knows
05:00:15 <Sgeo> Racket languages aren't very composable, are they?
05:00:16 <tbc> kmc, I red the log. I didn't see your comment about Wikipedia until now.
05:00:27 <Sgeo> What if I want to use two features from two languages at the same time
05:00:46 <monqy> what does "feature" mean here
05:01:00 <Bike> clearly you need composition-friendly pseudomonadic interpreters
05:02:25 -!- tbc has quit (Quit: Page closed).
05:02:39 <Sgeo> Someone actually implemented Racket-style macros in Clojure I think
05:36:13 -!- copumpkin has quit (Ping timeout: 252 seconds).
05:36:34 -!- NihilistDandy has joined.
05:36:51 -!- copumpkin has joined.
05:49:11 -!- kallisti has joined.
05:55:32 -!- tbc has joined.
05:56:48 -!- tbc has quit (Client Quit).
05:57:00 <kmc> i don't like racket's macros
05:57:05 <kmc> but i have not used them much
05:57:21 * Sgeo still doesn't have a strong grasp of hygienic macros in general
05:57:33 <Sgeo> And am a bit uncertain of how Racket macros differ from typical Scheme macros
05:58:13 -!- tbc has joined.
05:58:21 <kmc> i guess there are two layers
05:58:57 <kmc> the bottom layer lets you manipulate programs as data, but it's fairly cumbersome because the quotation captures lexical scope and other stuff
05:59:10 <kmc> the upper layer is a variety of DSLs to make common macros easier to write
05:59:27 <kmc> i don't like the bottom layer because it's cumbersome and I don't like the top layer because it defeats nearly the entire point of lisp
05:59:28 -!- tbc has quit (Client Quit).
06:00:10 <Bike> racket has backquote, doesn't it?
06:00:13 -!- sebbu has quit (Read error: Connection reset by peer).
06:00:14 <Sgeo> Well, only having the top layer but not the bottom layer would me more Lisp-defeaty
06:00:23 <kmc> Bike: yeah
06:00:24 <Sgeo> So the bottom layer should be made more ... convenient somehow
06:00:37 -!- sebbu has joined.
06:00:38 -!- sebbu has quit (Changing host).
06:00:38 -!- sebbu has joined.
06:00:39 <Bike> hm, so what do you mean by "cumbersome" exactly?
06:01:04 <kmc> well a macro is not supposed to return a naked lisp-style list of symbols and such
06:01:07 <kmc> it's supposed to return a syntax object
06:01:15 <kmc> http://docs.racket-lang.org/guide/stx-obj.html
06:01:32 <kmc> which is a more complicated thing that captures a source location and a lexical scope as well
06:01:36 <kmc> and that's how it manages hygeine
06:01:40 <Bike> oh, makes sense
06:02:21 <kmc> that's what this #' syntax gives you
06:02:27 <kmc> i assume there is #` as well, but have not seen it
06:02:47 <kmc> now as it happens Racket does support Lisp-style unhygenic macros, but it's not the preferred system
06:04:03 <kmc> my tentative opinion is that it's not that difficult to maintain hygeine with "unhygenic" macros
06:04:09 <kmc> and they are much simpler to understand
06:04:32 <kmc> and they give you a very direct way to do unhygenic things when that's what you want
06:04:53 <Bike> yeah, i don't think i've really wanted hygenic macros except for one time
06:05:19 <kmc> you need some kind of auto-gensym syntax, which should be in the standard library but is easy enough to implement as a macro, anyway
06:05:34 <Bike> but, and maybe this is just me being naïve, from this article it seems like it'd be pretty easy to make a defmacro wrapper that lets you return lisp-style but wraps it properly in a syntax object
06:05:51 <kmc> yeah i'm not sure
06:06:44 <kmc> i prefer operatives to all of this, but they're pretty far out experimental tech
06:06:50 <kmc> especially as far as efficient implementation goes
06:06:52 <Bike> i can see why you'd want syntax objects, though, I know CL systems have all kinds of weirdness to allow source context information and "de-macrotizing" for debugging
06:07:13 <kmc> here is my little writeup about it: http://mainisusuallyafunction.blogspot.com/2012/04/scheme-without-special-forms.html
06:07:19 <kmc> with links to other stuff
06:07:47 <Bike> i should try implementing kernel again but this time take efficiency more seriously
06:07:49 <kmc> lexically scoped fexprs
06:08:21 <Bike> and i suppose read his thesis instead of just the "standard"
06:08:34 <kmc> i read part of the thesis
06:08:42 <kmc> it's pretty long and rambly though ;P
06:08:46 <Bike> is it about vau?
06:08:58 <kmc> maybe i can implement kernel in pypy and it will magically be fast
06:09:13 * Sgeo goes to read http://www.reddit.com/r/Racket/comments/13cdy9/fear_of_macros_a_macro_tutorial/
06:09:32 <Bike> well, i'm not sure how you'd implement it fast, really. compilation i don't even know how i'd start, and having the lexical environment available arbitrarily seems like it'd inhibit a lot of optimizations
06:09:49 <kmc> handwave JIT compiler
06:09:58 <kmc> in a JIT your optimizations don't need to be sound in general, just in the common case
06:10:10 -!- sebbu2 has joined.
06:10:11 -!- sebbu2 has quit (Changing host).
06:10:11 -!- sebbu2 has joined.
06:10:24 <kmc> for example if somebody modifies an environment, you can just throw out compiled code
06:10:43 <Bike> mm, hadn't thought if it that way
06:11:02 <kmc> a good JIT could really kick some ass even on static languages
06:11:28 <kmc> dynamically optimizing for the common case, with stronger assumptions than any static compiler can make
06:11:41 <kmc> you can make those assumptions and then perform constant folding, inlining, dead-code elimination, etc
06:12:09 <kmc> PyPy is based on the observation that an interpreter running inside a tracing JIT sort of magically becomes a tracing JIT itself
06:12:09 <Bike> obviously my compiler powerlevel is not yet high enough :(
06:13:48 <Fiora> you can do a lot of those "optimizations based on the common case" without a JIT too though
06:13:57 <Fiora> like that optimization where you branch based on whether pointers alias or not, with the common case being they don't
06:13:59 -!- sebbu has quit (Ping timeout: 260 seconds).
06:14:02 <Fiora> letting the compiler assume they don't alias even though they could
06:14:27 <kmc> for high-level dynamically typed languages, there will be a huge number of paths though
06:14:29 <Bike> kmc: hm, you say you have a cleaner alternative to quote, do you mean eval in operatives everywhere?
06:15:06 <kmc> like all the different types each argument to a function could take
06:15:22 <kmc> Bike: what do you mean?
06:16:03 <Fiora> I suppose you could use a profiler to figure out the most common types for a non-JIT compiler?
06:16:09 <Fiora> but yeah, JIT seems convenient there
06:16:52 <Bike> kmc: "As it happens, quote is used sparingly in Qoppa. There is usually a cleaner alternative, as we'll see."
06:17:04 <Bike> and then "we selectively evaluate using eval, rather than selectively suppressing evaluation using quote."
06:17:34 <Bike> i suppose that does help destroy the hygeine problem though
06:18:54 <kmc> well you don't need quote because you aren't returning code
06:19:11 <kmc> operatives can do the wacky things that macros do, but in a dynamic and direct way, rather than by generating code
06:19:29 <kmc> of course if you want macros you can build them pretty easily
06:19:56 <kmc> operatives are basically hygenic because, since you're not generating code, you're not generating variable names
06:20:07 <Bike> but the reason i tripped up on compiling it was because with macros, that's just a preprocessor, so the compiler only has to special-case special forms (and a few other forms like function calls)
06:20:18 <kmc> there's a big difference between "a list with the symbol 'map' in it" and "a list with the value of the operative we currently call 'map' in it"
06:20:24 <Bike> but with operatives i'm not sure how you could do anything at compile time
06:20:38 <elliott> well, constant folding and inlining
06:20:54 <kmc> handwave magic JIT compiler
06:20:59 <Bike> stop handwaving gah
06:21:08 <kmc> i think a static compiler for an operative-based language would be a really bad idea
06:21:14 <elliott> that's what we do in pl research
06:21:19 <kmc> especially given how JITs are kicking ass in various other fields
06:21:29 <zzo38> I want to make the second C preprocessor with various purposes including that it will delete duplicate definitions, move things out that belong out, make pool strings, and to allow a definition of an object in one place having it to move everything around to the right places for it to do that (for example: lists, functions, name, enum, struct members, etc)
06:21:54 <Bike> greh, it just seems like you ought to be able to do something statically. but i hardly know anything about jits so i'm just in the past probably
06:22:02 <kmc> would you write a static compiler for Lua or JavaScript?
06:22:08 <kmc> sure, you could
06:22:14 <kmc> i don't think it would be that useful
06:22:21 <kmc> i also know hardly anything about JITs
06:22:31 <kmc> i know just enough to be pretty sure that they are the right answer here
06:23:18 <Bike> guess i'll make it even more of a learning experience then
06:23:42 <Fiora> I only know a little about JITs for emulation really which is kinda different
06:23:49 <Fiora> and has slightly more obnoxious speed constraints usually
06:24:12 <Bike> do angry java clients count as obnoxious speed constraints
06:26:14 <kmc> nice somebody already did it in PyPy: https://github.com/timfel/qoppy
06:26:23 <kmc> http://blog.bithug.org/2012/08/qoppa
06:27:22 <zzo38> $macro(linkedlist,x) $type(t) typedef struct t { x data; struct t*next; } t;
06:27:38 <kmc> it's cool that something i made made its way into a talk that was given in berlin
06:27:49 <kmc> berlin is a cool city and this raises my own coolness by transitive property
06:27:50 <zzo38> Would this be OK to you?
06:27:53 <Bike> i'm afraid the misplaced apostrophe has replaced any interest with blind hatred
06:28:20 <elliott> Bike: you should chill and stop caring about that s'tuff
06:28:22 <kmc> they're probably german
06:28:25 <elliott> i did it made my life much better
06:28:31 <elliott> you'll say thank's elliott
06:28:37 <Bike> thank's elliot
06:28:42 <Bike> speaking of which homestuck updated
06:35:51 <kmc> it is mine yeah
06:36:27 <coppro> is it just me or does the qoppa article on wikipedia read like zzo38 wrote it?
06:36:41 <Bike> what, on the letter?
06:36:45 <kmc> maybe i should drop out of society and become an anarcho-crypto-punk-hacker-homeless-bum in berlin
06:36:58 <Bike> but hagb4rd is already here
06:37:08 <kmc> my entirely fair perception is that roughly one out of every five structures in berlin is a hackerspace or a new media art collective
06:37:22 <kmc> so presumably i can find places to stay
06:37:51 <kmc> coppro: i don't see it
06:38:36 <kmc> shachaf: oh, yesterday was the 100th birthday of MUNI!
06:38:51 <elliott> why is there a qoppa article on wikipedia
06:38:58 <kmc> it's a greek letter
06:39:08 <elliott> i thought somehow kmc's language was ~notable~
06:39:44 <kmc> "With only two bucks and a bit of patience, you can hop on some combination of buses, trains and streetcars"
06:39:49 <kmc> uh, all of the trains are streetcars
06:40:03 <Bike> now i'm wondering if anyone's actually made a language called "lambda"
06:40:11 <kmc> maybe it only counts as a streetcar when it's in the street
06:40:12 <NihilistDandy> Sometimes I accidentally click the Simple English Wikipedia link without realizing it and wonder what the hell has happened to it.
06:40:46 <Bike> ooh it can be named after the phage
06:42:25 <NihilistDandy> Bike: Make a theorem prover in Unlambda, call it Ununlambda, and let logic work it out.
06:43:07 <Bike> psh, classical logic
06:46:16 <Bike> «The background chapters also concern themselves not only with how programming languages specify computations (semantics), but with how programming languages influence the way programmers think (psychological bias)» is this what you meant by "rambling", kmc
06:46:32 <kmc> i don't remember which part was rambly, just that i had that impression
06:46:49 <kmc> there's a lot of cool stuff in there, don't get me wrong
06:47:13 <Bike> no i know, i just don't think i want to hear programming people talk about psychological anything too much
06:47:21 <kmc> call it ununnilium
06:47:41 <kmc> Bike: yeah there is the danger of programmers assuming we are experts in everything
06:48:41 <kmc> but it's also easy to lose sight of the fact that practical programming language design is a human-computer interaction problem
06:48:50 <kmc> so maybe some of that perspective is nice
06:48:59 <elliott> what is bike's quote a quote from
06:49:07 <Bike> jshutt's thesis
06:49:44 <Bike> kmc: maybe i'm just cynical wrt programming language designers' ability to solve hci problems
06:50:33 <elliott> cynical wrt programming language designers's ability to solve programming language design problems
06:52:29 <kmc> it does seem that there is something of a disconnect between the people who are obsessed with minor syntactic tweaks to JavaScript and the people who are obsessed with strange theoretical constructs nobody understands
06:52:44 <kmc> you need these groups to get along to make a good language, i think
06:53:08 <kmc> one of the things I like about Haskell is that it gets a lot of "minor" usability things right
06:53:11 <monqy> i dont think i'd be able to get along with anyone obsessed with minor syntactic tweaks to javascript
06:53:15 <kmc> in my untrained opinion
06:53:41 <Bike> monqy: and thus we come to the heart of the problem.
06:53:45 <elliott> i can happily state i will never get along with people who are obsessed about minor syntactic tweaks to javascript
06:53:56 <kmc> and they actually aren't that minor because they are a large part of what makes the language nice to use
06:54:11 <kmc> even if they have nothing to do with purity or monads or whatever
06:55:00 <monqy> nice to use for syntax obsessives!!!!
06:56:21 <Bike> maybe i should just adopt the attitude i have towards spoken language design, and wait for C to grow hylomorphisms by itself
06:57:15 <kmc> like leaving food at the back of the cupbord to see what kind of fungus grows on it
06:57:34 <Bike> i happen to like fungi! so that all works out nicely
06:59:04 <monqy> leave javascript at the back of the cupboard so it grows a syntax i like(maybe some semantics too???)
06:59:18 -!- Bike has quit (Quit: sleep).
06:59:37 <kmc> oh bike left before i could geek out about fungi
07:00:08 <shachaf> monqy: do you like making space leaks go away in haskell
07:00:18 <elliott> kmc: missed connections time
07:00:38 <shachaf> foo xs = evalState (traverse (\d -> do { _ <- get; return d }) xs) () -- doesn't leak
07:00:41 <shachaf> foo xs = evalState (traverse (\d -> do { !_ <- get; return d }) xs) () -- leaks
07:00:58 <monqy> yes you can use the first
07:01:42 <shachaf> The real code has an input list as a state.
07:01:53 <kmc> give up and use deepSeq
07:02:01 <kmc> the opposite of that
07:02:08 <shachaf> And each action takes one element off the input list and returns it.
07:02:14 <shachaf> So it has to be state-strict.
07:03:13 -!- asiekierka has quit (Excess Flood).
07:03:21 <monqy> Q: why are you asking me
07:04:08 <shachaf> A: you seem like an expert
07:06:13 -!- asiekierka has joined.
07:06:32 <monqy> ????????????????????
07:11:01 <shachaf> monqy: are you an expert in corepresentable profunctors too
07:12:39 <shachaf> That COMBINING DIAERESIS didn't even COMBINe.
07:14:21 <Jafet> AUTHENTIC DECOMMISSIONED MUSEUM QUALITY DIAERESIS
07:15:41 <shachaf> A Unicode codepoint ought to be able to use all the previous codepoints in its name.
07:15:52 <Jafet> THE HOSPITAL SURPRISE ME WITH DIAERESIS
07:17:39 * Sgeo takes back his anger at Racket custodians. The documentation was poorly worded.
07:28:14 <kmc> shachaf: are the names ASCII in reality?
07:28:43 <Gregor> I think they're ALL UPPER CASE ENGLISH LETTERS PLUS SPACES AND HYPHENS
07:29:07 <zzo38> I think there is "LOW-9" though, is one of the names using digits
07:29:24 <shachaf> Gregor: HYPHEN-MINUSes, you mean.
07:29:32 <zzo38> But most is not using digits.
07:29:54 <Sgeo> http://lists.racket-lang.org/dev/archive/2012-December/011373.html
07:30:15 <ion> Almost all fonts render the HYPHEN-MINUS as a hyphen.
07:30:30 * shachaf isn't sure how they're supposed to be specified.
07:30:48 <shachaf> ion: The thing about HYPHEN-MINUS is that there's a dash between the HYPHEN and the MINUS.
07:30:57 <ion> HYPHEN DASH MINUS
07:31:09 <ion> HYPHEN HYPHEN-MINUS MINUS
07:31:18 <ion> damn, there’s still a HYPHEN-MINUS in the middle.
07:31:25 <ion> HYPHEN HYPHEN HYPHEN-MINUS MINUS MINUS
07:31:45 <shachaf> HYPHEN HYPHEN HYPHEN HYPHEN HYPHEN HYPHEN HYPHEN HYPHEN MINUS MINUS
07:32:03 <Jafet> When they finish decoding the hieroglyphs, we might have a BOULDER DASH.
07:32:28 <shachaf> http://www.inference.phy.cam.ac.uk/cjb/codepoints.html
07:33:25 -!- Nisstyre-laptop has joined.
07:34:00 <Jafet> "In 2007, four Apache helicopters were destroyed on the ground by Iraqi insurgent mortar fire; the insurgents had made use of embedded coordinates in web-published photographs (geotagging) taken of the helicopters by soldiers."
07:34:21 <ion> Lenticular brackets! Lens should use these. 【 】 〖 〗 ︗ ︘ ︻ ︼
07:39:15 <kmc> Jafet: haha wow
07:42:33 <shachaf> The two planes 15 and 16, called Supplementary Private Use Area-A and -B (or simply Private Use Area (PUA)) are available for character assignment by parties outside the ISO and the Unicode Consortium. They are used by fonts internally to refer to auxiliary glyphs, for example, ligatures and building blocks for other glyphs. Such characters will have limited interoperability. Software and fonts that support Unicode will not necessarily ...
07:42:39 <shachaf> ... support character assignments by other parties.
07:43:57 -!- epicmonkey has joined.
07:55:31 <kmc> i read that ISO 10646 initially allocated some private use areas in the range beyond Unicode
07:55:47 <kmc> #fail #wtf #iso10646facts
07:57:18 <shachaf> I would join #iso10646facts if it was a real channel.
07:58:41 <shachaf> kmc: How's your web-based IRC replacement thing?
08:01:54 <shachaf> λ> :t let fromInteger = id in 5
08:01:59 <kmc> shachaf: it's going
08:02:19 <kmc> we have various groups using it
08:02:30 <kmc> it's not widely available yet
08:04:57 <quintopia> Jafet: we can already make a BOLDER DASH
08:06:55 <shachaf> kmc: Does your laptop have "nvidia optimus"?
08:30:38 -!- epicmonkey has quit (Ping timeout: 255 seconds).
08:31:32 <zzo38> In this Dungeons&Dragons game, the candles lit fire much bigger, but we managed to escape through a hole into the next room, with tables where some people were playing cards. I have several idea what to do next; do you know?
08:34:17 <zzo38> That was one of my ideas but I have other things which I can do first.
08:34:23 <zzo38> I already prevented the door from opening.
08:34:59 <kmc> shachaf: no
08:35:16 <kmc> it has "intel adequacy"
08:35:19 <zzo38> I intend to use "Control Sound", to make the screaming in the room with the fire.
08:35:41 <shachaf> kmc: I wish I had "intel adequacy" :-(
08:35:49 <kmc> what do you have?
08:46:44 <Sgeo> What happens when I want to mix the laziness of Racket's lazy language with the static typing of Typed Racket?
08:47:08 <shachaf> Maybe #clojure would know.
08:51:54 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
08:53:42 -!- Taneb has joined.
08:57:53 -!- zzo38 has quit (Remote host closed the connection).
09:14:39 -!- DHeadshot has quit (Ping timeout: 244 seconds).
09:16:08 -!- DHeadshot has joined.
09:29:17 -!- sebbu has joined.
09:29:35 -!- sebbu has quit (Changing host).
09:29:36 -!- sebbu has joined.
09:30:51 -!- sebbu3 has joined.
09:31:08 -!- sebbu3 has quit (Changing host).
09:31:09 -!- sebbu3 has joined.
09:32:54 -!- sebbu2 has quit (Ping timeout: 260 seconds).
09:34:39 -!- sebbu has quit (Ping timeout: 260 seconds).
09:47:24 -!- Nisstyre-laptop has quit (Ping timeout: 250 seconds).
10:02:20 -!- epicmonkey has joined.
10:17:45 <coppro> I wanted to get a book on english grammar so I asked a finn
10:21:32 <coppro> it's a goron smiley face, duh
11:03:03 -!- monqy has quit (Quit: hello).
11:17:03 -!- buffer has joined.
11:22:56 -!- sebbu3 has changed nick to sebbu.
11:32:27 <Sgeo> kmc, Racket's defmacro does basically take the sexp->sexp function and wrap it around syntax->datum and ... the other direction
11:39:12 -!- WeThePeople has quit (Ping timeout: 250 seconds).
11:39:50 -!- kallisti has quit (Ping timeout: 244 seconds).
11:54:50 <coppro> "Heavy water is the only known chemical substance that affects the period of circadian oscillations, consistently increasing the length of each cycle. The effect is seen in unicellular organisms, green plants, isopods, insects, birds, mice, and hamsters."
11:59:23 <Jafet> What are you buffer than?
12:01:13 -!- nooodl_ has joined.
12:08:18 -!- AnotherTest has joined.
12:10:28 <Sgeo> Being able to change the semantics of function application sounds fun
12:25:33 -!- buffer has changed nick to dalai.
12:28:08 -!- dalai has left.
13:33:06 -!- Taneb has quit (Quit: Leaving).
13:37:55 <mroman> For any sets a,b,c: if (a n b) != 0 ^ (a n c) != 0 ^ (b n c) != 0 can one conclude (a n b n c) != 0 (n = intersection, 0 = empty set)?
13:39:56 <lambdabot> Data.IntMap intersection :: IntMap a -> IntMap b -> IntMap a
13:39:56 <lambdabot> Data.IntSet intersection :: IntSet -> IntSet -> IntSet
13:39:56 <lambdabot> Data.Set intersection :: Ord a => Set a -> Set a -> Set a
13:42:07 <elliott> No instance for (Arbitrary (Set a0))
13:43:35 <elliott> mroman: quickcheck is unable to disprove that statement, at least
13:44:46 <elliott> let's see. say (intersection a b) has element x. then if (intersection b c) has element x, then so does intersection a (intersection b c)
13:45:17 <elliott> if (intersection b c) does not have element x, then c does not have element x (since we know b does)
13:45:46 <elliott> yet I think this cannot be true for *all* x
13:45:51 <elliott> otherwise (intersection a b) would be empty
13:46:18 <elliott> mroman: um, I'm too tired.
13:46:28 <elliott> ask anyone who isn't sleep deprived and they'll tell you the trivial answer
13:49:42 <AnotherTest> because (a n b) ^ (a n c) = (a ^ b) ^ (a ^ c)
13:51:12 * elliott doesn't see why a ^ b ^ a ^ c couldn't be 0 there.
13:51:27 <elliott> (as in, I doubt your specific reasoning, not the conclusion)
13:51:48 <AnotherTest> well I proved a n b n c = (a n b) ^ (a n c)
13:52:04 <AnotherTest> if (a n b) is not the empty set and (a n c) is not the empty set
13:52:20 <AnotherTest> then (a n b ) n ( a n c) is not the empty set
13:52:31 <elliott> that's certainly not true in general
13:52:55 <elliott> a = {1,2,3,4,5,6}, b = {1,2,3}, c = {4,5,6}
13:52:59 <elliott> (a n b) n (a n c) is empty
13:53:03 <elliott> but (a n b) is not and (a n c) is not
13:53:29 <elliott> of course, this violates the prerequisites for mroman's statement
13:53:41 <elliott> but I don't really see how your logic follows, still
13:53:49 <elliott> but I am way too tired to be thinking about anything involving more than one symbol
13:54:16 <AnotherTest> Oh I only saw half of his if statement ((a n b) != 0 ^ (a n c))
13:56:40 <elliott> mroman: a={AB,AC}, b={BC,AB}, c={BC,AC}
13:58:47 * elliott saw no requirement on length in mroman's question
13:58:50 <elliott> I provided a counterexample
13:59:36 <elliott> maybe there is no counter-example of length three though
13:59:44 <elliott> whatever length three means (could be an exists or forall)
14:00:06 <elliott> a={AB,AC,JUNK1}, b={BC,AB,JUNK2}, c={BC,AC,JUNK3}
14:01:23 <mroman> then they all have one common element?
14:01:35 <elliott> mroman: well that's exactly what it says...
14:01:44 <elliott> intersection of a, b, c: set of elements that appear in a, b and c
14:01:50 <elliott> you are saying there is at least one element of this set
14:01:54 <elliott> and hence at least one element that appears in a, b and c
14:02:00 <mroman> If the all have a common element
14:02:06 <mroman> then that element must be in a in b and in c
14:02:16 <mroman> so it is also in (a n b)
14:02:20 <mroman> and it is also in (b n c)
14:02:27 <elliott> yes, you're going backwards though
14:02:32 <elliott> you're deriving your premises from your conclusion
14:03:45 <AnotherTest> a n b n c = 0 <=> (a n b) n c = 0 => (a n b) != c
14:03:45 <AnotherTest> a = {1} b = {1} and c = {0} then a n b n c = {}
14:03:52 <elliott> you will find (_|_ -> p) vastly easier to prove than (p -> _|_) for many p
14:04:24 <elliott> @tell oerjan when you read the logs: i'm sorry it took me to so long to find that obvious counterexample. please don't swat me
14:06:29 <mroman> Let's assume (a n b) = x, (a n c) = y, (b n c) = z
14:06:39 <mroman> then c contains at least {y,z}
14:06:50 <mroman> a contains at least {x,y}
14:06:51 -!- ais523 has joined.
14:06:58 <mroman> and b contains at least {z,x}
14:08:07 <mroman> > (intersect (intersect [1,2] [1,3]) [2,3])
14:08:31 <mroman> > intersect [1,2] [1,3]
14:08:41 <mroman> > intersect [1,2] [2,3]
14:08:50 <mroman> > intersect [1,3] [2,3]
14:09:07 <mroman> That'd be a counter example?
14:09:16 <ais523> !bfjoust anticipation2 http://sprunge.us/NAHZ
14:09:20 <ais523> let's hope it fits within the size limit
14:09:27 <EgoBot> Score for ais523_anticipation2: 0.0
14:09:40 <ais523> Gregor: what /is/ the size limit for egojoust, anyway?
14:09:47 <ais523> it'd be way shorter if I had an if statement, but I don't :(
14:10:03 <ais523> oh: "parse error: maximum [] nesting depth exceeded"
14:10:14 <ais523> didn't hit size limit, hit something else
14:10:29 <elliott> mroman: that's just my example
14:10:34 <AnotherTest> well, it seems like there is a nesting depth limit
14:10:41 <fizzie> ais523: That limit's 256.
14:10:52 <ais523> I only go /slightly/ over 256
14:11:00 <ais523> is there any particular reason why the limit's there?
14:11:47 <mroman> That's very unfortunate :(
14:11:50 <fizzie> ais523: I don't recall. Possibly not anything that would count. Fixed-size arrays for matching things in the parser.
14:12:08 <ais523> well it's annoying to have a really good program and having to butcher it to fit it on the hill
14:13:05 <fizzie> ais523: I could fix that right now, but it would probably take time (and a Gregor) to get it into the thing.
14:13:30 <ais523> OK, ten of the [] aren't used
14:13:46 <ais523> !bfjoust anticipation2 http://sprunge.us/FjPS
14:13:51 <EgoBot> Score for ais523_anticipation2: 56.5
14:14:47 <ais523> now I just have to come up with more good programs that beat space_hotel, to push it into first ;)
14:16:13 <ais523> !bfjoust this_sort_of_thing_is_done_so_often_it_doesnt_do_so_well_nowadays <
14:16:15 <EgoBot> Score for ais523_this_sort_of_thing_is_done_so_often_it_doesnt_do_so_well_nowadays: 0.0
14:18:27 <ais523> not edging above space_hotel on the leaderboard is annoying
14:18:33 <fizzie> http://sprunge.us/TMGZ well that's not good.
14:18:41 <fizzie> I think it might've been because of your <.
14:19:00 <ais523> shall I put that program back?
14:19:13 <fizzie> I think I'll just fix whatever it broke.
14:19:17 <ais523> !bfjoust this_sort_of_thing_is_done_so_often_it_doesnt_do_so_well_nowadays >>>>(+)*20(<(+)*90)*4(>)*8(>[(+)*20[-]])*21
14:19:20 <EgoBot> Score for ais523_this_sort_of_thing_is_done_so_often_it_doesnt_do_so_well_nowadays: 23.2
14:19:28 <ais523> it's not a very good program and I was just using it as an example
14:20:05 <ais523> I'm pretty pleased with anticipation2
14:20:14 <ais523> and I'd love to get the chance to explain it to quintopia or someone
14:20:22 <ais523> hmm… I'll put the program that generates it on the wiki
14:21:41 <fizzie> "And the explanation had better be good."
14:21:53 <ais523> http://esolangs.org/wiki/User:Ais523/anticipation2.pl
14:22:05 <ais523> so, basically, it's an intelligent defence program
14:22:37 <ais523> it starts with a complex decoy setup
14:22:43 <ais523> to make sure it gets to its tripwires before the opponent does
14:22:50 <ais523> for short tapes, there's a couple of reverse tripwires
14:23:12 <ais523> if the opponent gets to them before decoy setup is complete, it changes to shudderlock's strategy
14:23:25 <ais523> and just tries to lock+clear; it works against quite a few programs on short tapes
14:24:17 <ais523> more usually, what it's trying to do is to set up a vibration on its flag
14:24:29 <ais523> so that the flag is 0 at the exact moment the opponent tests it for the first time
14:25:02 <ais523> the way it measures is to rely on the fact that the vast majority of programs do either + or - on the cycle immediately after their [ to check if the cell is 0
14:25:13 <ais523> and do their [ to check if the cell is 0 before adjusting it
14:25:21 <ais523> so it uses two tripwires, one with value 1, one with value -1
14:25:34 <ais523> and measures how long they take to become 0, compared to when the previous cell was zeroed for two cycles
14:25:57 <ais523> thus, it's #1 way to win is tricking the opponent off the end of the tape
14:26:06 <ais523> it has a few fallback winning methods too
14:26:13 <ais523> first, some opponents check for vibrations, and move into a clear loop if they do
14:26:50 <ais523> however, hardly any programs use an /offset/ clear in this situation, so I can lock them using a lock algorithm that works on any integer cycle length, but relies on knowing when the opponent's clear loop sets the value to 0
14:27:12 <ais523> second, if it can't measure the opponent's timing, it falls back to anticipation
14:27:41 <ais523> and third, if the game is still going after the opponent is meant to have fallen off the tape, it falls back to shudderlock (especially because it'll have a more accurate idea of when to start the lock than shudderlock normally has)
14:27:54 <ais523> so yeah, that's about it
14:28:28 <fizzie> Updated http://zem.fi/egostats/ with anticipation2, then.
14:29:19 <quintopia> i havent looked at it but it sounds like it will be gigs big
14:30:09 <ais523> read the program that generates it if you want something readable / with comments
14:30:18 <ais523> I deleted all the comments from the submitted version to help get it under the size limit
14:31:25 <quintopia> fizzie: does your egostats program fetch the whole hill at the click of a button?
14:31:51 <ais523> quintopia: I can fetch the whole hill with one command
14:32:05 <ais523> in esoteric/brainfuck/bfjoust/in_egobot, type hg pull && hg up
14:32:19 <fizzie> That's what I do, too.
14:32:37 <fizzie> (Then it's crank_hill.sh, parse_results.py, update_stats.py and rsync ...)
14:34:08 <ais523> I think anticipation2 may be the first successful program that intentionally sets its flag to zero, and knows it's intentionally setting its flag to zero when it does so
14:34:25 <ais523> also, it's the first successful cycle-counting defence program since defend9
14:34:52 <ais523> I basically just decided that, in this era of outcompeting decoy setups, simply ignoring the whole issue by using defence was the best option
14:35:06 <quintopia> fizzie: i just meant did you automate the entire update process
14:35:06 <ais523> the main things it loses to, incidentally, are reverse offset clears, and sometimes timer clears too
14:35:57 <fizzie> Well, it's quasiautomated. A total of five commands I copypaste from a commands.txt file.
14:36:01 <elliott> ais523: don't the shuddery things do that too?
14:36:10 <ais523> elliott: yeah, but they've never been successful
14:36:16 <ais523> when vibration ended up halfway up the hill
14:36:19 <ais523> I decided to make a /good/ one
14:36:26 <ais523> because it seemed like a viable strategy
14:36:47 <ais523> and unlike vibration, anticipation2 is actually capable of winning against things that the strategy doesn't work perfectly against
14:37:23 -!- Taneb has joined.
14:37:38 <quintopia> i find it interesting that despite their vast methodical differences, space hotel and anticipation2 win more on the same tape lengths and polarities as each other than any other programs
14:38:10 <quintopia> fizzie: can't you make commands.txt be commands.sh
14:38:53 <fizzie> I guess I could, it's just that things have (or at least had when it was written) a habit of breaking, it's nice for it to be slightly more granular.
14:39:22 <quintopia> and then can't you have one of the bots here call it whenever a new program is submitted? :P
14:39:58 <ais523> quintopia: I think it's just because space_hotel and anticipation2 win a lot full stop
14:41:14 <quintopia> ais523: this one is particularly revealing http://zem.fi/egostats/plot_tapeabs.png
14:41:38 <ais523> my favourite bit of that is how low anticipation2's flag is
14:41:44 <ais523> also, how high its opponent's flags are
14:41:50 <ais523> its own flag is low because it sets it low intentionally
14:42:19 <ais523> its enemies' are high because if it loses, it typically hasn't even started to attack the enemy flag yet, and if it wins, half the time it /still/ hasn't started to attack the enemy flag yet
14:42:53 <ais523> fizzie: another interesting plot might be to show where the player's and enemy's tape heads were when the duels ended
14:43:53 <ais523> for rush versus rush, it'd show how quickly players outrushed their opponent
14:43:59 <ais523> and it'd also indicate how often programs fell off the end
14:44:50 <fizzie> The cranking also produces a heatmap (well, the numbers for one) on where the tape heads spent time during the whole duel, which I think I'm not using for any plots.
14:45:14 -!- copumpkin has joined.
14:45:29 <ais523> yeah, that'd be interesting too
14:47:00 <fizzie> As for auto-updating, theoretically, sure. But it takes quite a while to run, maybe five-ten minutes or so, I don't think I want it running all the time. (And I don't have all the Python bits it depends on anywhere else than this local workstation.)
14:47:03 <mroman> If a,b,c were restricted to one element it would trivially be true
14:47:20 <ais523> oh, something you were talking about before I joined
14:47:32 <fizzie> (Python+Numpy+Matplotlib manages to be spectacularly slow at times.)
14:48:39 <mroman> If a,b,c were restricted to contain at least three elements...
14:50:17 <quintopia> fizzie: how about it sets a midnight cronjob whenever the hill changes?
14:50:56 <fizzie> mroman: a={1,2,4}, b={1,3,5}, c={2,3,6} as per elliott's other counterexample. (a n b = {1}, a n c = {2}, b n c = {3}, a n b n c = {}.)
14:51:19 <fizzie> quintopia: That could work. Admittedly it'd be nice for it to update oftener than once a year.
14:51:28 <quintopia> fizzie: is it impossible to coax matplotlib to make those "stuff left on the tape" plots trapezodial (equal cell width)?
14:52:23 <quintopia> fizzie: are you saying it'd be nice if people got interested in the joust more often than that?
14:53:12 <fizzie> quintopia: They could just be nan-filled (i.e. white) for equal cell width. I think I was just thinking it's nice when the opponent's flag is always at the same spot. But it could do both variants, of course.
14:53:43 <quintopia> fizzie: yeah its nicer to have the cells line up i think
14:53:58 <fizzie> quintopia: And I think people get interested more often than that (maybe even twice a year?) but I don't happen to be always looking at the channel when it happens so the page doesn't get updated.
14:54:03 <mroman> Would it matter how big the intersections are?
14:54:43 <ais523> fizzie: it's more than twice a year, but less than all the time
14:55:12 <fizzie> mroman: You can always add more junk. (a={1,11,111,2,22,222}, b={1,11,111,3,33,333}, c={2,22,222,3,33,333}.)
14:56:42 <fizzie> Some kind of a thing about the intersection of a, b and c given things about the intersections of (a and b), (a and c) and (b and c).
14:56:54 <fizzie> From what I can tell, it doesn't much matter what, as long as it's something.
14:58:50 <fizzie> quintopia: Also, it seems that the plotting takes about two gigs of memory, which would make it a bit iffy to run on the VPS where the plots live. (free -m "total 247".)
15:13:13 <elliott> [on Haskell] "Besides, we already have a language community for socially abrasive jerks. And the documentation for ruby is far better."
15:13:21 <elliott> I... think this person is living in opposite world.
15:15:22 <quintopia> oh. are you sure it wasn't [on esoteric languages]?
15:15:53 <olsner> maybe there's a separate community for socially abrasive jerks from the ruby community that have learned haskell
15:15:58 <ais523> mroman: do you know about Venn diagrams? if not, learn, it'll probably help you visualise things
15:16:16 <elliott> quintopia: unless Ruby's documentation massively improved in the last couple of years, the average esolang's is better
15:16:51 <olsner> then if everyone who knows ruby goes to haskell through that group then "the haskell community" will seem just as bad
15:18:18 <elliott> quintopia: can't object to that part
15:18:21 <ais523> elliott: well… PHP's documentation is apparently very good, but it has to be, the language would be impossible to write otherwise
15:18:23 <mroman> http://heimwerker-mathematik.aulbach-philosophy.de/_Schnittmenge_/echtes_Venn-Diagramm_-_B300.jpg
15:18:27 <mroman> ^- it looked like that
15:18:46 <elliott> ais523: stop using proper ellipses, I'm watching you
15:19:00 <ais523> I've got so used to proper ellipses
15:19:08 <ais523> that it takes quite some mental effort to type triple-period
15:19:21 <ais523> elliott: no, because that actually looks wrong
15:19:25 <mroman> how would you draw three circles
15:19:33 <olsner> ais523: what do you use to type your ellipses?
15:19:45 <quintopia> mroman: they dont have to be circles
15:19:59 <ais523> I type compose using caps lock, and caps lock using left shift + right shift
15:20:32 <elliott> ais523: soon enough people will forget there's a codepoint called ELLIPSIS anyway, I guess
15:21:01 <ais523> the sort of people who care about codepoints will know
15:21:11 <ais523> the sort of people who don't don't know in the first place so they can't forget
15:21:56 <quintopia> i've forgotten more than i've ever known!
15:22:12 * elliott still thinks smart quotes are doomed to obsolescence
15:24:40 <elliott> you get no answer from me!!!
15:26:25 <ais523> I can “type” smart quotes with altgr
15:26:30 <ais523> but am not sure how to do them with compose
15:30:20 <fizzie> I spent quite a while trying to compose-type an ë the other day; this keymap has a non-dead diaeresis key to make a ¨, but no way of composing ¨ and e seemed to work. (In the end it was "e, of course.)
15:31:32 <ais523> can’t is the correct smart apostrophe to use
15:31:37 <ais523> not can´t which obviously looks wrong
15:32:09 <ais523> hmm, I should use the correct apostrophes in words when I remember
15:35:47 <Sgeo> And today I learn that "better-monads" is a damned lie.
15:35:56 <Sgeo> ...oh, sorry about language
15:43:45 <Sgeo> elliott, I was worried about upsetting ais523
15:43:59 <ais523> Sgeo: I don't mind if you apply that to inanimate objects
15:45:15 <ais523> !bfjoust picks_up_breadcrumbs (>)*2(>>>>[(+[--[-[++++[(+)*100[+]]]]]>)*21])*6
15:45:17 <EgoBot> Score for ais523_picks_up_breadcrumbs: 9.6
15:50:21 -!- NihilistDandy has quit (Quit: Textual IRC Client: www.textualapp.com).
15:51:06 <ais523> !bfjoust picks_up_breadcrumbs (>)*2(>>>>>[((+[--[-[++++[(+)*10([-{(-)*90[-]>{}}])%20]]]]>)%21)*21])*6
15:51:08 <EgoBot> Score for ais523_picks_up_breadcrumbs: 10.3
15:51:38 <ais523> at least it beats space_hotel :)
15:51:51 <ais523> !bfjoust picks_up_breadcrumbs (>>>>>>[((+[--[-[++++[(+)*10([-{(-)*90[-]>{}}])%20]]]]>)%21)*21])*6
15:51:54 <EgoBot> Score for ais523_picks_up_breadcrumbs: 6.9
15:51:59 <ais523> !bfjoust picks_up_breadcrumbs (>>>>[((+[--[-[++++[(+)*10([-{(-)*90[-]>{}}])%20]]]]>)%21)*21])*6
15:52:01 <EgoBot> Score for ais523_picks_up_breadcrumbs: 12.3
15:52:29 <ais523> !bfjoust picks_up_breadcrumbs (>>>>[((+[--[-[++++[(+)*10([-{(-)*90[-]>{}}])%20]]]]>)%21)*21])*8
15:52:32 <EgoBot> Score for ais523_picks_up_breadcrumbs: 13.1
15:53:09 <ais523> !bfjoust picks_up_breadcrumbs (>>>>[((+[--[-[++++[(+)*10([-{(-)*90[-]>{}}])%20]]]]>)%21)*21])*7>(+)*100[+]>(+)*100[+]
15:53:12 <EgoBot> Score for ais523_picks_up_breadcrumbs: 13.3
15:53:15 <ais523> (another obvious improvement)
15:54:16 <ais523> !bfjoust picks_up_breadcrumbs (>>>>[(>(+[--[-[++++[(+)*10([-{(-)*90[-]>{}}])%20]]]])%21)*21])*7>(+)*100[+]>(+)*100[+]
15:54:19 <EgoBot> Score for ais523_picks_up_breadcrumbs: 11.3
15:54:30 <fizzie> An obvious disprovement this time?-)
15:54:38 <lambdabot> Maybe you meant: . ? @ bf do ft id pl rc v wn
15:54:40 <fizzie> (I just wanted to use the word "disprovement.")
15:54:42 <ais523> nah, that's the "let's just go even more insane" version
15:54:45 <ais523> !bfjoust picks_up_breadcrumbs (>>>>[((+[--[-[++++[(+)*10([-{(-)*90[-]>{}}])%20]]]]>)%21)*21])*7>(+)*100[+]>(+)*100[+]
15:54:48 <EgoBot> Score for ais523_picks_up_breadcrumbs: 13.3
15:54:51 <elliott> fizzie: Have you considered investing in: eyes?
15:54:57 <olsner> might be nice if it printed points and placement in addition to score
15:55:32 <olsner> the score changes every time, but it seems you always get the last place
15:55:49 <ais523> !bfjoust picks_up_breadcrumbs >>>>(>>>[((+[--[-[++++[(+)*10([-{(-)*90[-]>{}}])%20]]]]>)%21)*21])*8>(+)*100[+]>(+)*100[+]
15:55:52 <EgoBot> Score for ais523_picks_up_breadcrumbs: 15.6
15:56:25 <ais523> nice to know that the hill isn't centralized enough for this strategy to actually work yet :)
15:57:23 <ais523> !bfjoust picks_up_breadcrumbs >>>>(>>>[((+[+[+[+[-----[-[-[-[-[(+)*10([-{(-)*90[-]>{}}])%20]]]]]]]]]>)%21)*21])*8>(+)*100[+]>(+)*100[+]
15:57:26 <EgoBot> Score for ais523_picks_up_breadcrumbs: 15.9
15:57:36 <ais523> olsner: basically, moving n cells at a time towards the opponent
15:57:54 <ais523> in the hope of hitting their back trail rather than their decoy setup
15:58:02 <ais523> and reaching their flag before they finish actually setting up decoys
15:58:20 <ais523> everyone seems to have a back trail nowadays
15:59:02 <ais523> I didn't expect the strategy to work
16:02:26 <olsner> reading through plain.tex now, finally starting to get an idea of how the programming language TeX works
16:05:45 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
16:14:20 -!- DHeadshot has quit (Read error: Connection reset by peer).
16:14:40 -!- DHeadshot has joined.
16:20:24 <ais523> quintopia: have you noticed how the 11th cell seems to be somehow important when countering enemy pokes?
16:20:39 <ais523> both space_hotel and stealth change strategy at the 11th cell
16:23:53 <etb> !bfjoust court_jester (>)*9(+[-]>)*21
16:23:56 <EgoBot> Score for etb_court_jester: 13.7
16:24:09 <ais523> also, I think I've determined the maximum number of possible decoys for a non-poke program
16:24:20 <ais523> possibly with an extra decoy at 9 in order to confuse pokes on long tapes
16:24:36 <ais523> decoys on the seventh cell and later will almost always be avoided by the opponent
16:24:42 <ais523> or at least, cost more than they're worth
16:26:16 <etb> !bfjoust rampart (+)*70>(+)*128(>)*8(+[-]>)*21
16:26:19 <EgoBot> Score for etb_rampart: 21.1
16:27:29 <etb> that's my best yet :)
16:28:08 -!- nooodl_ has quit (Ping timeout: 244 seconds).
16:29:33 -!- sebbu2 has joined.
16:29:33 -!- sebbu2 has quit (Changing host).
16:29:33 -!- sebbu2 has joined.
16:32:54 -!- sebbu has quit (Ping timeout: 260 seconds).
16:34:03 <etb> !bfjoust boobs (+)>(+)*128(>)*8(+[-]>)*21
16:34:07 <EgoBot> Score for etb_boobs: 13.9
16:34:27 <ais523> etb: hmm, rampart is a very fast rush program
16:35:17 <etb> the defensive build-up at the beginning seems to help
16:35:41 <ais523> you have two decoys there
16:35:47 <ais523> and most programs are helped by adding decoys
16:37:00 <AnotherTest> Doesn't a cell with value 1 or -1 count as a decoy?
16:37:44 <AnotherTest> (note: my bf joust knowledge is minimal to none)
16:38:02 <ais523> AnotherTest: yes, a small decoy
16:38:04 <etb> !bfjoust rampart (+)*62>(+)*128(->)*8(+[-]>)*21
16:38:07 <EgoBot> Score for etb_rampart: 18.4
16:38:11 <ais523> small decoys are 1 to 3, and maybe 4
16:38:24 <ais523> medium decoys best function at 10 or so
16:38:33 <ais523> and large decoys often end up in the 70 to 85 range nowadays
16:38:40 -!- sebbu has joined.
16:38:43 <AnotherTest> ais523: Is it generally better to have large decoys?
16:38:43 <etb> !bfjoust rampart (+)*70>(+)*128(->)*8(+[-]>)*21
16:38:44 <mroman> How on earth is 3-SAT NP?
16:38:47 <EgoBot> Score for etb_rampart: 18.3
16:38:56 <ais523> (making them larger than 85 is mostly pointless, because a naive clear clears size 86 decoys just as fast as an order 86 offset clear does)
16:39:00 -!- sebbu has quit (Changing host).
16:39:00 -!- sebbu has joined.
16:39:14 <etb> !bfjoust rampart (+)*70>(+)*128(>)*8(+[-]>)*21
16:39:20 <EgoBot> Score for etb_rampart: 20.0
16:39:25 <ais523> AnotherTest: it depends on what you're doing; basically, a large decoy (that's larger than the opponent's clear offset) wastes 256 of their cycles on average, no matter how large it is
16:39:43 <ais523> so if you make it significantly larger than their clear offset, you're just wasting time setting it and not gaining any time back from the opponent clearing it more slowly
16:40:17 <ais523> (it takes 512 - 2*height cycles if they're trying the wrong polarity to clear it quickly, and 2*height cycles if they're trying the correct polarity)
16:41:06 <etb> !bfjoust rampart (+)*70>(+)*128(>)*8([-]>)*21
16:41:08 <EgoBot> Score for etb_rampart: 22.3
16:41:25 <etb> i keep forgetting that [ on !*p jumps to ]
16:41:36 <ais523> AnotherTest: a medium decoy, that's larger than any opponent wiggle but smaller than their offset, wastes a number of cycles equal to twice their offset, on average
16:42:03 <ais523> so because medium decoys are fast to set, against programs that use large offsets, they gain you a lot
16:42:12 <ais523> and a wiggle clear is where you check a few small values as special cases
16:42:15 <ais523> before going onto an offset clear
16:42:25 <ais523> they're good for dealing with small decoys, but have quadratic performance
16:42:25 -!- sebbu2 has quit (Ping timeout: 256 seconds).
16:42:35 <ais523> so people rarely wiggle above 3 or so
16:43:09 <etb> are they likely at all to get trapped in a loop?
16:43:19 <ais523> trapping programs in a loop is a legitimate strategy
16:43:28 <ais523> although one that hasn't done so well recently
16:43:41 <ais523> anticipation2, which I submitted today, has that as one of its methods of winning
16:43:41 <etb> i'm wondering how best to probe values without getting caught having to inc/decrement
16:43:53 <ais523> and you have to increment/decrement a cell to probe it
16:44:01 <ais523> this is part of the strategy
16:44:45 <ais523> you can zero-test a cell without touching it
16:44:54 <ais523> but for other cells, you have to set them to zero to be able to determine their value
16:45:33 <etb> !bfjoust manpart (+)*70>(+)*128(>)*8([(+)*3[-]]>)*21
16:45:36 <EgoBot> Score for etb_manpart: 17.8
16:46:11 <ais523> a "lock" program is one that tries to trap the opponent in a loop
16:46:25 <ais523> say by turning the cell backwards at the same rate the opponent is trying to turn it forwards
16:46:31 <ais523> I think defend7 is still on the hill, that's a pretty naive version
16:46:43 <ais523> AnotherTest: recently, no, but I've been trying to revive them
16:46:50 -!- oerjan has joined.
16:46:58 <ais523> the methods of countering them are just too good
16:47:25 * oerjan guesses ais523 is talking about bfjoust defense
16:47:25 <lambdabot> oerjan: You have 1 new message. '/msg lambdabot @messages' to read it.
16:47:29 <lambdabot> elliott said 2h 43m 6s ago: when you read the logs: i'm sorry it took me to so long to find that obvious counterexample. please don't swat me
16:47:43 <AnotherTest> How are these programs that constantly moves up and down the flags value doing?
16:48:01 <ais523> oh, shudder/vibration programs?
16:48:07 <ais523> vibration's like halfway up the leaderboard
16:48:17 <ais523> anticipation2 is technically a vibration program too, but it doesn't really act like one
16:49:18 <AnotherTest> Well, that was the only BF Joust program I ever wrote (but not submitted because I realized it had already been done)
16:49:40 <AnotherTest> But unfortunately, it had been done before
16:49:48 <etb> !bfjoust badlock (+)*70>(+)*70(.)*128([+])*-1
16:49:51 <AnotherTest> so I assumed that there would be some defence against it
16:49:53 <EgoBot> Score for etb_badlock: 10.7
16:50:43 * oerjan is still wondering how much rock/paper/scissors effects there are in bfjoust - that is, how much what wins depends of what is already on the hill, and whether defense could prevail more in another environment. this musing is somewhat hampered by my lack of any deep understanding of bfjoust.
16:51:28 <etb> putting a bad program on the hill rearranges the leaderboard
16:51:56 <oerjan> or put another way, if what's currently on the hill counts as scissors and defense counts as paper, do rocks exist?
16:52:26 -!- WeThePeople has joined.
16:52:36 <ais523> oerjan: actually sufficiently good defence beats what's currently on the hill, I think
16:52:42 <ais523> because the defence programs dropped off a while ago
16:53:58 <oerjan> <etb> putting a bad program on the hill rearranges the leaderboard <-- not if it gets dropped off, surely?
16:54:15 <etb> once it gets dropped, it will rearrange again
16:54:35 <etb> !bfjoust suicide <
16:54:38 <EgoBot> Score for etb_suicide: 0.0
16:54:39 <elliott> oerjan: bf joust is pretty much entirely a metagame of hill effects
16:54:55 <oerjan> quintopia: did your(?) new scoring system ever get merged into EgoBot?
16:55:20 <oerjan> ais523 said something implying it was, but i'm not sure if he is correct
16:55:41 <ais523> I'm not 100% sure either
16:56:30 <oerjan> etb: quintopia's system means scores are _only_ dependent on what is on the hill, not on previous scores.
16:57:01 <ais523> oerjan: the old one was like that too
16:57:09 <ais523> but it jostles around because submitting a program changes what's on the hill
16:57:45 <etb> that's what i'm saying :(
16:57:55 <etb> it's kinda cool actually
16:58:08 <oerjan> well sure, but the new one would also do that as long as the new program doesn't get thrown off immediately
17:18:45 -!- Bike has joined.
17:19:58 <olsner> I'm glad to see my programs finally move down the hill a bit
17:25:01 -!- sebbu has quit (Read error: Connection reset by peer).
17:25:28 -!- sebbu has joined.
17:25:29 -!- sebbu has quit (Changing host).
17:25:29 -!- sebbu has joined.
17:27:51 <ais523> olsner: it actually took me quite some effort trying to beat them :)
17:28:02 <ais523> it's nice to have a variety of people's styles on the hill
17:29:09 <mroman> now I need a DIMACS parser :(
17:33:46 <mroman> Let's just say if I've had invented the DIMACS format I would have put a constraint on ordering
17:37:56 -!- calamari has quit (Quit: Leaving).
17:39:58 <oerjan> <etb> i'm picturing a system in which `using x = T<int>; using y = T<int>;` will be like `using x = T<int,0>; using y = T<int,1>;` so that the expression `x = y;` results in a compile-time error
17:40:24 <oerjan> i'd bet ada can do that, if i actually knew ada.
17:40:49 <Bike> yeah, you can make incompatible named subtypes of int or w/e
17:41:03 <etb> that should be using X, using Y and X x; Y y; then x = y; (ie instance of x = instance of y results in an error)
17:42:21 <etb> it's just odd that C++ is supposed to be so type safe yet making safe types out of basic data types is not really possible
17:42:28 <oerjan> do ML modules work that way?
17:42:36 <etb> stroustrup talks about this frequently
17:42:41 <olsner> ais523: "my" programs are generated from a bfjoust syntax and a couple of small inner loops grabbed from other programs on the hill
17:42:58 <ais523> yeah but everyone's programs feel different
17:43:16 <ais523> it's quite easy to accidentally beat a program that does well against most people but badly against, say, GregorR or atehwa, for instance
17:44:10 <oerjan> um, did you intend "beat" there
17:44:49 <oerjan> (it could make sense either way, but...)
17:45:36 <olsner> (http://pastebin.com/WhKYSt6u)
17:46:00 <ais523> olsner: I intended "write"
17:46:39 <ais523> olsner: oh, they're automatically generated?
17:46:49 <oerjan> um, did you intend "olsner" there
17:46:56 <ais523> yes, I did intend "olsner"
17:47:06 <ais523> but "oerjan" the first time
17:47:19 <ais523> olsner: evolved or just random?
17:47:59 <olsner> found a crummy evolution framework and integrated it with the bfjoust stuff from codu.org
17:48:58 <olsner> a bit hard to make any progress since almost every program is equally bad
17:58:29 -!- asiekierka has quit (Excess Flood).
17:58:35 -!- asiekierka has joined.
18:02:31 -!- monqy has joined.
18:02:55 <oerjan> <elliott> I should grep the wiki logs to see if I can find out where the people behind it looked at the article on Malbolge, assuming they used the wiki
18:04:34 <oerjan> actually they probably copied from wikipedia. the program they used isn't in the esolang article. (you may note my recent wikipedia edit.)
18:05:35 <oerjan> that is, they basically took the one sample program on wikipedia, and copied it badly.
18:05:39 -!- DHeadshot has quit (Ping timeout: 260 seconds).
18:06:12 -!- DHeadshot has joined.
18:07:15 <oerjan> 04:02:27: <tbc> Any fans of the TV show Elementary here?
18:07:15 <oerjan> 04:03:28: <NihilistDandy> Haven't watched it. I can't imagine it topping Sherlock.
18:07:18 <oerjan> 04:05:26: <tbc> It's an interesting take on the Holmes character. I popped in here because Malbolge was part of the plot in the episode titled The Leviathan.
18:09:55 <oerjan> <elliott> I think the wikipedia article is a bit copied from ours <-- btw we never resolved the question on wikipedia of where the name "crazy operation" came from
18:10:29 <oerjan> iirc it showed up on wikipedia first, with no reference.
18:10:45 <Taneb> Didn't wikipedia give a French or German politician a new middle name, in a similar way?
18:11:21 <oerjan> i vaguely recall that.
18:11:52 <oerjan> someone with an already pompous nobility name got a bit extra, iirc
18:13:20 <oerjan> <tbc> Grr. I already deleted the episode. I should have transcribed the frame where they showed a fragment of a Malobolge program. It was a romping story. <-- someone already did so in the wp talk page, which is how i discovered it was a near-copy of Hello, World!
18:14:17 <Taneb> I think I've got Elementary recorded
18:14:26 <Taneb> I'll make a note to watch that episode
18:14:58 <oerjan> btw the same guy requested someone to upload a picture of that frame, but i was worried about copyright
18:15:34 <oerjan> if any of you are braver/less principled/knows this is fair use, see the talk page
18:21:17 -!- nooodl_ has joined.
18:21:46 <oerjan> <Bike> i'm not sure how anyone could reliably distinguish malbolge from line noise (not that line noise is really produced anymore) <-- that's not actually so hard in principle, because Malbolge allows only 8 character in each particular program position (although which depends on the position)
18:28:49 -!- AnotherTest has quit (Quit: Leaving.).
18:35:30 <ais523> yeah, it's like trying to distinguish a ttyrec from line noise
18:35:55 <ais523> in practice it's easy because line noise tends to not have weakly increasing timestamps
18:43:56 <hagb4rd> i must revise what i said about template templates metaprogramming and c#.. it is not easier to implement those. it is just impossible
18:45:48 <hagb4rd> so i hope you'll accept my apologies and revise the excommunication
18:45:59 <Bike> excommunication?
18:47:22 <hagb4rd> if a man admits his failure he must promptly be forgiven
18:58:29 <oerjan> @tell elliott It's OK, but as penance you will have to read up on http://en.wikipedia.org/wiki/Median_algebra
19:03:29 <oerjan> mroman: you can read it too btw
19:06:21 <kmc> you have reminded me of http://www.youtube.com/watch?v=zQqZKd_72C0 (nsfw?)
19:06:33 <kmc> a trailer for a film formerly titled "Kiss the Ring" and now titled "Gone With The Pope"
19:06:35 <oerjan> elliott: mroman: and then http://en.wikipedia.org/wiki/2-satisfiability
19:07:06 <oerjan> wait, that's darn long
19:10:30 <hagb4rd> kmc: well thx.. haven't seen that one yet
19:10:38 <oerjan> the connection i wanted to point out is probably http://en.wikipedia.org/wiki/2-satisfiability#The_set_of_all_solutions
19:14:44 <oerjan> or to put it explicitly: a family of variable assignments of some set of variables X can be described by pairwise restrictions on the variables precisely when the family is closed under taking the median operation on any 3 assignments
19:16:11 * oerjan sadly realizes no one will understand this anyway
19:18:31 <oerjan> mroman: oh but here's a cool related boolean algebra theorem which is what sent me from your discussion to thinking about this: (a \/ b) /\ (a \/ c) /\ (b \/ c) = (a /\ b) \/ (a /\ c) \/ (b /\ c). i.e. the median operation in boolean algebra is _self-dual_.
19:27:37 -!- carado has joined.
19:38:36 <lambdabot> fd:9: commitBuffer: invalid argument (invalid character)
19:39:30 * oerjan does a little victory dance
19:42:12 <oerjan> Bike: lambdabot's > breaks horribly on unicode I/O, but @let doesn't
19:42:36 <Bike> i know. but i don't want to think about why.
19:42:53 <oerjan> i think i know why, and it's fairly logical
19:43:40 <oerjan> @let just appends its line to a module file, which is then checked with ghc directly, and ghc is utf-8 clean
19:44:23 <oerjan> but > and :t pass an expression to mueval, which has some charset problem
19:44:43 <oerjan> ...actually :t may have a different problem than >
19:45:36 <oerjan> maybe i shouldn't think about why either
19:58:04 <oerjan> <mroman> How on earth is 3-SAT NP?
19:58:28 <oerjan> by encoding SAT into it?
19:58:49 -!- epicmonkey has quit (Ping timeout: 260 seconds).
19:59:03 * oerjan now wonders if mroman was looking at 2-SAT already
20:00:53 <oerjan> basically with 3-SAT you can encode that 1 variable is an arbitrary boolean function of two others.
20:01:46 <oerjan> and then you just build any other circuit up from that
20:06:43 <oerjan> (a \/ ~c) /\ (b \/ ~c) /\ (~a \/ ~b \/ c) encodes c == a /\ b
20:12:14 <shachaf> Am I hallucinating currently?
20:12:38 <oerjan> that computer is really a grape.
20:12:39 <shachaf> That's just what hallucinoerjan would say!
20:13:00 <oerjan> thus proving you're hallucinating!
20:13:10 <shachaf> But hallucinoerjan would probably lie to me.
20:13:27 <shachaf> Do you know what "spineless" in "spineless tagless g-machine" means?
20:14:11 <Fiora> I am a figment of your imagination sch
20:14:33 * Fiora hovers on the edge of your vision making weird faces
20:14:38 <ion> I also don’t know what “tagless” in “spineless tagless g-machine” means.
20:14:50 <ion> In addition to that, i don’t know what “g-machine” in “spineless tagless g-machine” means.
20:15:00 <oerjan> i think the g is for graph, maybe.
20:15:11 <ion> I’ve been meaning to read the paper, but haven’t got around to that.
20:15:23 <shachaf> ion: The STG machine is neither spineless nor tagless, I'm told.
20:15:38 <ion> In that case, that is an excellent name for it.
20:15:40 <shachaf> By which I mean the thing GHC uses, not the thing in the paper.
20:15:47 <shachaf> I have first-hand evidence that it's not tagless.
20:17:22 <shachaf> I don't know what spineless means so I don't know about that.
20:19:18 -!- esowiki has joined.
20:19:20 -!- glogbot has joined.
20:19:21 -!- fizzie has joined.
20:19:22 -!- mroman has joined.
20:19:22 -!- esowiki has joined.
20:19:23 -!- esowiki has joined.
20:19:31 -!- Gregor has joined.
20:19:37 -!- olsner has joined.
20:20:02 -!- Taneb has joined.
20:23:20 -!- lambdabot has joined.
20:27:57 <fungot> shachaf: by the time i saw no trace of
20:32:11 <fungot> shachaf: published june 1922 in home brew vol. 1, no. 4, p. fnord. prop... fnord...
20:33:52 <kmc> shachaf: it is tagless in the original meaning of "tag"
20:34:58 <kmc> the one where e.g. pointers all end in 00 and primitive ints end in 01
20:35:19 <kmc> and the garbage collector needs this information to do its job correctly
20:35:48 <kmc> one of the innovations of GHC was that you already know whether each word is a heap pointer or a primitive thingy, without inspecting the word
20:36:56 <Fiora> how did it do that?
20:41:09 <shachaf> «Objects in the heap, both unevaluated suspensions and head normal forms, have a uniform representation with a code pointer in their first field. Many implementations examine tag fields on heap objects to decide how to treat them. With our representation we never do this; instead, a jump is made to the code pointed to by the object. This is why we call the machine "tagless"»
20:41:51 <shachaf> I suppose you could read that either way.
20:42:02 <Fiora> I wonder how painful that is to the branch predictor
20:42:11 <Fiora> indirect jumps everywhere
20:42:13 <shachaf> That's why they don't do it anymore.
20:42:24 <Fiora> what do they do instead?
20:42:32 <shachaf> This is one of the places where a tracing JIT can really help, though.
20:42:47 <shachaf> They have pointed tagging now.
20:43:15 <Fiora> storing the tag in the low bits of the pointer, then masking it off?
20:43:18 <shachaf> The code is still there and you can still always jump to it.
20:43:41 <shachaf> So you can check whether a thunk is already evaluated and if so skip the indirect jump.
20:43:58 <Fiora> I guess the old tagless stuff reminds me of vtables
20:44:20 <shachaf> vtables are another place where a JIT can help. :-)
20:44:32 <Fiora> does java do anything special for vtable stuff?
20:44:49 <shachaf> edwardk worked on an x86->x86 tracing JIT to optimize indirect jumps and that sort of thing.
20:45:23 <Fiora> does that work better than branch prediction? since, I mean, modern chips do track indirect jumps
20:45:35 <Fiora> I guess it could reduce the number to reduce the load on the predictor unit
20:46:29 <shachaf> Well, once you're doing optimizations at runtime there can also be all sorts of other things that you can do.
20:47:37 -!- Phantom_Hoover has joined.
20:47:55 <Fiora> isn't inlining a vtable reference the same thing as a template basically?
20:48:03 <Phantom_Hoover> I seem to have unexpectedly ended up with a Raspberry Pi and no idea what to do with it.
20:48:03 <Fiora> like you're templating that function based on the type of an object
20:48:03 <lambdabot> Phantom_Hoover: You have 2 new messages. '/msg lambdabot @messages' to read them.
20:48:13 <shachaf> But I understand that just replacing the indirect jump with a direct jump in an inner loop can help quite a bit.
20:48:44 <Fiora> yeah, but don't you have to check each time to see if the direct jump is still right?
20:48:51 <Fiora> since the type of the object could be different
20:49:04 <shachaf> You can do it once outside of the loop, presumably.
20:49:42 <shachaf> Well, depending on whether you expect the address to change.
20:50:03 <shachaf> In most contexts, like vtables, it probably won't.
20:54:34 <shachaf> Anyway I don't know that much about this.
20:55:16 <Bike> Phantom_Hoover: post-bop avantcore.
20:55:47 <Bike> only one way to find out!
20:56:22 <Bike> hichaf? sounds like a warning for militarypilots
20:56:24 <Fiora> you can do that optimization on compile time too right? loop hoisting
20:57:25 <shachaf> Well, you don't know what the value will be at compile time.
20:57:37 <Fiora> but if it doesn't change in the loop, you could at least load it once at the start, right?
20:58:04 <shachaf> Sure, but it's still an indirect jump.
20:58:46 <Bike> kmc: dunno if you're here or care but yesterday got me thinking, so now i'm wondering what a clean way to (userly) define special forms not based on environment manipulation (e.g. compiler interaction things like load-time-value and no i don't expect you to have heard of that). and whipping some shit up as usual
21:00:50 -!- Taneb has quit (Quit: Leaving).
21:02:29 <Fiora> isn't an indirect jump cheap if it goes to the same place every time?
21:08:08 <kmc> HDMI and DVI are partially compatible
21:09:05 <Phantom_Hoover> kmc, yes but unless I can jam one into the other that's not much help right now.
21:25:51 -!- monqy has quit (Quit: hello).
21:48:55 -!- Nisstyre-laptop has joined.
22:13:04 <fizzie> Don't you wish you had a DVI-HDMI cable instead? (It's what I have.)
22:13:37 -!- asiekierka has quit (Excess Flood).
22:13:43 -!- asiekierka has joined.
22:14:11 <fizzie> But then I wouldn't see what I typed. :/
22:14:57 <fizzie> I like being able to see my screen more.
22:15:05 <fizzie> Plus I couldn't connect my own Pi without the cable.
22:15:18 <fizzie> (I don't know what to do with it.)
22:19:11 <fizzie> Forget smartphones, smarthats are where it's at.
22:20:40 <fizzie> Maybe some kind of an integrated Pi-controlled 3D printer/hat hybrid.
22:20:48 <fizzie> Just wait three-six hours and you've got a new hat.
22:20:57 <fizzie> Careful with the heating elements, though.
22:21:31 <Phantom_Hoover> i was thinking more of some strategically-arranged retractible brims but that works too
22:22:45 <fizzie> Many people have made media-centery things with the Pi, which to me sounds kind of weird.
22:23:04 <fizzie> I'm sure it could be a passable one, but still.
22:24:20 <fizzie> Hey, my scp file transfer is running at 15 MiB/s. How is that even possible?
22:24:40 <fizzie> Oh, right, there's a network cable there.
22:47:38 -!- xDEADCA7 has joined.
22:47:53 <fizzie> Huh, it must be the future now. I just EMULATED a WII on a PC.
22:48:20 <Fiora> Dolphin is pretty amazing
22:48:32 <Fiora> It has a really good JIT
22:48:45 <fizzie> It wasn't that long ago when just emulating a Playstation was kind of impressive, and it was really recently I discovered you can do PS2 these days.
22:49:36 <Fiora> yeah, PS2 works great with a fast clocked CPU
22:49:43 <Fiora> the PS2 chip is way harder to emulate, clock for clock, than the Wii though
22:49:52 <ais523> Fiora: you're a JIT fan, right?
22:50:03 <Fiora> ummmm kinda but I mostly know emulation stuff
22:50:11 <ais523> you just seem to go on about them a lot :)
22:50:21 -!- zzo38 has joined.
22:50:21 <Fiora> I likecompilers and jits and emulators and things
22:50:40 <Fiora> and things like, learning how the ps2 cpu works and its instructions and how to emulate them and stuff
22:50:56 <Fiora> it's amazing how it can take like 15-20 instructions to emulate a single floating point add in the VU
22:51:27 <Fiora> and there's two VUs each doing 128-bit vector ops, then the main MIPS core which also has a custom 128-bit integer simd instruction set
22:51:49 <fizzie> "What are Fioras made of? Compilers and jits and emulators and things." I think there was a rhyme that went like that.
22:52:07 <Fiora> I'm just kind of insane and I read the pcsx2 source code for fun okay ~_~
22:52:12 <ais523> at least the original playstation is famous for sucking at arithmetic
22:52:17 <ais523> oh, and reading source for fun is fine :)
22:52:36 <Fiora> the vector unit on the ps2 is lots of fun
22:52:47 <Fiora> instead of IEEE it has max/min float values, so you have to clamp
22:52:52 <Fiora> so no infinities or nans
22:53:10 <Fiora> each instruction has a built-in shuffle on all of the inputs (you can take the inputs in any order)
22:53:11 <ais523> that's common in graphics programming
22:53:19 <ais523> NaNs have a tendency to spread and take over your whole systme
22:53:25 <Fiora> each instruction can choose to operate on only some of the input values
22:53:33 <Fiora> each instruction sets a combination of flags
22:53:43 <Fiora> there's a sign flag and overflow flag (I think?) for each of the 4 floats
22:54:03 <Fiora> and then there's "sticky flags" which can get set on, but not off, so it lets you see if any of the previous operations overflowed or such
22:54:10 <Fiora> so that means you can't easily optimize out flag calculations that aren't used
22:54:37 <Fiora> so each VU instruction turns into a gigantic mess of pshufd and pmovmskb and minps and maxps for clamping
22:55:35 <oerjan> <Fiora> I'm just kind of insane and I read the pcsx2 source code for fun okay ~_~ <-- AHEM
22:55:41 <HackEgo> "But I don't want to go among mad people," Alice remarked. "Oh, you can't help that," said the Cat: "we're all mad here. I'm mad. You're mad." "How do you know I'm mad?" said Alice. "You must be," said the Cat, "or you wouldn't have come here."
22:55:50 <Fiora> it also has some really weird pipeline structure you have to emulate, because VU0 is locked to the main CPU, and if the CPU accesses it, it has to get the right results depending on which operations have retired
22:56:11 <Bike> i'm trying to remember the last time i met someone who explicitly denied being insane, instead of jokingly saying they were, and failing
22:56:34 <Bike> Fiora: that ("gigantic mess") makes it sound like it would make ps2 emulation pretty slow?
22:57:02 <fizzie> Nintendo DS has a "math accelerator", I think that's a funny bit. It can do 64x64->64 division and a 64->32 square-root; you write your results into a memory-mapped IO register, and after a while you can read the result out of another.
22:57:18 <Fiora> Bike: exactly, yeah
22:57:27 <oerjan> Bike: only (some) insane people deny being insane.
22:57:33 <Fiora> there's two reasons why PS2 emulation is so slow
22:57:36 <Fiora> 1) emulating the VUs is really hard
22:57:39 <Bike> Fiora: so, how do they deal with it? (or do they just say "get a faster computer")
22:57:44 <fizzie> Fortunately, computers are pretty fast.
22:57:57 <Fiora> they optimize out a lot of the flag calculations, use an optimizing compiler for VU microprograms, and use core i7s
22:57:59 -!- xDEADCA7 has quit (Quit: Sto andando via).
22:58:04 <Bike> as a netbook user i am constantly confronted with the fact that they are not, fizzie :/
22:58:16 <Fiora> the other part of things is the ps2 graphics chip
22:58:29 <ais523> I can't run JPC-RR at a reasonable speed on my netbook, especially on NetHack
22:58:46 <ais523> and it's implementing a 386-era PC
22:58:46 <Fiora> the ps2 graphics chip is really overly simple and very inflexible
22:58:50 <Fiora> but it runs insanely fast
22:58:55 <Bike> also i'm reminded of bsnes
22:58:57 <Fiora> it can fill the entire screen 40 times per frame
22:59:22 <Bike> putting in one extension for correctness with original hardware cut the speed of the one game that used it in tenths or so
22:59:26 <Fiora> so to do game graphics, people would do multiple passes of simple code instead of fewer passes of complex code
22:59:35 <fizzie> My most efficient computer is a laptop, and it can run PCSX2 and (as I learned today) Dolphin/Wii reasonably well. (Granted, it's only borderline a "laptop", and certainly not a netbook.)
22:59:36 <Fiora> but modern GPUs are all about complex, flexible code running slower
22:59:44 <ais523> this is borderline a netbook
22:59:47 <Fiora> not simple code running insanely fast
22:59:55 <Bike> ais523: "subnotebook" clearly
23:00:00 <Fiora> so emulating the graphics unit is sorta tricky too
23:00:01 <Bike> "supernetbook"
23:00:12 <fizzie> ais523: Which border, though?
23:00:16 <ais523> I think Toshiba wanted to make a netbook originally
23:00:19 <ais523> and then they wanted to put Windows on it
23:00:28 <ais523> so it's ended up with 3 GB of RAM
23:00:40 <ais523> although, that's pretty low specs for today
23:01:55 <Fiora> I emulated persona 4 pretty okay with a 1.6ghz i7
23:02:47 <fizzie> Yeah, the "laptop" weighs some absurd amount, eats watts for breakfast, and has a Sandy Bridge i7-2720QM (4x 2.2 GHz) + a GTX 460M on it. Granted, both have "M" in the name so they're not quite high-end-desktop parts (not even when it was made), but it's still fast-ish as far as these things go.
23:04:59 <fizzie> (It's kind of a compromise solution, I wanted something that'd run current (when-bought) games, yet would be something I could when necessary carry along, after the PPC iBook died on me. In retrospect, it might have made more sense to do both a desktop upgrade as well as buy something more portable, but meh, it works.)
23:05:43 <Fiora> huh, mine's like 3.2kg ish and has a 2.4ghz ivy bridge (runs at 3.4ghz in practice...) and a 7970M
23:06:16 <fizzie> Yeah, this is from the Sandy age, but the weight is around the same.
23:06:30 <Fiora> this was about the lightest I was able to find
23:06:33 <Fiora> most of them were like 4-5kg
23:06:40 <Fiora> I basically bought it just for the weight
23:08:00 <Bike> ooh let's make it a contest
23:08:17 <Bike> "I just execute the instructions on paper, I can get 5 Hz if I'm on enough stims"
23:09:28 -!- ais523 has quit.
23:09:39 <Bike> phantom gets roughly 1 mHz if he uses enough throughput
23:10:16 <oerjan> i don't compute. i just guess, and then destroy all the universes where i guessed wrong.
23:10:48 <fizzie> I think my VDSL2 router box has its MIPS core clocked at 400 MHz.
23:10:58 <Bike> oerjan: i feel like i should complain about many-worlds but it turns out i'm not actually scott aaronson
23:11:21 <Fiora> but hwo do you check your answer
23:11:23 <Fiora> doesn't that involve....
23:11:44 <shachaf> Fiora: So you've reduced it to a problem oerjan just solved.
23:11:47 <Bike> oerjan applies the process recursively until there is no oerjan to guess incorrectly, fiora.
23:11:55 <oerjan> Fiora: well no one has ever told me i was wrong in any universe that survived
23:13:13 <oerjan> well, no one _believable_, that is.
23:15:46 <Fiora> you're actually dead
23:16:43 <shachaf> Have you ever thought of yourself as actually dead, lying in a box with a lid on it?
23:16:51 -!- TeruFSX has joined.
23:17:28 <fizzie> Trivia fact of the day: Sonic Generations runs on the "Hedgehog Engine".
23:17:39 <Bike> that's quite uncreative
23:18:39 <fizzie> (For factual accuracy: only the PC/PS3/X360 versions of Generations; but also the PS3/X360 versions of Unleashed too.)
23:18:51 <fizzie> I don't know, the name always kind of makes me smile.
23:18:56 <fizzie> It's the Hedgehog Engine.
23:19:04 <fizzie> IIRC, it has a hedgehog logo.
23:20:20 <fizzie> https://dl.dropbox.com/u/113389132/Misc/20121230-Hedgehogengine.png oh yes.
23:21:17 <Bike> ok, that is cute.
23:22:05 <fizzie> They've added the "TM" symbol, I wonder if they've actually... oh yes, http://tess2.uspto.gov/bin/showfield?f=doc&state=4002:njtr9n.2.1
23:22:38 <fizzie> I like the "we're not registering the word "ENGINE" exclusively" disclaimer.
23:24:02 <oerjan> wow next year they're starting to remove the landline phone system in norway
23:34:13 <fizzie> http://www.ficora.fi/attachments/englantiav/68tsy4qIW/Telecommunication_Markets_in_the_Nordic_Countries_2011.pdf Finland is leading the drop in the "Fixed telephony subscriptions per capita" graph (page 12), but also completely nowhere in the VoIP graph (page 13).
23:35:32 <Bike> finland has resorted by cybernetic pigeons for long-distance telephony
23:36:45 <fizzie> I didn't quite realize how much mobile broadband subscriptions/use there is in here.
23:37:07 -!- Frooxius has quit (Read error: Connection reset by peer).
23:37:11 <oerjan> http://translate.google.no/translate?hl=no&sl=no&tl=en&u=http%3A%2F%2Fwww.dagbladet.no%2F2012%2F12%2F30%2Fnyheter%2Fsamferdsel%2Fpolitikk%2Finnenriks%2Ftelefon%2F25021505%2F
23:37:25 -!- Frooxius has joined.
23:37:49 <fizzie> "In the period 2013 to 2017, Telenor shall lay down fixed phone."
23:37:54 <fizzie> Google Translate makes it sound so dramatic.
23:38:55 <fizzie> Incidentally, our university just (a month or so ago) got rid of all their billion DECT desk phones, and just issued regular GSM phones to all personnel.
23:39:22 <fizzie> Though nobody has called it yet. :/
23:44:25 <oerjan> apparently google translate turns "Hordaland" into "Oslo" in the first paragraph :(
23:44:41 <oerjan> "like they're both countries, okay?"
23:55:02 -!- monqy has joined.