00:08:08 -!- augur has joined.
00:15:02 -!- Slereah has joined.
00:16:09 -!- Slereah_ has quit (Ping timeout: 260 seconds).
00:16:34 -!- augur has quit (Remote host closed the connection).
00:33:21 -!- ais523 has quit (Remote host closed the connection).
00:34:40 <Sgeo> kallisti, my notifier hasn't gone off, therefore I assume you're lying
00:34:58 -!- Jafet has joined.
00:36:30 -!- Sgeo has left ("Leaving").
00:36:33 -!- Sgeo has joined.
00:36:57 <kallisti> Sgeo: I guess you'll just never know how AWESOME this PUMPKINS are.
00:37:14 <myndzi> actually the video for blood red sandman gave me the boots: \m/ \m/
00:37:18 <Sgeo> kallisti, or, you may in fact be delayed in seeing the latest updates
00:37:31 <Sgeo> Because we saw pumpkins recently, but that was a while ago
00:37:40 <Sgeo> The pumpkins update
00:43:38 -!- pikhq_ has joined.
00:43:51 -!- pikhq has quit (Ping timeout: 258 seconds).
00:48:07 -!- sebbu2 has quit (Ping timeout: 248 seconds).
00:51:12 -!- sebbu2 has joined.
00:51:13 -!- sebbu2 has quit (Changing host).
00:51:13 -!- sebbu2 has joined.
00:55:46 <zzo38> I made so that some Haskell functions can have Show; it works you can type maybe (False, True) (join (,)) in GHCi and it tells you the output Nothing -> (False, True) Just False -> (False, False) Just True -> (True, True)
00:56:01 <zzo38> If the type is ambiguous it assumes you mean ()
00:57:01 -!- DCliche has quit (Quit: You are now graced with my absence.).
01:01:36 -!- copumpkin has joined.
01:02:13 <kallisti> http://upload.wikimedia.org/wikipedia/en/math/a/5/e/a5e707d8d73a8dc420acfb9cb8794622.png
01:02:28 <kallisti> can someone explain this notation? it's a "family of sets"
01:02:42 <kallisti> which, if I understand correctly, is a multiset of sets.
01:07:23 <kallisti> if I understand correctly it's saying that the subsets are basically indexed by an integer or something?
01:09:01 <kallisti> A choice function is a function f, defined on a collection X of nonempty sets, such that for every set s in X, f(s) is an element of s.
01:09:08 <Betawolf> The way i read it, there are some sets S for every i in set I, but that's somewhat loose and probably dodgy as an interpretation. Is there any context that would help?
01:09:15 -!- derdon has quit (Remote host closed the connection).
01:09:19 <kallisti> For any set X of nonempty sets, there exists a choice function f defined on X.
01:09:26 <kallisti> oh okay... axiom of choice now makes sense.
01:10:14 <kallisti> http://en.wikipedia.org/wiki/Axiom_of_choice
01:10:24 <kallisti> I see what the subscript i is for now.
01:15:54 <kallisti> I was going to say that restricts the sets to being countable, but I guess "I" could be real numbers here so not necessarily. also the mapping function I -> S is not necessarily bijective I think.
01:16:16 <kallisti> http://en.wikipedia.org/wiki/Indexed_family
01:21:35 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
01:37:53 -!- Jafet has quit (Quit: Leaving.).
01:40:09 <kallisti> Haskell: not a fan of intuitionism.
01:41:06 <kallisti> of course Maybe Bool gives you a three-valued logic, in which you could probably say that not x || x is unknown (aka Nothing in this construction)
01:41:31 <kallisti> or well, that not x || x /can/ be unknown, depending on x.
01:43:33 <kallisti> http://lonelynerdsinfedoras.tumblr.com/ needs more Gregor
01:44:34 <Sgeo> kallisti, intuitionism?
01:45:08 <kallisti> yes, a kind of mathematical constructivism
01:45:16 <Sgeo> What would the result of not True && True be in intuitionism?
01:45:45 <kallisti> http://en.wikipedia.org/wiki/Intuitionistic_logic
01:46:42 * kallisti is still learning so does not have an answer yet :P
01:49:04 <kallisti> well I think not True && True is False
01:49:17 <kallisti> but not p && p cannot in general be proven (???)
01:51:40 <GreaseMonkey> ok quick question, what would be a good scheme standard to implement?
01:52:04 <Sgeo> Does R7RS exist?
01:52:17 <Sgeo> I've heard bad things about R6RS
01:52:59 <GreaseMonkey> but yeah i have heard bad things about versions after R5RS
01:54:06 <kallisti> I've heard bad things about people who hold strong opinions about scheme standards.
01:54:46 <GreaseMonkey> "The R6RS standard has caused controversy because it is seen to have departed from the minimalist philosophy."
01:55:34 <kallisti> that is not necessarily a bad thing. But I don't know anything about R6RS
01:56:20 -!- Jafet has joined.
01:56:52 -!- Vorpal has quit (Ping timeout: 244 seconds).
02:01:17 -!- Klisz has joined.
02:01:43 -!- MDude has quit (Ping timeout: 248 seconds).
02:07:26 -!- MSleep has joined.
02:13:02 <GreaseMonkey> if you attempt to include a completely empty file, it crashes
02:14:12 <kallisti> GreaseMonkey: that doesn't sound too weird.
02:14:45 <kallisti> they probably just overlooked the possibility of the empty file or something?
02:14:58 -!- zzo38 has quit (Remote host closed the connection).
02:15:33 <kallisti> what about files that contain characters but no trailing newline?
02:45:07 <tswett> Hm, I'm pondering this one problem. Implement a binary semaphore. The only atomic operation you're allowed is a swap operation: swap(x,y) atomically swaps the values of *x and *y.
02:45:56 -!- TeruFSX has joined.
02:46:56 <tswett> Arbitrarily many threads could be running at any time. They can sleep, they can revive each other, and they can interact with each other's memories.
02:47:42 <tswett> Yeah. They use shared memory.
02:47:57 <Sgeo> Oh, was thinking of the other definition of memory
02:48:12 <Sgeo> Which might require Feather to implement?
02:48:48 * Sgeo is not thinking too clearly right now
02:49:26 <tswett> My original thought was for the semaphore to be represented with a variable. The variable contains 0 when the semaphore is available, and 1 when it's unavailable. To try to procure the semaphore, a thread prepares a variable containing the number 1, and atomically swaps it with the semaphore variable.
02:51:42 <tswett> If the thread gets a 0 from this swap, it successfully got the semaphore. If it gets a 1 from the swap, it did not.
02:51:49 <Sgeo> What's the problem with that, unless you have a rogue threat deliberately messing with other threads?
02:52:13 <tswett> The problem with that is that there's no way to block on a semaphore. If you want to procure the semaphore, and it's unavailable, you have to busy loop.
02:53:29 <Jafet> You want to give out the semaphore in fifo order?
02:54:33 <tswett> Jafet: well, I want to give it out in *some* order. If thread A procures a semaphore, then thread B tries to procure it, then thread A vacates it, then it should somehow wind up in B's possession.
02:54:36 <Jafet> You could probably implement a queue with atomic swaps
02:54:56 -!- TeruFSX_ has joined.
02:55:00 <tswett> I've managed to create a queue that goes in the wrong direction. Each thread has a pointer to the thread before it in line.
02:55:01 <Jafet> You don't have a thread notification mechanism; how do you even do that?
02:55:36 <tswett> Unfortunately, once you're done with a semaphore, what you need to do is give it to the thread *after* you in line.
02:55:52 <tswett> Jafet: well, they have shared memory. To talk to a sleeping process, you change its variables and wake it up.
02:56:03 <Jafet> Okay, so you do assume a notification mechanism.
02:56:19 <Jafet> Well then, you should turn your queue the right way round, I guess.
02:56:20 -!- TeruFSX_ has quit (Read error: Connection reset by peer).
02:57:09 <tswett> The way the queue is built is... more or less the same as my original thought above. To try to procure the semaphore, you swap your own thread ID into the semaphore variable.
02:57:11 -!- TeruFSX_ has joined.
02:57:24 <tswett> Either you get a 0, meaning the semaphore is yours, or you get the ID of the guy before you in line.
02:58:30 <Jafet> What you could do is have each thread reserve a location in its memory, then write the memory address to the semaphore. The next thread writes its address to that address.
02:58:31 -!- TeruFSX has quit (Read error: Connection reset by peer).
02:58:51 <Jafet> Er, writes its thread-id to that address.
02:59:27 <tswett> What if two threads both read the semaphore variable at the same time, and then both write in their addresses at the same time?
03:00:02 <tswett> I guess right after you swap, you can give guy-before-you your thread ID. But what if guy-before-you tries to use your thread ID right before you give it to him...
03:00:10 <Jafet> Well, you'd need a small busy-loop while each thread atomically acquires its place in the queue.
03:00:43 <Jafet> I don't think there's any way around that.
03:01:53 <Jafet> Suppose that the zero address is invalid. Then a thread can lock the semaphore by swapping it with zero, add itself to the queue, and swap its memory address to the semaphore.
03:03:48 <tswett> Hm. Suppose that two threads try to swap zero into the semaphore at the same time.
03:04:36 <tswett> One of the threads will get a zero out. This means it can't proceed, so it has to sleep. Who wakes it up?
03:04:56 <kallisti> tswett: "queue that goes in the wrong direction" like a stack? :>
03:05:19 <tswett> kallisti: that... yeah, a lot like a stack!
03:05:53 <Jafet> tswett: it busy-loops for the minuscule amount of time it takes for the other thread to do two atomic swaps.
03:06:40 <tswett> Yeah, I guess busy looping may be fine if the thread it's waiting on is guaranteed to finish quickly.
03:07:57 <Jafet> It's probably theoretically impossible to do this with your primitives and no busy waiting
03:08:04 <Jafet> Also, isn't a binary semaphore only two-valued?
03:09:03 <tswett> A binary semaphore is what we're implementing; that doesn't mean we have to implement it on top of a Boolean variable.
03:09:19 <tswett> I do wonder if it is theoretically impossible. If it is, I ought to prove it.
03:09:27 * kallisti briefly imagines an "intuitionistic semaphore"
03:18:03 -!- copumpkin has joined.
03:31:49 -!- augur has joined.
03:49:18 -!- lambdabot has joined.
03:52:13 -!- Klisz has quit (Quit: You are now graced with my absence.).
04:05:28 -!- Jafet has quit (Quit: Leaving.).
04:25:39 <lambdabot> Graphics.Rendering.OpenGL.GL.VertexSpec Color3 :: a -> a -> a -> Color3 a
04:25:40 <lambdabot> Graphics.Rendering.OpenGL.GL.VertexSpec Normal3 :: a -> a -> a -> Normal3 a
04:25:40 <lambdabot> Graphics.Rendering.OpenGL.GL.VertexSpec TexCoord3 :: a -> a -> a -> TexCoord3 a
04:40:08 -!- augur has quit (Remote host closed the connection).
04:46:32 -!- augur has joined.
05:02:09 -!- kallisti has quit (Ping timeout: 260 seconds).
05:03:45 -!- kallisti has joined.
05:03:45 -!- kallisti has quit (Changing host).
05:03:45 -!- kallisti has joined.
05:05:22 -!- Klisz has joined.
05:18:15 -!- sebbu has joined.
05:18:16 -!- sebbu has quit (Changing host).
05:18:16 -!- sebbu has joined.
05:19:08 -!- sebbu2 has quit (Ping timeout: 244 seconds).
05:24:02 <kallisti> two monitors. so I can watch starcraft II games and get shit done
05:26:08 -!- zzo38 has joined.
05:32:26 -!- Nisstyre has quit (Quit: Leaving).
05:33:12 -!- Nisstyre has joined.
05:51:47 <zzo38> Can there be barrier monad transformer?
06:00:43 <kallisti> I'm not really sure I understand barrier monads
06:01:04 <zzo38> I am trying to do it; maybe this way I trying can work.
06:02:46 -!- oerjan has joined.
06:04:47 <oerjan> <oklopol> oerjan: let D : C^C \to C^C (let's say C_\infty functions only) be the differentiation operator, does it have a unique set of n periodic points of period n for all n?
06:05:26 <oerjan> a unique subspace of dimension n of periodic points of period | n
06:05:28 <kallisti> I'm supposed to format this as like...
06:05:37 <kallisti> but the title is like... three parts.
06:05:53 <kallisti> Ph.D., Dean, School of Computing and Software Engineering
06:06:15 <oerjan> generated by e^(m*2pi*ix/n) for m=0,...,n-1.
06:06:28 <kallisti> zzo38: can you explain a barrier monad?
06:06:36 <oerjan> @tell oklopol see logs
06:06:42 <zzo38> Semicolons exist but I don't know what context the document is
06:07:32 <oerjan> oklopol: er, scratch the formula, thinking too fast
06:07:42 <kallisti> Name, Ph.D.; Dean, School of Computing and Software Engineering
06:07:49 <kallisti> but the semicolon looks weird next to that .
06:08:16 <oerjan> it's e^(phi*x) where phi^n = 1, of course
06:08:25 <zzo38> kallisti: OK. data Barrier f b t = Unit t | Barrier f (b -> Barrier f b t); It means, there is a front type and a back type. The "yield" operation yields a front value and something else make a back value to continue. Similar to how generator functions in JavaScript are, a bit
06:08:25 <oerjan> of which there are n solutions.
06:09:00 <kallisti> zzo38: how does Unit fit into this?
06:09:18 <zzo38> Unit is the "return" operation: return = Unit;
06:10:13 <zzo38> Of course it is also functor and applicative; all monads are supposed to be also functor and applicative.
06:10:25 <oerjan> the case n=4 gives e^x, e^(-x), e^(ix) and e^(-ix), and the last two can be rearranged as (e^(ix)+e^(-ix))/2 and (e^(ix)-e^(-ix))/(2i), which you may recognize.
06:10:31 <kallisti> ah okay, so then the monadic function is the second field there. (b -> Barrier f b t)
06:11:01 <zzo38> There is actually a third constructor Fail String which is the "fail" operation and is also used for the Alternative instance
06:11:42 -!- copumpkin has quit (Quit: Computer has gone to sleep.).
06:11:55 <kallisti> zzo38: how does >>= work? is there a >>=?
06:12:21 <kallisti> or is there just a f :: Barrier f b t -> Barrier f b t ?
06:12:38 <kallisti> (to differentiate it from the front type)
06:12:39 <zzo38> Yes there is a >>= it is: Unit x >>= f = f x; Fail x >>= f = Fail x; Barrier a c >>= f = Barrier a $ c >=> f;
06:13:32 <kallisti> so the front value is... always the same?
06:14:10 <zzo38> kallisti: Do you know the "yield" command in Javascript? The "yield" command here is similar thing (which is the reason why it is called "yield").
06:14:22 <zzo38> yield = flip Barrier Unit;
06:14:25 <Sgeo> So, what's this Barrier thing?
06:14:50 <kallisti> only one question asker allowed. :P
06:15:33 <zzo38> Sgeo: See above; I specified the definitions
06:16:12 <oerjan> <oklopol> actually i sent a text to my colleague and he solved it in 2 minutes, ignore that.
06:17:24 -!- mtve has quit (Ping timeout: 260 seconds).
06:18:26 -!- yorick has quit (Ping timeout: 252 seconds).
06:19:12 -!- yorick has joined.
06:24:58 -!- Klisz has quit (Quit: You are now graced with my absence.).
06:27:11 <atehwa> kallisti: a system which has "truth values" for propositions is usually non-intuitionistic, because intuitionistic logic does not track truth but (constructive) provability.
06:28:14 <atehwa> It could be possible, of course, to model "justified" or "provable" with boolean values, but then it would be quite clear that two values would not suffice.
06:28:19 <kallisti> but it's a sort of truth-valued logic..
06:28:47 <zzo38> It is possible to make classical logic in Haskell, too, by making a class of law of excluded middle.
06:29:27 <kallisti> if I understand correctly, it's a three-valued logic? or maybe doesn't work like that and exists only as symbolic transformations.. ?
06:29:27 <atehwa> moreover, it's not impossible to prove x || not x if we already know that x is either provable or disprovable
06:29:38 <kallisti> atehwa: yes, I understand that.
06:29:45 <oerjan> i vaguely recall there's a proof that no number of truth values suffices for intuitionistic logic
06:29:54 <oerjan> it may be no finite number
06:30:17 <atehwa> kallisti: basically, intuitionistic logic is defined by those symbolic transformations
06:30:37 <atehwa> what you're trying to do is to give a "semantics" for those symbolic transformations
06:30:52 <atehwa> And I think it can be done by three-valued logic, but I'm not sure
06:30:52 <kallisti> basically implication, though it acts as a symbolic transformation.
06:31:15 <Sgeo> oerjan, so, if I were to do it in Haskell, would I require Integer or something, or is it not so straightforward?
06:31:15 <zzo38> Intuitionistic logic is the same as function types of Haskell (due to Curry-Howard).
06:31:18 <Sgeo> Or a recursive data type?
06:31:37 <atehwa> well, there's a whole lot of "rules" that describe transformations which are allowed in intuitionistic logic because they're considered "constructive"
06:31:47 <kallisti> Sgeo: zzo38: I was about to say function type is basically implication due to Curry-Howard.
06:31:57 <oerjan> for one thing, intuitionistic logic satisfiability is PSPACE complete, while any finite truth value operators can have it checked in NP. that's not a proof though since it's still not proved that NP /= PSPACE
06:32:03 <Sgeo> I don't quite understand Curry-Howard
06:32:28 <atehwa> (p ||q) && not p => q is _not_ one of the allowed transformations, whereas (p => q) && p => q is.
06:33:09 <kallisti> Sgeo: okay so basically types in programs are like mathematical formula, and the program that the type describes is a proof of that formula.
06:33:38 <kallisti> Sgeo: so when you write the type a -> b you're actually talking about a logical implication.
06:34:34 <Sgeo> And when I write a -> b?
06:34:41 <Sgeo> (I think I saw something about this)
06:35:10 <Sgeo> The fact that there's no way to write a -> b (without cheating) means a -> b cannot be proved, or something?
06:35:22 <oerjan> Sgeo: i guess that you could use kripke models as your representation for intuitionistic logic. i recall playing around with those.
06:35:30 <Sgeo> kripke models?
06:35:49 <kallisti> Sgeo: well there's no proof of -> in intuitionistic logic because it's basically the axiom of intuistionistic logic.
06:37:21 <oerjan> http://en.wikipedia.org/wiki/Kripke_semantics#Semantics_of_intuitionistic_logic seems quite unreadable.
06:38:17 <zzo38> Some proofs are simple: doubleNot = flip id; contrapositive = flip (.); deMorgan x = either (fst x) (snd x);
06:38:19 <oerjan> well, the notation anyway.
06:40:09 <lambdabot> forall a b (f :: * -> *). (Functor f) => f a -> (a -> b) -> f b
06:40:10 <Sgeo> Because I'm lazy
06:40:27 <zzo38> :t flip (Prelude..)
06:40:28 <Sgeo> :t flip (Prelude..)
06:40:28 <lambdabot> forall b c a. (a -> b) -> (b -> c) -> a -> c
06:40:29 <lambdabot> forall b c a. (a -> b) -> (b -> c) -> a -> c
06:40:34 <oerjan> say you want to show that p || not p is not provable in intuitionistic logic, by finding a kripke model in which it's not true in all frames.
06:41:01 <zzo38> In this case, c is Zero (an uninhabited type)
06:41:16 <kallisti> oerjan: what's the type for not in Haskell?
06:41:59 <oerjan> let frame 1 be one in which p is false, and frame 2 be one in which p is true. that satisfies the condition. but then not p is false in frame 1 because p is true in a later frame. and p || not p is false in frame 1 because both p and not p are false there.
06:42:45 -!- Jafet has joined.
06:44:26 <oerjan> kallisti: b should be Void
06:45:06 <oerjan> Void is the representation of false.
06:45:18 <zzo38> I called the uninhabited type Zero and defined as: data Zero; type Not x = x -> Zero;
06:46:17 <kallisti> hmmm okay, but then what's the proof?
06:46:21 <zzo38> Note you could represent natural numbers by using Zero as number zero and Maybe as successor. If there is such a thing as types that are only capable of holding bijective functions, you could use that to prove equality of natural numbers.
06:46:52 <oerjan> kallisti: proof of what?
06:47:28 <oerjan> kallisti: to proven negation of x, you construct a contradiction from x. i.e. you construct an element of Not x.
06:48:08 <kallisti> oerjan: oh okay. so in Haskell data types with constructors are automatically proven, basically.
06:48:33 <kallisti> if they're made of things that are proven (??)
06:48:37 <oerjan> they're automatically proven if you can find the arguments to their constructors...
06:49:05 <zzo38> For example: Not Zero proven by the function id
06:49:41 <kallisti> "prove that booleans are true." "okay here you go I made them"
06:51:06 <oerjan> <kallisti> but not p && p cannot in general be proven (???) <-- it can be disproven.
06:51:48 <oerjan> of course with that one in particular, that's a little circular semantically
06:52:13 <lambdabot> forall b. (b -> Bool) -> b -> Bool
06:52:27 <zzo38> explosion :: (p, Not p) -> q; explosion (x, y) = contradiction $ y x; where contradiction :: forall t. Zero -> t;
06:52:39 <oerjan> kallisti: @djinn is an intuitionistic prover
06:53:36 <oerjan> Void is an uninhabited type. you cannot actually construct it, it's a representation of a contradiction.
06:54:03 <lambdabot> data Either a b = Left a | Right b
06:54:07 <lambdabot> class Monad m where return :: a -> m a; (>>=) :: m a -> (a -> m b) -> m b
06:54:08 <lambdabot> class Eq a where (==) :: a -> a -> Bool
06:54:29 <kallisti> ah okay, so then Not Void is the only valid type for a in data Not a = Not (a -> Void)?
06:54:30 <oerjan> hm not sure where that void is defined.
06:54:52 <oerjan> kallisti: recursive types are not allowed in this context.
06:58:05 <oerjan> that Bool definition is somewhat unrelated to the intuitionistic truth values
06:58:13 <oerjan> which are Void and Not Void, really
06:58:35 <kallisti> Bool is a sum type of... unit types?
06:59:27 <oerjan> yeah. @djinn's main purpose is to construct haskell functions with prescribed types, so the intuitionistic part is sort of just underlying.
07:01:58 <oerjan> @djinn Either a b -> (a -> c) -> (b -> c) -> c
07:02:32 <kallisti> oerjan: also, are primitive types kind of just... unproven?
07:03:29 <oerjan> @djinn doesn't deal with those, i think. it's not _really_ haskell, but a fragment without nontermination and without recursive types.
07:03:51 <kallisti> ah, well, the Haskell Report does define Int as a huge number of constructors right?
07:04:00 <Sgeo> What does Either a b mean in the context of intuitionistic logic?
07:04:04 <oerjan> and you can define new nonrecursive types.
07:05:14 <kallisti> also the | in data declarations is also or.
07:05:19 <Sgeo> Can I read that as "If I have a proof of a or b, and I have a proof of if a then c, and I have a proof of if b then c, then c?
07:05:20 <oerjan> kallisti: well yeah. it's not expected that implementations actually _use_ that representation. :P
07:05:33 <Sgeo> Or do I have to do currying?
07:06:16 <Sgeo> Partial functions don't count as proofs, right? Otherwise I could prove Either a b -> a
07:06:48 <Sgeo> What does Maybe a mean?
07:07:02 <Sgeo> And how do I do logical and?
07:07:10 <zzo38> Logical and does (,)
07:07:12 <oerjan> it's isomorphic to Either () a
07:07:15 <zzo38> And logical or does Either
07:07:45 <zzo38> Maybe makes it always true it is always provable by Nothing
07:07:46 <Sgeo> oerjan, I take it that that's essentially useless, since it should always be true
07:08:00 <zzo38> For numbers, you might use Maybe for successor, though
07:10:09 <kallisti> type Bool = Either () () -- yes?
07:10:17 <oerjan> kallisti: essentially :P
07:10:31 <oerjan> and () is useless since you can construct it on the fly
07:11:12 <Sgeo> Why have anything other than Either, (,), and ()?
07:11:25 <oerjan> i _think_ @djinn makes an attempt to use as many arguments as possible, i.e. it's slightly preference for linear logic. so it's not _entirely_ useless.
07:11:37 <oerjan> @djinn Maybe a -> (a -> b) -> Maybe b
07:11:58 <zzo38> Since it is isomorphic to Either () a that is why it can be successor, if Either is addition, if you have a type of bijective functions: Either () a <-> Maybe a { Left () -> Nothing; Right x -> Just x; } if you had a <-> type then you could *prove* it to be isomorphic.
07:12:08 <kallisti> Sgeo: that's basically what intuitionistic type theory is. (don't forget Void)
07:12:53 <zzo38> oerjan: It is: f = flip fmap
07:14:04 <oerjan> <Sgeo> Why have anything other than Either, (,), and ()? <-- the others are defined using @djinn's definition mechanism
07:14:11 <lambdabot> djinn provides: djinn djinn-add djinn-del djinn-env djinn-names djinn-clr djinn-ver
07:14:36 <oerjan> @djinn-add Fnord a b = Fnord a (b -> a)
07:14:43 <oerjan> @djinn-add data Fnord a b = Fnord a (b -> a)
07:14:45 <zzo38> If you had bijective function type then the types as numbers can be: uninhabited type for zero, Maybe for successor, Either for addition, (,) for multiplication, -> for exponent, <-> with same type on both sides for factorial
07:14:49 <Sgeo> @djinn (a -> b) -> Void
07:15:21 <oerjan> Sgeo: i just defined it :P
07:15:43 <Sgeo> I have no idea what it means
07:15:47 <lambdabot> Either Left Right Maybe Nothing Just Bool False True Void Not Void Monad Eq Bool Fnord Fnord
07:16:01 <Sgeo> @djinn Void -> Void
07:16:09 <oerjan> there seems to be some duplication there...
07:16:12 <Sgeo> @djinn Void -> (a -> b)
07:16:46 <zzo38> It should be: void x = case x of { } but Haskell doesn't accept that
07:16:52 <oerjan> Sgeo: void :: Void -> a
07:17:09 <oerjan> yeah it may be a special case
07:17:11 <Sgeo> So basically, a statement that if you proven void, you can prove anything
07:18:44 <Sgeo> @djinn (Void -> a) -> a -> b
07:18:55 <zzo38> In TNT, (exist a. x) is equivalent to (not (forall a. not x))
07:18:57 <Sgeo> Well, that does make sense
07:19:23 <oerjan> @djinn (a -> Void) -> a -> b
07:19:52 <lambdabot> Either Left Right Maybe Nothing Just Bool False True Void Not Void Monad Eq Bool
07:20:04 <Sgeo> @djinn Not Void
07:20:06 <zzo38> And if you have x{5} or x{anything} then you can make (exist a. x{a})
07:21:18 <zzo38> Is it possible to do this in Haskell?
07:21:39 <oerjan> zzo38: sounds pretty much like dependent typing, so no.
07:22:06 <oerjan> hm maybe on the type level
07:22:29 <oerjan> and who knows with the new type -> kind lifting that's coming up
07:22:34 <zzo38> To be specific, I mean of making (exist a. x{a}) from (x{5}) or whatever
07:22:47 <zzo38> What is type -> kind lifting?
07:24:51 <Sgeo> How did it figure out Not Void?
07:25:40 <Sgeo> How does Not work
07:26:10 <lambdabot> data Either a b = Left a | Right b
07:26:14 <lambdabot> class Monad m where return :: a -> m a; (>>=) :: m a -> (a -> m b) -> m b
07:26:16 <lambdabot> class Eq a where (==) :: a -> a -> Bool
07:26:39 <Sgeo> Ah, I'm starting to get an understanding of it now
07:27:05 <Sgeo> Does Not need to be a type?
07:27:16 <oerjan> zzo38: http://www.reddit.com/r/haskell/comments/mm68o/ghc_74_branched_whats_in_for_christmas/c328u7i has a small example
07:27:26 <oerjan> well the reply to that
07:27:34 <Sgeo> @djinn Either a (Not a)
07:27:53 -!- Vorpal has joined.
07:27:56 <zzo38> How would dependent types allow you to make (exist a. x{a}) from (x{5})? GHC does have a existential types extension
07:28:42 <oerjan> zzo38: well it's the part of using the value 5 rather than a type to quantify over, which is problematic.
07:29:01 <oerjan> and which _might_ work with the new extension, i don't know
07:29:12 <zzo38> But I mean for any type in general, not necessarily 5
07:29:29 <oerjan> well then i guess ghc can do some of it on the type level.
07:30:16 <oerjan> data Exists x = forall a. Exists (x a)
07:31:36 <oerjan> zzo38: dependent types is when you allow types to depend on values. and ghc does not support it fully, not even with the new extension.
07:32:18 <zzo38> Actually, in the case I given, the 5 *will* be a type, such as (Maybe (Maybe (Maybe (Maybe (Maybe Zero)))))
07:32:40 <zzo38> So it won't depend on a value.
07:33:04 <pikhq_> So, it's a bit more that you're doing type-level computation.
07:33:20 <oerjan> well then it should be possible. although there may be further difficulties when you unpack it from the existential again (you cannot compare well things unpacked at different points)
07:33:43 <zzo38> No I mean to prove it by writing functions like how Curry-Howard is
07:41:11 <zzo38> I do have idea of bijective function syntax: A new built-in type "<->" which is like "->" but only bijective functions (a value of this type is allowed to be undefined but can return undefined if and only if the input is undefined), a new keyword "bijective" which introduces layout, and new built-in functions called "inverse" and "runBijective"
07:42:47 <zzo38> inverse :: (a <-> b) -> (b <-> a); runBijective :: (a <-> b) -> a -> b;
07:44:40 <zzo38> The bijective keyword would make a value having a <-> type, and inside would be something similar to a case block (but with some restrictions).
07:45:21 <zzo38> Would this seem to work to you?
07:45:37 <oerjan> i expect finding the right restrictions is the hard part here.
07:48:48 <zzo38> You should also allow bijective functions to be called directly without the use of runBijective (and calling bijective functions directly would be allowed in a bijective case block). I do have some ideas about the restrictions. For example, each variable used on either side must be used exactly once on each side
07:51:19 <oerjan> well my doubt is whether simple restrictions will allow you to write all the bijective functions you want.
07:52:32 <zzo38> Other restriction would be you would be disallowed to write values of recursive types
07:52:40 <oerjan> for example, if f is a halting but otherwise non-bijective function, then g x = x `xor` f x is a bijective function.
07:53:16 <oerjan> *for example, if f is a halting but otherwise non-bijective function, then g (x, y) = (x, y `xor` f x) is a bijective function.
07:54:19 <oerjan> and there are other functions than xor which work that way... any group operation for example.
07:55:13 <oerjan> this is what i thought of when i was pondering reversible computing previously.
07:56:14 <zzo38> You might need to add additional built-in functions
07:57:56 <zzo38> But I don't know if that would make it complete
07:59:32 <zzo38> I also don't know how you would use it to prove that there is no such bijective function of types (such as: Not (Zero <-> Maybe Zero))
08:04:38 <zzo38> A proof in intuitionistic or classical logic using Curry-Howard would require all functions written to halt, and that is assumed and the logic still works. Maybe something similar can still work with bijective function type?
08:09:53 <oerjan> linear logic seems somewhat relevant, but not perfectly.
08:10:18 <oerjan> it has the "every argument must be used exactly once" property
08:11:02 <oerjan> but it still allows a function and an argument to combine in a nonreversible way.
08:13:43 <Sgeo> I wonder if you could do STM-like stuff without actual repeats (using blocking instead) by using an arrow instead of a monad
08:14:32 <Sgeo> That way, all information about what variables may be accessed is known statically, and thus the system can check for conflicting variable access
08:14:47 <Sgeo> Before running the thread
08:15:09 <oerjan> arrows or applicatives, maybe.
08:15:29 <Sgeo> Are arrows applicatives?
08:15:41 <oerjan> such prescheduling is supposed to be one of the advantages of arrow/applicative parsers.
08:16:07 <oerjan> when you fix the first type argument
08:17:47 <oerjan> http://cdsmith.wordpress.com/2011/07/30/arrow-category-applicative-part-i/
08:20:34 <oerjan> (btw the answer to the title question is "not quite")
08:20:48 <oerjan> as you need some extras in the other direction.
08:21:25 <zzo38> Could you define applicative in terms of fmap and liftA2 (,) and pure
08:22:37 <oerjan> zzo38: yes. i think that was mentioned in one of the comments to that link.
08:22:48 <oerjan> lax strong monoid something
08:24:14 <zzo38> Can you add something weaker than join or >>= that can still define a monad from an applicative, because join or >>= can be defined from this new thing and the applicative things
08:25:35 -!- monqy has quit (Quit: hello).
08:26:53 -!- GreaseMonkey has quit (Quit: The Other Game).
08:27:42 -!- mtve has joined.
09:15:18 -!- derdon has joined.
09:31:40 -!- oerjan has quit (Quit: leaving).
09:50:49 -!- zzo38 has quit (Remote host closed the connection).
10:49:03 -!- derdon has quit (Remote host closed the connection).
10:54:32 -!- ais523 has joined.
11:57:56 -!- zzo38 has joined.
12:03:22 <oklopol> oerjan: ah, your proof if even nicer than his.
12:03:22 <lambdabot> oklopol: You have 2 new messages. '/msg lambdabot @messages' to read them.
12:19:49 <kallisti> The phrase quod erat demonstrandum is a translation into Latin from the Greek ὅπερ ἔδει δεῖξαι (hoper edei deixai; abbreviated as ΟΕΔ). Translating from the Latin into English yields, "what was to be demonstrated";
12:19:59 <kallisti> that's what all the cool mathematicians say instead.
12:21:34 * Sgeo envisions representing a computable real with a list of tuples, the first number of the tuple being an approximation, and the second being the how far off the approximation is, such that the second number is equal to or larger than the error
12:21:47 <Sgeo> Presumably, later values in the list would be better approximations
12:22:17 <Sgeo> Although I'm pretty sure there's some other infinite list representation of reals somewhere
12:22:29 <kallisti> How do you compute how far off the approximation is from the real value without already having information about the number?
12:23:15 <Sgeo> kallisti, the error given in the second number of the tuple may be larger than the actual distance between the approximation and the actual value
12:23:26 <Sgeo> I'm presuming there is an actual value, just not easy to represent
12:23:43 <Sgeo> I think it makes sense to say that pi is 3 plus or minus .15
12:24:47 <kallisti> e is kind of like 0 plus or minus infinity.
12:25:57 <Sgeo> If the approximations don't converge, then it doesn't represent an actual number
12:26:11 <Sgeo> Can still do comparisons though, in some cases
12:26:59 <Sgeo> I should write some code for this
12:29:57 <Slereah> Markov wrote a whole article on writing down definable numbers!
12:30:29 <Slereah> Where fgh are recursive functions
12:34:04 <Sgeo> Although I have a feeling you're referring to a historical source
12:34:07 <Sgeo> But still, linky?
12:34:23 <Slereah> I can give you the reference
12:37:51 <Slereah> Марков, А. А. О конструктивных функциях
12:38:07 <Slereah> Or just Markov, "On Constructive Functions"
12:38:51 <Jafet> No doubt it's already been scanned
12:39:02 <Jafet> And sold to universities
12:39:13 <Sgeo> http://www.haskell.org/pipermail/haskell-cafe/2011-May/091585.html
12:39:16 <Slereah> I got it from a book that I bought because I could not find an article in it anywhere
12:39:21 <Sgeo> infinity = Succ infinity
12:39:31 <Sgeo> I find the properties of that fascinating
12:39:44 <Sgeo> infinity > any finite natural number
12:40:05 <Sgeo> infinity > infinity = _|_
12:41:08 <Sgeo> Hmm, might break on *
12:41:27 <Sgeo> Since probably * is defined with Zero on one of the sides as making it = Zero
12:41:34 <Sgeo> When the result should probably be _|_
12:43:16 <Sgeo> But then you break the notion of a == b implying a-b==0
12:43:45 <Jafet> Oh, no! Extending a field with infinity does not produce a field!
12:45:51 <lambdabot> [1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,...
12:45:54 <Jafet> Actually, I think 0ω is defined as 0.
12:46:09 <lambdabot> Couldn't match expected type `[t1] -> t'
12:46:17 <Jafet> So it works out fine, as long as you use unamb.
12:46:30 * Sgeo non-arbitrarily decides that a better representation of definable reals is as an infinite list of tuples, but the tuples are a lower and upper bound
12:46:34 <kallisti> Haskell needs to fix this bug. :P
12:46:44 <Sgeo> Rather than average and distance
12:46:53 <Sgeo> Makes it easier to define sine
12:47:27 <Jafet> That doesn't really define definability
12:48:02 <Sgeo> Are there definable numbers that don't fit the mold? I think I'm fine with some lists that don't represent definable numbers
12:48:34 <Jafet> You seem to have described the set of real numbers.
12:50:01 <Sgeo> Note: My Haskell library has no intention of making it possible to define undefinable numbers. If you manage to do this with my library, the destruction of the universe is on your hands.
12:52:55 -!- elliott has joined.
12:53:17 <lambdabot> elliott: You have 1 new message. '/msg lambdabot @messages' to read it.
12:53:43 <elliott> <lambdabot> ais523 said 15h 26m 2s ago: I didn't delete "why testing is good" and the other one, Keymaker did
12:53:48 <elliott> ais523: should have protected it!
12:54:00 <ais523> elliott: protection has no correlation with deletion at all?
12:54:01 <elliott> in fact, we should just protect all the spam pages...
12:54:11 <ais523> in fact, nowadays, you can typically even protect a page that doesn't exist
12:54:16 <ais523> although I'm not sure if Esolang implements that
12:54:31 <kallisti> @tell kallisti something important.
12:54:32 <elliott> ais523: well, I presume people think twice before deleting a protected page
12:55:37 <ais523> elliott: not if it was protected because elliott thinks that protecting spam is a good idea
12:55:50 <ais523> hmm, I wonder if there's a wiki on the Internet whose only purpose is to be edited by spambots
12:55:56 <elliott> ais523: yes, but you're more reliable than that! :P
12:56:03 <ais523> and it's just left with registration and anonymous editing open, and left there
12:56:36 <ais523> the problem is, it'd be basically impossible to find
12:56:37 <elliott> 18:22:35: <Vorpal> pikhq_, do you often visit Japan?
12:56:38 <elliott> 18:22:43: <pikhq_> Vorpal: No.
12:56:38 <elliott> 18:22:54: <pikhq_> Vorpal: In fact, I have never been.
12:56:38 <elliott> 18:23:01: <Vorpal> what do you use your Japanese knowledge for then?
12:56:40 <ais523> as any sane search engine would sort it to the bottom
12:56:46 <elliott> ais523: you could advertise it
12:56:50 <ais523> elliott: Japanese is actually a vaguely useful language to know
12:56:58 <elliott> then your spambots start editing your own wiki...
12:57:11 <elliott> I am Wikipedia programmer Brandon Harris. AMA (self.IAmA)
12:57:17 <ais523> I come across words in languages I don't understand, occasionally
12:57:24 <ais523> and Japanese is one of those languages
12:57:25 * elliott just stares at that headline for a while.
12:58:50 <ais523> what's stareworthy about the headline?
12:59:35 <elliott> ais523: I have trouble conceiving of Wikipedia programmer Brandon Harris as a real person, he's just that guy in the donation boxes
13:00:02 <ais523> there was no issue for me
13:00:16 <ais523> in the TV series, Big Brother is a real person too
13:00:19 <ais523> several, I think, who work in rotation
13:01:33 <kallisti> elliott: Brandon Harris, antagonist to the man.
13:02:04 <elliott> for twelve years you have been asking, "who is brandon harris?"
13:02:09 <elliott> this is brandon harris speaking.
13:05:12 <elliott> "I also work for Wikipedia, and had a rather scary email recently: "Before you edit a banner or update some code, just remember that if our readership was a country it would be the 3rd largest country in the world.""
13:07:03 <HackEgo> 2011-11-28.txt:13:02:04: <elliott> for twelve years you have been asking, "who is brandon harris?"
13:07:28 <HackEgo> http://codu.org/projects/hackbot/fshg/index.cgi/raw-file/tip/paste/paste.24786
13:07:54 <itidus21> 2011-10-05.txt:19:38:28: <Phantom_Hoover> "A personal appeal from Wikipedia programmer Brandon Harris."
13:08:41 <elliott> ais523: haha, wikipedia had to take down the fundraising statistics page because of the traffic from reddit
13:08:59 <ais523> that sort of thing actually happens occasionally
13:09:20 <kallisti> elliott: I feel like reddit is like this hivemind of horrible internet trend stuff.
13:09:36 <ais523> when you get up to Admin level, you have to be careful to avoid Wikipedia slashdotting itself
13:09:52 <elliott> ais523: but how.............
13:09:57 <ais523> you need to know which bits can handle heavy traffic and which bits can't
13:10:23 <ais523> (hint: you don't want to hit the toolserver on every page read, or even every edit (more than it's currently hit, that is))
13:10:37 <elliott> ais523: hmm, is there only /one/ toolserver?
13:10:39 <ais523> likewise, you can hit the API on every read, but not really perform more than a few queries
13:10:51 <elliott> ais523: "The Wikimedia Toolserver is a collaborative platform providing Unix hosting for various software tools written and used by Wikimedia editors. The service is operated by Wikimedia Deutschland e.V. with assistance from the Wikimedia Foundation.
13:10:51 <elliott> It consists of thirteen servers as outlined here."
13:10:59 <ais523> hmm, it looks like one
13:11:01 <elliott> no it's not, I found the answer before you gave me an incorrect one :P
13:11:12 <elliott> ais523: so does wikipedia itself :P
13:11:30 <ais523> FWIW, there's only one physical server that handles write changes
13:11:34 <ais523> as in, things that handle the database
13:11:38 <ais523> the vast majority of them are for reads
13:11:40 <elliott> https://wiki.toolserver.org/w/images/b/b5/Toolserver-cluster.svg
13:11:51 <ais523> which makes sense, given Wikipedia's load patterns
13:12:10 <elliott> ais523: I can't help but feel that Wikipedia could do a lot better than it could if it wasn't tied to its software
13:12:17 <ais523> (I think they can trivially hot-swap /which/ server handles the writes, though, for redundancy)
13:12:37 <ais523> yep, MediaWiki is painful
13:12:52 <ais523> it's excellent in terms of its user-facing behaviour, but behind the scenes it's a mess
13:13:06 <elliott> there's no need to have a linear history at all, for one thing
13:13:28 <ais523> "see page as of time X" is a useful operation
13:13:38 <elliott> ais523: yep, but that's not the same thing
13:13:41 <ais523> although nonlinear histories can be linearised for that purpose
13:13:55 <elliott> ais523: I mean, you could easily allow edits to be done on N servers instead of 1
13:13:59 <kallisti> elliott: how do you stalk people with differing viewpoints from your own so you can call them out as deletionists or pushing a POV?
13:14:00 <elliott> and just merge it afterwards
13:14:09 <elliott> ais523: although you have to block the confirmation page until the merge happens
13:14:13 <elliott> so you can notify of conflicts
13:14:27 <kallisti> elliott: well I guess no linear history wouldn't affect the user changes log.
13:15:14 <ais523> I don't think Wikipedia's designed to take Linus' Law into account, either
13:15:22 <kallisti> (note: not actually joking. people do that.)
13:15:26 <ais523> hmm… MediaWiki's storage model is essentially what git's designed for
13:15:46 <ais523> kallisti: I've been known to stalk suspected trolls/spammers/vandals before now in order to make sure
13:16:10 <ais523> and yet it ignores most of the optimisations git's made to handle that
13:16:22 <elliott> ais523: yes, MediaWiki suffers from being developed before common RCSes
13:16:37 <elliott> (RCS wouldn't work very well :P)
13:16:38 <ais523> does SVN use reverse diffs for storage?
13:16:46 <elliott> dunno anything about SVN's storage
13:17:32 * ais523 frowns at the TDWTF discussion of the twelve weights problem
13:17:43 <elliott> ais523: mediawiki is only 2 years older than svn, anyway
13:17:52 <ais523> because it's actually solvable with 13 (at least if you only care about knowing the odd one out, not lighter/heavier), and everyone's missed it so far
13:18:02 <elliott> so it wasn't really an option at the time, I wouldn't think
13:18:08 <ais523> elliott: wow, it's hard for me to envisage something revision-control-like being older than SVN
13:18:11 <ais523> apart from CVS and RCS
13:18:31 <elliott> ais523: open-source VCS is novel field, really
13:18:38 <elliott> it only got started around 2001
13:18:45 <elliott> I mean, anything other than CVS
13:19:34 <kallisti> before VCS closed source developers collaborated via email attachments.
13:19:49 <elliott> ais523: list of VCSes older than SVN:
13:20:12 <elliott> Software Change Manager (1970s) ClearCase (1992) CMVC (1994) Visual SourceSafe (1994) Perforce (1995) StarTeam (1995)
13:20:16 <elliott> TeamWare (1990s?) Code Co-op (1997) BitKeeper (1998)
13:20:21 <ais523> elliott: you can't cure my prejudices with facts!
13:20:41 <elliott> ais523: no, but I can cause you severe cognitive dissonance! MWAHAHAHAHA
13:21:02 * kallisti 's cognitive dissonance sounds awesome.
13:22:03 <ais523> gah, my IRC client prints elliott's and kallisti's name in the same color, and I keep reading kallisti's lines as being from elliott and having to do a double-take
13:22:06 <kallisti> even reading the article on cognitive dissonance fills me with anxiety about cognitive dissonance.
13:22:19 <ais523> also, that line of mine, I typed "color" then spend around 4 seconds wondering whether "colour" would be a better spelling
13:22:20 <kallisti> ais523: this is because we are almost the same person.
13:22:32 <elliott> ais523: turn off nick colouring, then you just mix people up because of similar names
13:23:40 -!- MSleep has changed nick to MDude.
13:24:01 <kallisti> dude what if we had hair on our palms?
13:24:05 <kallisti> handshakes would be so much weirder.
13:33:33 * ais523 is not entirely convinced that kallisti is not a spambot
13:34:08 <Jafet> fungot, can you do handshakes?
13:34:08 <fungot> Jafet: " who says?" screamed glod. " he was no longer an option. he could hear the sounds of argument coming from the fnord fnord.
13:34:29 <kallisti> ais523: The word douche came to English via French – where today it means shower (from Italian: doccia "conduit pipe" and docciare "pour by drops"). It is thus a notorious false friend encountered by non-native speakers of English.
13:34:53 <ais523> kallisti: the funny thing is, I actually know its French meaning rather better than its English one
13:39:53 <elliott> I bet that fizzie is here.
13:43:15 <ais523> I think elliott would get better odds on his/her bet
13:43:45 <elliott> I would indeed get better odds on his/her bet.
14:01:48 <elliott> bah, @ has made me unable to be interested in low-level OS news
14:02:29 <kallisti> elliott: oh my god I decided to visit reddit on my own free will what have I done
14:03:12 <kallisti> yes you hit random and it /goes to random thingies/
14:03:18 <elliott> who the hell looks at the top bar
14:03:28 <elliott> http://www.reddit.com/r/RATS/ rats
14:05:29 <kallisti> http://www.reddit.com/r/somethingimade/
14:06:52 <kallisti> elliott: show off awesome perl scripts here.
14:06:55 <kallisti> http://www.reddit.com/r/nostalgia/
14:07:01 <kallisti> elliott: reflect on painful childhood memories.
14:08:57 <Vorpal> <ais523> FWIW, there's only one physical server that handles write changes <ais523> as in, things that handle the database <-- very doubtful that mediawiki wouldn't use a distrubuted database server. Doesn't even mysql support that nowdays? I know postgre supports it well for example.
14:09:11 <kallisti> http://www.reddit.com/r/frugalmalefashion/
14:09:44 <kallisti> http://www.reddit.com/r/actuallesbians/
14:10:15 <kallisti> http://www.reddit.com/r/Psychonaut/
14:10:23 <Sgeo> In the "X is a monad" series:
14:10:36 <Sgeo> A certain way of writing BF programs is a monad (I think)
14:11:15 <elliott> Vorpal: maybe ais523 means "one hostname" like he did with the toolservers:P
14:11:16 <Sgeo> State representing locations of variables
14:11:52 <Sgeo> Run the monad, which must return something of a certain type, and you get a BF program
14:11:54 <kallisti> elliott: ah help kallisti is always taken how do I make usernames?
14:12:43 <elliott> kallisti: if you do sign up to reddit, i suggest the first thing you do is to unsubscribe from all default subreddits
14:12:55 <elliott> at least /r/{pics,funny,politics}
14:13:14 <elliott> kallisti: /r/politics is actually US politics (is actually US politics circlejerk)
14:13:17 <kallisti> but maybe there are better news sources.
14:13:23 <kallisti> elliott: that's fine I like that .
14:13:38 <Vorpal> elliott, anyway you still need to propagate writes in a consistent order, even with a distrubuted db. At least if you want a consistent history for edits like mediawiki does
14:14:33 <Vorpal> hm an obvious solution to load balancing here would be to hash the article identifier and use that to select which database server to use. Don't even need distributed databases for it
14:14:36 <elliott> Vorpal: only a few things need consistent ordering in MW
14:14:37 <Deewiant> Also /r/{atheism,gaming} and maybe /r/{IAmA,todayilearned} and /r/AskReddit
14:14:49 <elliott> /r/atheism isn't default these days
14:15:04 <Deewiant> They appeared to be, I just logged out to check
14:15:11 <elliott> Oh, gaming and atheism are
14:15:51 <kallisti> elliott: it's like they want /r/atheism to be full of controversy
14:15:53 <elliott> kallisti: OK, here's an unsubscribe list: /r/{pics,funny,atheism,politics,WTF,AskReddit,AdviceAnimals} and most likely /r/{gaming,todayilearned}
14:16:21 <Deewiant> You definitely want out of /r/gaming, there are better replacements
14:16:29 <elliott> Deewiant: Yeah, I'm not subscribed so I didn't feel qualified to say
14:16:39 <elliott> kallisti: No, it's not full of controversy at all, /r/atheism is actually the internet's largest circlejerk
14:16:51 <Deewiant> /r/{Games,gamernews,truegaming}
14:17:04 <Deewiant> Depending on what you want, you can pick (I'm subbed to all three)
14:17:08 <kallisti> or maybe it's falsegaming acting like truegaming
14:17:08 <Deewiant> truegaming is only for discussions
14:17:08 <elliott> kallisti: Okay, what Deewiant said, except don't subscribe to anything starting with "true"
14:17:19 -!- Madoka-Kaname has quit (Remote host closed the connection).
14:17:27 <Deewiant> Of true* I'm only in TrueReddit and truegaming
14:17:32 <Deewiant> I find they have interesting content
14:17:40 -!- Madoka-Kaname has joined.
14:17:49 <elliott> Deewiant: Maybe, I just can't stand the implicit elitism :P
14:17:58 <elliott> http://www.reddit.com/r/TrueTrueReddit
14:17:59 <itidus21> so my brother has skyrim.. watching him play it makes my life feel painfully inadequate.
14:18:01 <Deewiant> I'm in it for the links, not the comments :-P
14:18:02 <elliott> This is actually a real non-joke subreddit.
14:18:10 <kallisti> http://www.reddit.com/r/content/ omg so much content
14:18:11 <elliott> "As TrueReddit grows, it will become less like TrueReddit. See "Hot Tubbing an Online Community" for thoughts as to why. By virtue of the fact that it is smaller, and will not yet make /r/all, TrueTrueReddit is better equipped to adhere to its own standards."
14:18:12 <Vorpal> itidus21, why don't play it yourself too?
14:18:15 <Deewiant> TrueTrueReddit used to be a joke
14:18:32 <itidus21> Vorpal: do you want the real answer?
14:18:35 <kallisti> itidus21: I don't understand the hype around Skyrim actually.
14:18:41 <Vorpal> itidus21, why do you ask?
14:18:56 <itidus21> kallisti: it looks like so much freaking fun thouhg
14:18:58 <elliott> kallisti: Oh, and don't subscribe to /r/programming, though it isn't default
14:18:59 <Vorpal> kallisti, not a good game. A fun game sure, but too buggy to be a good game
14:19:13 <kallisti> elliott: that would be like going to the programming board on 4chan.
14:19:16 <Deewiant> /r/AskReddit can be moderately interesting for some things but I think it's best to just take a quick look at the topics once a week or so than have it on your frontpage all the time
14:19:19 <elliott> kallisti: /r/coding is... "okay", but /r/haskell is the only decent programming subreddit I know of
14:19:22 <elliott> At least, that I care about
14:19:28 <Vorpal> kallisti, somehow after I saved a game I got a non-random quest a second time.
14:19:31 <elliott> Actually it's one of the only reasons I use reddit still :P
14:19:32 <kallisti> elliott: I am an expert at internetz brah, I've got this.
14:19:34 <Deewiant> elliott: You know that /r/programming is better these days, right?
14:19:47 <elliott> Deewiant: I read it every day; it really isn't
14:19:57 <kallisti> Vorpal: certainly less buggy than previous Bethesda games
14:20:08 <elliott> Deewiant: OK, the links are usually interesting, but then I check the comments and everything goes downhill
14:20:12 <kallisti> Vorpal: or well, many many many games that people have flooded money into.
14:20:14 <elliott> Deewiant: Especially if it involves Haskell :)
14:20:25 <Deewiant> elliott: The solution to this for you is: don't check the comments
14:20:31 <Vorpal> kallisti, well maybe on release. I didn't play oblivion until some fairly late patch
14:20:34 <Deewiant> elliott: (For others, it's also "don't care about the comments" but I doubt that works for you)
14:20:34 <elliott> Deewiant: I can't stop myself
14:20:41 <kallisti> Vorpal: perpetuating a vile industry that encourages rapid deadlines and not good finished products.
14:21:06 <Deewiant> elliott: I wonder if RES or something allows for removing the comment links :-P
14:21:07 <kallisti> but with shit switched around.
14:21:16 <elliott> Deewiant: I tried RES once and I just got annoyed at all the visual noise :P
14:21:29 <Deewiant> elliott: Just configure it, you can remove everything you don't want
14:21:36 <elliott> Yeah I know, I just also don't have any use for it
14:21:43 <itidus21> i mean, if deadlines are such a problem why are they so important
14:21:54 <Deewiant> I use it mostly for its "hide child comments" feature
14:21:56 <kallisti> http://www.reddit.com/r/shrooms/ I am disappointed at the lack of quality post things.
14:22:04 <elliott> itidus21: What's the real answer, since Vorpal is too boring to ask
14:22:07 <Vorpal> kallisti, anyway, I seen quite a few stable games on their release. None of them were open world sandbox games though.
14:22:28 <itidus21> elliott: as with most things it is best understood in a functional sense
14:22:45 <Deewiant> /r/starcraft is kind of shitty as well
14:22:47 <kallisti> I think they have an IRC channel as well?
14:23:09 <elliott> As an anthropologist studying the primitive /r/starcraft natives, I can confirm that it's shitty
14:23:12 <Deewiant> It's more about the people than the game
14:23:24 <kallisti> elliott: but maybe it has like... starcraft games?
14:23:35 <itidus21> elliott: so.. the core explanation is i don't have either 1) the game 2) a PC which could play the game.
14:23:49 <kallisti> elliott: I bet they use a lot of jargon you don't understand.
14:24:00 <Deewiant> For me /r/starcraft is like /r/AskReddit, I check it on occasion but don't subscribe to it or read it actively
14:24:06 <Vorpal> elliott, my only experience of starcraft is watching a few minutes of a commentated match. It was mostly incomprehensible jargon.
14:24:26 <kallisti> Vorpal: the jargon is actually not that dense.
14:24:28 <Deewiant> Surprise: thing you know nothing about is incomprehensible
14:24:36 <elliott> Deewiant: I don't know why you'd check /r/AskReddit ever, anything actually decent filters through to /r/bestof or whatever (which is admittedly kinda awful itself), and the rest is really awfully inane stuff
14:24:45 <Vorpal> kallisti, just as dense as for dota/lol/hon.
14:24:46 <elliott> FoxTrot creator Bill Amend is thinking about doing StarCraft 2 commentaries. Let's encourage him! (twitter.com)
14:24:52 <Vorpal> which is also mostly incomprehensible
14:24:52 <elliott> Deewiant: /r/bestof is default these days :P
14:24:58 <elliott> Deewiant: http://blog.reddit.com/2011/10/saying-goodbye-to-old-friend-and.html has the current list
14:25:04 <Deewiant> elliott: I unsubscribed from it long before it was default :-P
14:25:05 <kallisti> elliott: 6pool, 3rax, 3gate, 1-1-1, etc
14:25:13 <itidus21> 1) i don't have a job. 2) i don't have any money 3) i don't have any income. 4) whatever money i got in the last year from gifts such as xmas or birthday or other ended up going to my mom
14:25:15 <elliott> kallisti: Nope, haven't seen anything like that
14:25:24 <elliott> kallisti: I think you're expecting too much of them, it seems to mostly be celebrity worship crap
14:25:28 <itidus21> 4b) she ended up wasting most of this buying me soft drink and junkfood
14:25:37 <kallisti> I was expecting like... people who play starcraft
14:26:41 <itidus21> 1) my brother has an explosive anger problem 2) my brother is greedy and selfish for some reason 3) due to (1) and (2) whenever i might acquire anything my brother wants he will just take it rather than waste energy getting his own copy of said thing
14:27:14 <itidus21> when i was about 10, i learned that in my house if i wanted to make a glass of cordial i basically had to pour one for everyone
14:27:18 <Vorpal> itidus21, you forgot 2i) There are other ways to get hold of games if you want to.
14:27:20 <Deewiant> elliott: As for /r/AskReddit, there's a good question once in a while plus I find reading about amusing real-world stories a significant improvement to e.g. /r/{funny,pics,videos}; it works with RES's "hide all child comments" well, too, so you can only read the top-level replies
14:27:27 <kallisti> itidus21: http://www.reddit.com/r/drugs/
14:27:51 <itidus21> im trying to express i guess how futile my life is..
14:28:03 <Vorpal> itidus21, unless you use a console rather than a PC for gaming, in which case why on earth?
14:28:10 <kallisti> what this picture is trying to express
14:28:15 <kallisti> an unrelated problem altogether.
14:28:32 <elliott> itidus21: this is perhaps the most elaborate learned helplessness ever conveyed over irc
14:28:51 <Vorpal> itidus21, just use torrents? *shrug*
14:28:53 <elliott> Deewiant: "hide all child comments" sounds nice in theory but makes me miss out on e.g. when a high voted comment has an even higher-voted reply proving it's bullshit :P
14:29:08 <itidus21> Vorpal: my pc isn't near good enough to run it
14:29:09 <Deewiant> elliott: You can always manually check the replies
14:29:22 <itidus21> well i am not sure how good my pc is though but yeah
14:29:22 <kallisti> elliott: we're all in a state of learned helplessness man.
14:29:23 <Deewiant> elliott: (There's a "show child comments" button after hiding)
14:29:34 <kallisti> elliott: what are you gonna do about pollution, dawg?
14:29:39 <Deewiant> elliott: And that's what I usually do when I come across something that might need proving :-P
14:29:48 <Deewiant> elliott: But it hides pun threads and such effectively.
14:29:55 <elliott> Deewiant: Maan, I don't read reddit to think
14:30:02 <elliott> But yeah, anything that gets rid of pun threads is tempting :P
14:30:15 <Vorpal> itidus21, well then I guess you are stuck. Gaming when there are ranged weapons (bows and spells here) on consoles is generally horrible anyway due to lack of any sort of precision in aiming without a mouse.
14:30:17 <kallisti> wow a lot of pill-poppers on /r/drugs
14:30:58 <kallisti> uh oh, Vorpal is one of those "I can't aim with a thumbstick" people.
14:31:08 <itidus21> Vorpal: im just saying i feel how deprived i am when watching my brother play skyrim on a pc
14:31:19 <Vorpal> kallisti, I consider "auto aim" to be cheating. I know a lot of shooters on consoles use them.
14:31:25 <Vorpal> But that shouldn't be needed
14:31:27 <kallisti> Vorpal: that's not what I'm talking about.
14:31:40 <kallisti> you can do this neat thing where you turn up the sensitivity on the aiming
14:31:42 <itidus21> and ... i feel how fucked my life is on every level..
14:31:46 <Vorpal> kallisti, it takes much more time to aim with a thumbstick than with a mouse
14:31:53 <kallisti> and it gives you like, control over where you aim things based on how far you tilt the thumbstick
14:32:22 <elliott> Vorpal: s/$/ because i'm bad at it/
14:32:25 <itidus21> i keep myself happy by lying to myself
14:32:41 <Vorpal> kallisti, still inferior to a mouse.
14:33:04 <Vorpal> kallisti, anyway another problem: current consoles are way behind PCs when it comes to graphical fidelity.
14:33:31 <Vorpal> graphical quality then. Whatever you call it
14:33:45 <itidus21> elliott: i have learned that a nation has a similar problem when it feels its borders are too small.. and it has to ask all its neighbors to compromise
14:34:05 <itidus21> like suppose italy wanted to expand itself.. then all of europe might have to shift their borders
14:34:57 <itidus21> i have also learned that revolution tends to lead to a lot of deaths, and that border-renegotiations tends to lead to war
14:35:30 <Vorpal> kallisti, just compare a high end PC with the current PS3 or xbox 360 (wii is even further behind it seems). Assuming they all render to the same resolution, which system will be able to provide the best graphics? The PC.
14:35:32 <itidus21> and i know that, inspite all this a majority of the population of the world are screwed
14:36:26 <elliott> Vorpal: nobody actually gives a shit though because nobody derives fun from standing in front of a texture and admiring how high-resolution it is.
14:36:30 <itidus21> its like helplessness might be part of the system.. like... why are creatuers with learned helplessness surviving natural selection
14:36:43 <elliott> Vorpal: and consoles are attached to televisions which you sit further away from to play and therefore notice finer details less.
14:37:23 <Vorpal> elliott, the second point is true yes.
14:37:25 <kallisti> itidus21: because we don't actually have to fight for our lives/
14:37:50 <Vorpal> I prefer games to cover a larger part of my field of view though.
14:38:56 <Vorpal> elliott, but you yourself complained about the texture quality in skyrim screenshots. So you obviously do think it matter to some degree.
14:40:12 <itidus21> one of the cool things about it is so much voice acting in it.. and so much stuff in it.. and the conversation trees (seem a bit contrived at times, but oh well)
14:40:58 <itidus21> its not hte game itself i guess, but realizing that i'm not at that level of society that can play a modern pc game
14:41:34 <itidus21> its more than i can fit into my life
14:41:45 <kallisti> order groceries online, do freelance work.
14:42:22 <itidus21> clearly if i cannot buy myself a new pc ... a car is not in wildest dreams (even though diabetes is main reason i shouldn't drive.. and problems i suspect in my vestibular system)
14:42:32 <Vorpal> kallisti, well if you are in US you are screwed
14:42:48 <itidus21> and.. you can rule out a girlfriend
14:43:01 <itidus21> but thats kind of implied by the whole geek thing :P
14:43:54 <kallisti> maybe you're just caring about the wrong things, and letting completely irrational beliefs hold you back. hmmmm?
14:44:28 <itidus21> at this rate, before i die i will face a living hell on earth
14:44:43 <itidus21> as the problems i am describing escalate and close in on me
14:44:48 <Vorpal> anyway there are compsci students that are female. Far fewer than half of the students, but they do exist at the university I'm studying at least.
14:45:05 <kallisti> Vorpal: yes I even saw one in one of my classes!
14:45:21 <itidus21> i never planned for the possibility my brother would turn on me
14:45:32 <Vorpal> kallisti, I think it is something like two out of 18 in one of the current courses I'm taking.
14:45:43 <Vorpal> courses I'm currently taking*
14:45:49 <kallisti> she was even attractive! but, that's no place to pick up women, since... everyone is basically fawning her.
14:46:08 <kallisti> and she was probably like married or something
14:46:52 -!- ais523_ has joined.
14:46:57 -!- nooga has joined.
14:47:10 <Vorpal> kallisti, not so much of that here. I usually hang around with a group of around 5 people for stuff like lunch and so on, one of them is in that group. Just plain friends.
14:47:28 <ais523_> so, question I'm asking my students in this marking session: they have to write (in Java) a recursive method that sums a linked list
14:47:44 <ais523_> and I'm asking them what would happen if they removed the base case
14:47:52 <ais523_> the answers are interesting, sometims
14:47:52 <Vorpal> ais523_, speaking of which, does java optimise tail recursion?
14:48:04 <ais523_> Vorpal: I don't know; I think it's allowed to, but generally doesn't in debug mode
14:48:42 <Vorpal> ais523_, so what sort of interesting answers were there?
14:48:43 <nooga> linked list, in java, what for? how?
14:48:53 <ais523_> nooga: same way you define a linked list in C
14:48:58 <Vorpal> nooga, it is trivial to do with classes?
14:49:11 <Vorpal> nooga, since everything but the primitive types are by reference
14:49:22 <Vorpal> at least as far as I know
14:49:22 <ais523_> or, fwiw, java.util.LinkedList
14:49:52 <nooga> but there are no pointers in java
14:50:04 <ais523_> no need to roll your own when perfectly reasonable doubly-linked lists exist
14:50:11 <ais523_> nooga: Java has references, which are a special case of pointers
14:50:19 <Vorpal> nooga, everything except primitive types are references.
14:50:24 <ais523_> (or to look at it another way, pointers are a common way to implement references)
14:50:28 <ais523_> and references are enough for a linked list
14:51:13 <nooga> I come from a world of pointers
14:51:18 <Vorpal> ais523_, so what sort of interesting answers were there?
14:51:23 <ais523_> Vorpal: well, the students who are trying to answer everything by rote assume they'd get a stack overflow, because that's always what happens when you remove the base case of a recursion, right?
14:51:34 <ais523_> so I ask them what'd happen when the end of the list is reached
14:51:37 <elliott> nooga: ruby - world of pointers
14:51:41 <ais523_> funniest answer so far is that it goes back to the start of the list
14:51:57 <Deewiant> Yes, java.util.LinkedList, the linked list that lacks an easy of way of retrieving the tail
14:51:57 <Vorpal> ais523_, non-ciruclar list I take it?
14:52:19 <ais523_> it's handrolled, and does have an accessor for the tail
14:52:20 <Vorpal> ais523_, you can have a singly linked circular list!
14:52:34 <nooga> elliott: well, ruby is not my main language ;p
14:52:46 <ais523_> also, it doesn't have a constructor or setter method that would allow creating a circular one without bypassing the security model somehow
14:53:01 * kallisti hasn't figured out his "main language"
14:53:06 <kallisti> I don't think I have one of those.
14:53:13 <ais523_> elliott: seriously; you can mutate it into its tail
14:53:15 <Vorpal> ais523_, how can someone fail a simple question like that, I don't get it.
14:53:20 <Deewiant> elliott: It's the reason I rolled my own at one time
14:53:23 <ais523_> but not get a reference to the tail without changing it
14:53:38 <elliott> Oh, right, it's "linked list: the arraylist interface"
14:53:46 <elliott> AKA the least useful structure, ever
14:53:56 <Deewiant> You can do subList(1, list.size()) but that probably copies n-1 elements
14:54:00 <ais523_> btw, about tail-calls in Java, I just looked it up; the JVM doesn't do it because it needs to maintain the stack trace as expected
14:54:15 <elliott> You can do tail calls with stack traces trivially
14:54:17 <ais523_> but individual JVM languages can optimise tail-recursion (i.e. self-tail-calls) into loops if they want
14:54:20 <elliott> But that's GvR's excuse too
14:54:29 <nooga> I thought you don't give a shit about Java and now, suddenly, everybody is talking about Java
14:54:37 <elliott> because ais523_ brought java up
14:54:40 <elliott> because ais523_ teaches java
14:54:42 <Vorpal> ais523_, is javac able to do that?
14:54:43 <Deewiant> "Trivially" is a bit much; simply, maybe :-P
14:54:45 <ais523_> you can get the names of functions trivially
14:54:48 <elliott> because we talk about the things ais523_ talks about
14:54:50 <ais523_> elliott: you can't inspect the values of params back along the stack, though
14:55:08 <nooga> ais523_: excuse me, but... begone!
14:55:09 <ais523_> elliott: because I'm marking Java right now, except it's a two-week exercise and the student in this slot did it all last week
14:55:09 <elliott> ais523_: Sure you can, it just means you leak memory
14:55:12 <ais523_> to get the week off this week
14:55:20 <elliott> Admittedly, that's almost the same as not optimising tail calls
14:55:22 <ais523_> elliott: wait, is that even a tail-call any more?
14:55:33 <ais523_> the obvious place to store it is the call stack
14:55:47 <ais523_> I suppose it'd be a tail-jump; when you actually hit the return of the tail-calls, just pop all the stack elements at once
14:55:57 <ais523_> so you get a speed improvement if not a space improvement
14:56:06 * elliott thinks the tail call argument is rubbish anyway
14:56:09 * ais523_ realises with horror that this is actually a standard idiom in INTERCAL
14:56:12 <elliott> people just make it up when trying to think of excuses not to implement it
14:56:18 <quintopia> the jvm should have a flag to loop tail recursion and not give a damn about stack data :/
14:56:35 <elliott> I have never heard of anyone failing to debug a Scheme program because they tail-recursed and the stack trace didn't have all the frames
14:57:15 <ais523_> elliott: the typical API to a Prolog debugger (which seems standard among multiple implementations, strangely) tends to have two different operation modes, one which tail-recurses and one which doesn't
14:57:24 <ais523_> I'm not sure if it extends to tail-calls generally
14:57:43 <elliott> also anyone who does tail recursion optimisation as opposed to tail call optimisation
14:57:46 <elliott> is not my friend, advanced warning
14:58:02 <ais523_> when not debugging, it optimises out the tail-recursions just fine (again, not sure about general tail calls); in the debugger, I imagine being able to see them helps sometimes
14:58:17 <ais523_> meanwhile, Perl has specific syntax for doing a tail-call, and probably doesn't do them if you don't use it
14:58:20 <Vorpal> anyway you could just do the optimisation at compile-to-bytecode time. So there is really no obvious reason to not have it there rather than in the jvm
14:58:25 <ais523_> which is an interesting middle ground
14:58:28 <Vorpal> unless you can JIT better doing it in the JVM I guess.
14:58:33 <ais523_> Vorpal: I think the JVM has a concept of methods
14:58:42 <ais523_> quintopia: I'm not sure, they're both earlier-than-you'd-think
14:58:46 <ais523_> and I'm not sure which is more earlier
14:59:38 <Vorpal> ais523_, probably. Still there is no obvious reason to not optimise tail calls already in the compiler if the end result (the machine code produced by the JIT) ends up equally good to doing the whole thing in the JIT would have.
14:59:43 <Vorpal> gah the grammar of that.
15:00:12 <ais523_> http://blogs.oracle.com/jrose/entry/tail_calls_in_the_vm
15:00:12 <quintopia> prolog predates haskell by over two decades :O
15:00:16 <nooga> never really thought about TCO before
15:00:23 <ais523_> (proposal to add tail-calls to Java bytecode in a backwards-compatible way)
15:00:48 -!- elliott_ has joined.
15:01:04 <elliott_> <quintopia> didnt prolog come before haskell?
15:01:31 <ais523_> wow, Prolog's as old as INTERCAL
15:01:35 * elliott_ doesn't think haskell is "earlier than you'd think", personally
15:01:46 <quintopia> < quintopia> prolog predates haskell by over two decades :O
15:01:49 * elliott_ is surprised that Prolog is that old though
15:02:49 <quintopia> i suspect the syntax that haskell and prolog have in common was extant before 1995
15:03:14 <elliott_> in fact, I'm having a hard time of thinking of a single piece
15:03:58 <quintopia> but the idea of multiple alternate subcases of a fact/function being built into a syntactical structure
15:04:13 -!- elliott has quit (Ping timeout: 245 seconds).
15:04:48 <quintopia> its not something languages had before prolog that i can tell
15:05:09 <elliott_> do you just mean writing pattern-matching like
15:05:27 <elliott_> and not being able to define multiple top-level clauses for "f"?
15:05:47 <elliott_> otherwise i dunno what you mean
15:05:56 <quintopia> of the idea of patternmatching defs in general
15:06:26 <quintopia> anyways shower time. i'm already running way late.
15:08:32 -!- ais523_ has quit (Ping timeout: 265 seconds).
15:13:34 -!- ais523_ has joined.
15:14:12 <ais523_> and that was a weird pingout, pinging out from the webclient while on a desktop computer with a wired connection
15:15:05 <ais523_> the way patternmatching defs work in Prolog is entirely different from the way they work in Haskell, though
15:15:14 <ais523_> as in, they do the same thing, but for entirely different reasons
15:16:05 <elliott_> hmm, is it possible to create a reversible language where only the program /state/ needs to be known to compute the previous one, not the state _and_ the program?
15:16:12 <elliott_> I realise that's a kind of vague concept
15:16:23 <elliott_> reversible CAs do that, except they embed the program into the state already, kind of :P
15:18:25 -!- zzo38 has quit (Remote host closed the connection).
15:23:18 <elliott_> ais523_: oh, my name is johny, what the F**K? seems to be forming properly in my head
15:23:29 <elliott_> by which I mean, I'm coming up with a language and it seems good enough to give it the name
15:27:53 <ais523_> capital J on Johny, right?
15:27:55 -!- copumpkin has joined.
15:28:41 -!- ais523_ has quit (Quit: Page closed).
15:30:31 <ais523> the ** in the name of that language, I mentally pronounce as somewhere between öö and üü
15:33:48 <elliott_> hmm, the problem with having reversibility based on state alone is that no two different programs can produce the same state
15:34:03 <elliott_> seems like I'm edging close to Rice's theorem if I'm not careful
15:38:39 <ais523> which one is Rice's theorem?
15:39:04 <elliott_> http://en.wikipedia.org/wiki/Rice's_theorem
15:39:16 <elliott_> in this context, the problem is basically that you can't compute equality for functions
15:41:53 <ais523> incidentally, a few days ago, there was a Haskell fan flaming OCaml for accepting = on functions (and throwing an exception if you tried to use it)
15:42:03 <ais523> also, for defining < and > on absolutely everything that has an =, even if it's arbitrary
15:42:15 <ais523> (that is, they're consistent with =, but otherwise arbitrary, in some cases)
15:44:47 <elliott_> although, that </> thing is a bit hypocritical
15:44:55 <elliott_> Haskell has arbitrary Ord instances too
15:45:04 <elliott_> beacuse our structures like to use them
15:45:09 <ais523> elliott_: in real life
15:45:38 <kallisti> in real life my structures are giant monsters that eat me.
15:45:41 <ais523> one advantage of working in a CS department is that you have a nontrivial chance of encountering a Haskell fan
15:45:59 <ais523> elliott_: remember the Bjorn stories? kallisti reminds me of that, just less extreme
15:46:47 <HackEgo> 2011-09-13.txt:18:09:15: <elliott> `log Bjorn
15:47:04 <HackEgo> 2010-07-24.txt:03:54:13: <alise> The merchant tottered away uneasily, and decided to get a job that involved fewer crazy people. Say, telemarketing. Bjorn voyaged on through the dark for maybe three meters before giving up and resting for the night.
15:47:07 <kallisti> past elliott: stop being curious
15:47:14 <ais523> there we go, it's that sort of thing
15:47:31 <HackEgo> 2011-09-13.txt:18:07:47: <ais523> oh, I forgot all about the Bjorn thing
15:47:41 <HackEgo> 2010-07-24.txt:03:52:04: <alise> As Bjorn woke the next morning, he was, much to his chagrin, reminded of his exploits-to-be by his least favourite region of the brain, which was whatever part stored memories; Bjorn wasn't really sure how the brain operated, apart from that he wished it wouldn't do so in such an efficient and unforgetting manner. So he trundled off again to the pub, and finally got up the energy,
15:47:54 -!- copumpkin has quit (Remote host closed the connection).
15:48:18 -!- copumpkin has joined.
15:49:03 <ais523> alise was better at Bjorn stories than the rest of us
15:49:24 <kallisti> Sgeo: updersation between itidus21, Vorpal, and kallisdeet
15:49:30 <ais523> Bjorn, sadly, was better at Bjorn stories than himself, but he wished it was worse
15:49:35 <kallisti> (continuing with the fractal theme)
15:50:07 <elliott_> ais523: hmm, I think I know how to implement addition in My name is Johny, what the F**K? branch 2, but I'm not sure about multiplication
15:50:20 <ais523> that's always a good sign
15:50:45 <elliott_> ais523: but if what I have is a correct implementation of multiplication, I fear that the language may be fairly boring
15:51:17 <ais523> if it's correct but non-obvious given esolang knowledge, you've probably found something new
15:51:29 <ais523> the multiplication impl
15:52:37 <elliott_> hmm, ah, I think I know what I need
15:52:50 <elliott_> unfortunately, I'm not sure how to make it /mandatory/
15:52:56 <elliott_> if it's not, you can write programs easily but boringly
15:55:05 -!- Phantom_Hoover has joined.
15:55:52 <ais523> elliott_: is that MNIJWTF?
15:56:34 <ais523> gah, it looks vaguely like Haskell but trying to interpret it as Haskell makes my head spin
15:56:40 <ais523> that's also a good sign :)
15:56:56 <elliott_> ais523: try ignoring discard...in
15:57:06 <elliott_> and note that times returns a tuple
15:57:08 <ais523> nah, I think I know what discard does
15:57:18 <ais523> it asserts that both values are equal, and then forgets about them
15:57:24 <ais523> and forgetting about data is otherwise impossible
15:58:04 <elliott_> ais523: the problem is mainly, how do I force people to use discard? rather than just doing something like
15:58:24 <elliott_> where you basically just thread computations and put all the junk in one value
15:58:40 <ais523> what about making the language typed?
15:58:46 <kallisti> elliott_: the value is thusly called "the trunk"
15:58:47 <ais523> (as in, typed lambda calculus)?
15:59:25 <elliott_> ais523: ooh, that might actually work
15:59:49 <ais523> then you have to invent a monstrously complicated ADT to lump all the junk in one value
16:00:12 <kallisti> hereafter called "the trunk" plz
16:00:22 <elliott_> ais523: maybe if it was the simply typed lambda calculus
16:00:23 <ais523> kallisti: but we're trying to get rid of it
16:00:27 <elliott_> ais523: but the STLC can barely /compute/ anything
16:00:39 <kallisti> ais523: okay then plz name your finished solution "the trunk"
16:00:40 <ais523> elliott_: what's the difference? no recursive types?
16:01:06 <ais523> kallisti: elliott_ and I both care deeply about MNIJWTF, we want a truly great language to represent the name
16:01:08 <elliott_> ais523: STLC just has Q and (A -> B) as types
16:01:28 <ais523> elliott_: crazy idea: what about bounding memory usage somehow?
16:01:44 <ais523> although that gets rid of TCness, it still allows the vast majority of practical programs
16:01:54 <ais523> apart from interps and similar constructs that absolutely need to be TC
16:02:09 <ais523> hmm, that reminds me, I still need to invent ACK
16:02:23 <ais523> the esoteric programming language that is not TC, but only barel
16:03:47 <elliott_> ais523: what if i made it bounded but infinite?
16:03:48 <ais523> (the idea is, there are two sorts of entropy; there's minor entropy and major entropy, all operations cost minor entropy, major entropy allows you to ackermann-function your minor entropy but you only have a finite, program-specified, amount)
16:04:02 <ais523> kallisti: stop trying to derail us, this channel is even better ontopic than offtopic
16:04:39 * kallisti was actually just discussing (read: ranting to himself with a witness) an esolang.
16:04:40 <elliott_> ais523: that is to say, like, you have aleph_null ram
16:04:59 <elliott_> ais523: but if you do f(g(x), h(x)), the computations of g(x) and h(x) can only take half of it
16:05:07 <elliott_> and f gets all of it, because it's a tail call
16:05:15 <ais523> does that even make sense?
16:05:18 <ais523> please tell me that makes sense
16:05:29 <elliott_> I don't think so, so let's keep thinking about it until it makes even less sense
16:06:04 -!- calamari has joined.
16:06:08 <elliott_> ais523: so the idea would be, make it so that just piling all the junk from multiple calls together ends up using an impossible amount of RAM
16:06:27 <elliott_> ais523: i.e., because you recurse, and then use more than ten times that, or whatever
16:06:36 <elliott_> so the whole function needs RAM n > n for certain inputs
16:06:41 <elliott_> and it's rejected by the RAM checker
16:06:42 <ais523> hmm, now I'm reminded a bit of Advice
16:06:50 <ais523> it's one of the ICFP esolangs
16:07:12 <ais523> and it's basically just Thue-on-trees, except that if the same number of replacements need to be made on both branches of a tree, it doesn't replace on either
16:07:29 <ais523> which is a restriction that's perfectly gauged to throw a spanner in the works of typical algorithms
16:07:40 <kallisti> wow so I think I've actually figured out my esolang.
16:08:05 <ais523> (my solution to programming in it was to make sure that only one replacement was possible at any given time, so that it'd always be split 1/0 everywhere that mattered and thus avoiding a balanced situation)
16:08:20 <ais523> that applies to subtrees, too, obviously, or it'd be trivial
16:09:18 <elliott_> ais523: incidentally, it's meant to be term rewriting, if it isn't obvious
16:09:55 <ais523> elliott_: yep, I figured it was some sort of match-and-unmatch thing, like Anarchy
16:10:22 <ais523> ("unmatch" is a great name for the operation of creating a data structure from a template)
16:13:46 <elliott_> ais523: hmm, I'm quite worried that the junk value always seems to be one of the parameters to the function
16:13:56 <elliott_> I suppose it's because these functions are pretty simple so far
16:14:22 <ais523> elliott_: hmm, I'm reminded of Unassignable now
16:14:33 <ais523> finding workable junk values there was really hard
16:14:41 <ais523> yay, I can finally type its actual name
16:14:50 * elliott_ is trying fib now, which is interesting because it recurses twice
16:18:52 <elliott_> the problem there is that there's no such thing as fst
16:21:09 <elliott_> wow, that's longer than it looks in my editor
16:22:43 <elliott_> ais523: I suppose there's no problem in letting you use a variable after it's discarded
16:23:16 <ais523> although, you could just put a discard list at the end of a function
16:23:20 <elliott_> ais523: the main problem is that it's easy to cheat discard
16:23:28 <elliott_> ais523: by giving it a definition that _isn't_ equivalent
16:23:36 <elliott_> but just happens to work in all the cases you try
16:23:50 <ais523> should be instant runtime crash if they're different at runtime
16:24:00 <ais523> I don't see why it's a problem if they're always the same at runtime but defined differently
16:24:06 <elliott_> ais523: that's cheating; you can't do that in the "architecture" of the language
16:24:17 <elliott_> ais523: I mean, on real computers, you don't have to do discard at all! you can just throw away the values
16:24:35 <elliott_> the idea is that you can throw away information as long as you can prove you already have it
16:24:43 <elliott_> which isn't the same thing as just happening to have the right bits
16:24:54 <elliott_> you need to prove you've already computed it redundantly, in essence
16:26:51 -!- olsner has joined.
16:27:21 <elliott_> ais523: I suppose it could try and prove it itself via term rewriting
16:27:40 <ais523> make it ship with a machine-readable proof, Coq/Agda-style?
16:28:07 <elliott_> ais523: that's also cheating, but more importantly it's really boring
16:28:12 <ais523> heh, I think that's another operation that I'm planning for Anarchy
16:28:12 <elliott_> because proofs are boring to write
16:28:13 <olsner> quick, someone summarize the last week of #esoteric for me
16:28:24 <ais523> olsner: is that possible?
16:28:36 <ais523> but yes, today it's been interesting, the rest of the week, not so much
16:28:40 <olsner> elliott_: ok, I'll just assume I haven't missed anything then :)
16:29:09 <kallisti> elliott_: yes, everything is so much easier when I resist the urge to not make this a term rewriting language.
16:29:27 <ais523> term rewriting is great
16:29:34 <kallisti> and instead just make it an awesome term rewriting language.
16:29:44 <ais523> more languages should do term rewriting
16:30:33 <elliott_> ais523: heh! i think i can use this model to do a kind of uniqueness typing
16:30:50 <kallisti> so this is kind of turning into a spatial and temporal logic graph rewriting language, if that's even a thing.
16:32:08 <kallisti> also nondeterministic because why not.
16:35:33 <elliott_> the main problem is that you could discard the last world and return the second-last world, which is problematic
16:37:51 <elliott_> ais523: heh, then I thought of a solution but it's just a monad
16:38:16 <ais523> elliott_: monads in general, or a specific monad?
16:38:37 <ais523> right yes, that became obvious when I clicked on the link
16:38:51 <elliott_> that sprunge isn't the IO monad
16:39:10 <ais523> nope, but it becomes clear that IO is how you'd fix it
16:39:32 <elliott_> that's so boring though, it doesn't use the reversibility at all
16:39:42 <elliott_> the only additional thing you'd need is like
16:39:50 <elliott_> discard X in E -- E has to have type IO t for some t
16:40:04 <elliott_> so that you can, e.g., read a line from the terminal without having to print it out later or whatever
16:40:16 <elliott_> (discard X in E has the same type as E, ofc)
16:40:49 -!- sebbu2 has joined.
16:41:02 -!- sebbu2 has quit (Changing host).
16:41:02 -!- sebbu2 has joined.
16:41:12 -!- sebbu has quit (Ping timeout: 248 seconds).
16:41:42 <elliott_> ais523: time to see if I can write reverse : [a] -> [a]
16:43:30 <elliott_> hmm, that can't possibly work, which is a bad sign
16:43:36 <elliott_> because I can't think of another way to do it
16:43:50 <elliott_> and I also can't see how that's invalid
16:45:03 <elliott_> ais523: hmm, I might pop back to branch 1, which is a completely different language
16:45:19 <elliott_> ais523: http://esoteric.voxelperfect.net/wiki/User:AlisonDiaz603
16:45:59 <ais523> deleted (I assume you didn't want protection instead :P)
16:46:12 <Phantom_Hoover> I have just noticed a name in a Wikipedia article which is spelt two different ways in two consecutive paragraphs.
16:48:25 -!- copumpkin has quit (Remote host closed the connection).
16:48:32 <elliott_> ais523: btw, though I'm not as annoyed as oerjan, I think you should contact Graue if spam continues at this rate, at least to give you bot privileges so that you can keep the deletions off recentchanges
16:48:57 <ais523> elliott_: he'd need to give me the option to set/unset bot privs
16:49:09 <elliott_> ais523: why can't he just set bot privileges for all admins?
16:49:10 <ais523> rather than just to put them on constantly, because then none of my edits would show up in recent changes
16:49:21 <elliott_> is there a way to do that without giving you crat privs?
16:49:25 <ais523> I'm also not sure what happens to admin actions marked bot actions
16:49:34 <ais523> elliott_: yes, but it's nontrivial and may require recentish MediaWiki
16:49:43 <ais523> admins can set/unset all sorts of flags on Wikipedia
16:49:56 <ais523> (none of the really important ones, but flags like "can use rollback" are routinely toggled by admins)
16:50:07 <elliott_> ais523: well, whatever, I just think you should contact him to get /something/ done if recent changes continues to be completely clogged with spam
16:50:37 <ais523> what I'd really like is the AbuseFilter extension
16:50:43 <ais523> it lets admins configure anti-spam rules
16:51:01 <elliott_> that would be preferable to our current (terrible) capthca system.
16:51:16 <elliott_> but i have a feeling that graue has Strong Opinions on the Right Way to do this
16:51:37 <elliott_> we could at least have a better captcha
16:51:44 <elliott_> admins can create accounts, right?
16:51:54 <ais523> yes, for other people as well as themselves
16:51:57 <elliott_> then it doesn't matter if we have an image-only captcha
16:52:06 <elliott_> people who can't use it can ask an admin for an account
16:52:09 <ais523> it requires an email address, though
16:52:22 <ais523> as the admin doesn't get to see the resulting password, and it has to be sent /somewhere/
16:52:37 <ais523> (random fact: for a while, I handled quite a large proportion of Wikipedia's manual account creation)
16:53:27 <ais523> mostly usernames that hit the blacklist
16:53:41 <ais523> like being too similar to another user, or containing blacklisted words, that sort of thing
16:53:48 <ais523> checking to see if the blacklist should be overriden in that case
16:54:05 <ais523> (being too similar to someone who registered six years ago and has never edited, for instance, typically I'd allow that)
16:59:36 <elliott_> someone help me forget an idea I just had, please
16:59:49 <kallisti> !perl print (("stay in school", "drop out")[int(rand(2))])
17:00:07 <elliott_> `run perl -e 'print (("stay in school", "drop out")[int(rand(2))])'
17:00:15 <elliott_> You should trust HackEgo instead.
17:00:37 <kallisti> still MY TIME MANAGEMENT SKILLS ARE FUCKING DISAPPEARING AAAAAAH
17:00:46 <kallisti> not that I had any in the first place.
17:00:48 <kallisti> but now they're more important.
17:01:06 <Deewiant> Majority opinion points to "drop out"
17:02:06 <kallisti> PRNGs is no way to make important life decisions.
17:03:26 -!- copumpkin has joined.
17:03:30 <Deewiant> www.random.org says 1 so "stay in school" it is
17:04:06 <kallisti> !perl print ( int rand(6 > 0) ? "continue living" : "kill yourself" )
17:04:36 -!- copumpkin has quit (Remote host closed the connection).
17:04:42 <kallisti> so I'm just bad at programming
17:05:01 -!- copumpkin has joined.
17:05:23 <kallisti> !perl print ( (int rand 6) > 0 ? "continue living" : "kill yourself" )
17:08:26 <elliott_> you're all being terrible at distracting me.
17:09:37 <kallisti> echo '#!/bin/perl' > bin/russianroulette && echo 'print ( (int rand 6) > 0 ? "continue living" : "kill yourself" )' >> bin/russianroulette && chmod +x bin/russianroulette
17:09:56 <kallisti> `run echo '#!/bin/perl' > bin/russianroulette && echo 'print ( (int rand 6) > 0 ? "continue living" : "kill yourself" )' >> bin/russianroulette && chmod +x bin/russianroulette
17:10:11 <HackEgo> /home/hackbot/hackbot.hg/multibot_cmds/lib/limits: /hackenv/bin/russianroulette: /bin/perl: bad interpreter: No such file or directory \ /home/hackbot/hackbot.hg/multibot_cmds/lib/limits: line 5: /hackenv/bin/russianroulette: Success
17:11:29 -!- monqy has joined.
17:12:55 <monqy> speaking of success, I finished the python yesterday/lastnight
17:13:37 <monqy> hopefully that means no more for a while. will likely have to do c++ next quarter though :( why is everything bad
17:13:48 <elliott_> "On the one hand, Java was slow, bloated, and not too portable. On the other hand, Inferno was quick, small, portable*, and marketed by AT&T. So naturally Java became popular."
17:14:14 <monqy> inferno? that any good?
17:14:39 <elliott_> http://en.wikipedia.org/wiki/Inferno_(operating_system)
17:26:36 <elliott_> ais523: quick, talk about Feather
17:52:05 <kallisti> elliott_: obviously he wrote an IRC client in Feather
17:52:44 <kallisti> using the Feather inerpretre that's written in Feather.
17:53:22 <kallisti> ais523: probably too insane to do either.
18:06:20 <nooga> is prototype inheritance in JS a real, built-in language fearture?
18:06:23 -!- zzo38 has joined.
18:06:27 <nooga> or just a stupid hack?
18:07:34 <elliott_> JavaScript prototype inheritance is a language feature. I'm not sure how that's related to whether it's a stupid hack or not.
18:08:58 <ais523> kallisti: /all/ Feather interpreters are written in Feather
18:09:04 <ais523> if they weren't, they wouldn't be Feather interpreters, by definition
18:09:27 <ais523> this confused me for a bit, before I realised that you could write a Feather interp as a polyglot between Feather and some other language
18:09:33 <ais523> and as long as everything had the same meaning, it'd work fine
18:10:55 <nooga> elliott_: But is it in the language itself or just in the runtime that could be altered? How is it different from prototype inheritance implemented in C? Would this make C object oriented? :D
18:11:06 <kallisti> ais523: you realize that doesn't really make any sense at all right?
18:11:16 <elliott_> nooga: (a) it is part of the language itself. it must be implemented in the runtime, of course, like all language features.
18:11:17 <nooga> I'm asking because I have an argument with guy that states that JS is legit OO language
18:11:27 <elliott_> nooga: (b) C does not have prototypes...
18:11:31 <ais523> kallisti: there is a reason that Feather drives people who attempt to understand it crazy
18:11:40 <ais523> I think you're beginning to see the edges of it
18:11:42 <elliott_> nooga: of course JS is an object-oriented language.
18:12:06 <ais523> the reason it's so maddenning is that you're constantly struggling with the issue of whether Feather makes sense or not
18:12:14 <ais523> nooga: also, you can do OO quite well in C
18:12:21 <nooga> ais523: i know taht
18:12:31 <nooga> but it does not make C an OO language
18:12:34 <nooga> and that's my point
18:12:37 <ais523> you can even setup vtables by hand and get it working exactly like a saner version of C++ if you like
18:13:08 <elliott_> nooga: JavaScript has language support for objects with self-reference and constructors. JavaScript has built-in language support for prototypes via the <obj>.prototype functionality.
18:13:09 <nooga> ais523: I've read a book about it
18:13:19 <elliott_> It is unquestionably a real object-oriented language based on prototypical inheritance.
18:13:42 <elliott_> It's also not a very good language in general, but that's an orthogonal issue.
18:13:55 <nooga> elliott_: understood
18:14:00 <ais523> elliott_: how does JS do delegation, or the equivalent? I seem to remember something like making the prototype a function that looks at the superobject's prototype
18:14:22 <elliott_> ais523: I don't remember exactly how it works; I've tried to forget as much JS as possible.
18:14:27 <nooga> http://ejohn.org/blog/simple-javascript-inheritance/
18:14:33 <nooga> but this is just completely wrong
18:14:51 <elliott_> nooga: That's just syntactic sugar.
18:14:54 <nooga> i could write OO programs in C with less syntactic clutter
18:14:57 <ais523> elliott_: why do you hate JS as much as you do? I don't understand it well enough to truly hate it
18:15:03 <elliott_> Half syntactic sugar for delegation, half attempting to make it look like class-based inheritance.
18:15:28 <elliott_> ais523: I don't really hate it, it's just not very pleasant to use; a large part of that is because browser APIs, especially the DOM, are terrible.
18:15:33 <ais523> elliott_: well, class-based inheritance is a special case of prototype-based inheritance
18:15:34 <elliott_> ais523: But also its scoping is awful.
18:15:44 <ais523> elliott_: isn't it block-scoped?
18:15:50 <ais523> oh, I see what you mean
18:16:16 <elliott_> ais523: for (var i = ...; ...; ...) { ... }; /* surprise, i is still in scope! */
18:16:25 <elliott_> (and any previous "i" in the function overwritten)
18:16:40 <ais523> what about {for (var i = …; …; …) { … };} /* is i still in scope here? */
18:17:03 <elliott_> another thing I dislike about JS is how lax and implicit its coercions are
18:17:17 <ais523> hmm, that would be a fun use for C++ lambda syntax: [](){ … }()
18:17:26 <ais523> although {} works just as well in C++
18:17:42 <ais523> elliott_: that's just typical dynamic language typing syndrome
18:17:47 <ais523> at least, it's endemic to both JS and PHP
18:18:11 <elliott_> ais523: Python and Ruby don't suffer from it
18:18:16 <elliott_> ais523: Perl sort of does, but it's at least consistent about it
18:18:24 <ais523> Perl uses a different solution to the problem
18:18:28 <elliott_> because it separates its string and number operators strictly
18:18:37 <ais523> Python and Ruby make sure that values are always clear on their own type
18:18:39 <elliott_> "Some languages, such as Perl, began as scripting languages[3] but were developed into programming languages suitable for broader purposes. Other similar languages – frequently interpreted, memory-managed, or dynamic – have been described as "scripting languages" for these similarities, even if they are more commonly used for applications programming. They are usually not called "scripting languages" by their own users."
18:18:44 <elliott_> err, Perl users don't call it a scripting language?
18:18:44 <ais523> whereas Perl makes sure that contexts are always clear on their own type
18:18:54 <ais523> elliott_: I call it a scripting language when I use it for scripting
18:19:03 <ais523> something like TAEB, it doesn't really feel like I'm using a scripting language, though
18:19:20 <ais523> it feels like I'm using a not-really-designed-for-scripting subset of a scripting language
18:19:27 * elliott_ thinks Perl is probably okay for scripting, but wouldn't use it for anything non-scripty. /me also considers it a flaw when a language is only good at one
18:19:45 <elliott_> I agree, so I moved it. Not an admin tho so history will look weird. Elfguy 20:37, 16 August 2005 (UTC)
18:19:49 -!- Klisz has joined.
18:19:52 <kallisti> elliott_: perl does have pretty good scoping rules though.
18:20:13 <elliott_> Perl is one of the few modern languages with proper dynamically-scoped variables
18:20:14 <ais523> it took multiple tries to get it right
18:20:30 <ais523> elliott_: Perl did what it usually does, and put every sort of scoping it could think of into the language
18:20:32 <kallisti> also, I believe Python is function-scoped as well for local variables.
18:20:57 <elliott_> but at least variables can't be referenced before definition
18:20:58 <ais523> package scope, dynamic scope, lexical scope, you can even have truly global scope if you like (this requires you to name your variables starting with a control character)
18:21:00 <elliott_> (in js they're just undefined)
18:21:06 <elliott_> and at least it doesn't /pretend/ to have a declaration keyword (var)
18:21:20 <elliott_> ais523: control character? seriously?
18:21:28 <ais523> elliott_: yes; there's sugar to write it in ASCII
18:21:42 <kallisti> I like how Python is sometimes less strict than Perl, mainly regarding variable declaration (or lack thereof)
18:21:42 <ais523> ${^This_starts_with_control_T}
18:21:44 -!- derrik has joined.
18:21:50 <ais523> but it's stored as a literal control-T internally
18:21:59 <elliott_> kallisti: nothing's looser than strict/warningsless perl
18:22:23 <elliott_> incidentally, it's 2011; why doesn't perl have a flag to enable both strict and warnings?
18:22:30 <ais523> and you can put a literal control-T in the source, if you really want to
18:22:52 <kallisti> elliott_: I believe they want it to be module-specific. This is why the -w flag is discouraged.
18:22:56 <ais523> elliott_: because scripts where you want strict and warnings, which is ones that are longer than oneliners, are scripts where there's no big loss in writing "use strict; use warnings;"
18:23:13 <elliott_> ais523: the loss is that it takes time and annoys me :P
18:23:13 <kallisti> because -w is applied globally.
18:23:15 <ais523> whereas for the really insane golfing, poetry, etc, you probably want them off
18:23:34 <ais523> kallisti: are you muddling it with -W, which is very very global?
18:23:50 <kallisti> I thought -w turned on warnings in the perl interpreter
18:24:06 <kallisti> which is not a module-specific thing.
18:24:17 <ais523> -w sets the global variable ${^W}
18:24:23 <ais523> which turns on warnings
18:24:29 <ais523> but it can be turned on and off scopely as usual
18:24:33 <nooga> and, especially, PHP fanboys
18:24:34 <ais523> it's just that most modules don't start "no warnings;"
18:24:47 <ais523> so because -w changes the default warning setting from off to on, it affects them too
18:24:59 <ais523> -W turns on warnings regardless of "use warnings;" or "no warnings;" or ${^W} or anything
18:25:46 <ais523> (btw, you can golf ${^W} down to $^W because the name's one char long, and further to $ followed by a literal control-W)
18:25:59 -!- Klisz has quit (Quit: You are now graced with my absence.).
18:26:23 <kallisti> elliott_: incidentally, aside from it being a requirement for certain uses of Getopt and $_ hacks, I haven't really used dynamic scope much in Perl.
18:26:26 <ais523> I can't remember what -a does
18:26:34 <ais523> and why would you turn on automatic line-ending handling twice?
18:26:41 <elliott_> kallisti: it's good for configuration settings, generally
18:26:47 <elliott_> for instance, whatever stdout is
18:26:58 <nooga> ais523: you know the options for Larry?
18:26:59 <elliott_> common lisp puts it to good use like that
18:27:22 <ais523> elliott_: in the Crawl codebase, I've seen a class whose objects are dynamically-scoped booleans, using RAII
18:27:34 <ais523> it really confused the person who asked me for help with it, because they didn't understand it
18:27:47 <ais523> if the code were RAIIing everywhere, it'd probably be fine, but it's the only bit of RAII I've seen in the code
18:27:55 <ais523> which just makes it more confusing
18:28:01 <elliott_> Accustomed awk users should take special note of the following:
18:28:01 <elliott_> · A Perl program executes only once, not once for each input line. You can do an implicit loop with "-n" or "-p".
18:28:17 <ais523> -p is great for golfing
18:28:24 <kallisti> ais523: -a turns on autosplit mode. I'm not sure if someone else has already said this or not.
18:28:27 <ais523> to the extent that many programs, you actually write #!perl -p at the start
18:28:39 <ais523> kallisti: hmm, I thought that was -s, perhaps I was confused
18:28:49 <elliott_> ais523: I just find it funny that it has to be pointed out that lines run once
18:29:04 <ais523> ah, -a is autospit, -s parses command-line arguments
18:29:15 <ais523> elliott_: plenty of languages have an implicit loop
18:29:32 <ais523> also, because I'm used to perldoc nowadays for Perl-related things because it has all the manpages and more stuff beyond that
18:29:47 <ais523> you can use perldoc -f to get a section of perlfunc, you can't do that with man, for instance
18:29:54 <ais523> and perldoc and man produce identical output for the manpages
18:30:03 <ais523> I think; reasonably identical, at least
18:30:14 <ais523> oh, the wrapping's different
18:30:28 <ais523> I think I prefer right-ragged to ASCII-justified
18:31:00 <elliott_> the status bar is different, more importantly
18:31:04 <elliott_> anyway, if you prefer that, set man to do that
18:31:28 <ais523> elliott_: oh right, man's overriding my less settings, perlrun isn't
18:31:28 <elliott_> ais523: err, both are ragged-right here
18:31:47 <ais523> man's normally justified, I just assumed it'd be for perl docs too
18:32:06 <ais523> presumably the manpages are actually generated as manpages, not via nroff
18:32:23 <kallisti> `run echo 'open 0;print<0>' > quine.pl && perl quine.pl
18:33:17 <ais523> hmm, it looks like nroff
18:33:34 <ais523> .\" For nroff, turn off justification. Always turn off hyphenation; it makes
18:33:36 <ais523> .\" way too many mistakes in technical documents.
18:33:52 <ais523> it looks like some workaround for nroff specifically in pod2man
18:34:02 <ais523> it's conditioned on nroff being the implementation used, and wouldn't happen in groff or troff
18:34:08 <elliott_> what's the fastest way to forget how to write assembly code?
18:34:19 <ais523> elliott_: in which language?
18:34:40 <ais523> I think you'd have to learn how to write asm in spanish first
18:35:40 <elliott_> ais523: (what did you actually mean by that question?)
18:36:40 <ais523> which asm variant, I think I meant
18:36:40 <ais523> as in, x86 asm, 6502 asm, etc
18:37:15 <ais523> I suppose if you wanted to forget asm for a particular platform, you could just learn it for another platform that's much nicer
18:37:20 <ais523> go work on SPARC asm or something for a while
18:37:28 <ais523> why do you want to forget x86 asm, incidentally?
18:38:00 <elliott_> ais523: to prevent me from trying to write a horrible thing
18:38:12 <ais523> it might be easier to fix the reason rather than the immediate problem
18:38:12 <ais523> elliott_: oh, err, uh-oh
18:38:23 <ais523> (if I demoralize elliott_ enough, that'll have the same effect with less pain)
18:38:44 <ais523> elliott_: writing a horrible thing will make you a worthless human being, even if you succeed; especially if you succeed, possibly more so if you fail
18:39:05 <elliott_> ais523: see, now what'll happen is I'll end up writing it anyway, and then I'll get all sad because you're mean
18:39:18 <ais523> elliott_: you don't want to make me mean, do you?
18:39:28 <ais523> not even retroactively? especially not retroactively?
18:39:51 <ais523> that looks nothing like Feather
18:40:02 <ais523> you'd have to <<= me with a slightly modified ais523
18:40:04 <elliott_> you can change Feather's syntax, can't you?
18:40:07 <ais523> probably through a wrapper function, to prevent a time loop
18:40:18 <elliott_> !feather loads the Alternate Standard Feather Library which is more popular nowadays
18:40:25 <ais523> elliott_: well, yes, I guess, but at some point it stops being Feather, and starts being a different language with similar semantics but different syntax
18:41:02 <elliott_> ais523: changing <<= to = and adding sugar for record access doesn't seem that drastic
18:41:29 <ais523> but that'd be negative sugar
18:41:36 <ais523> as you would need just a space there for record access, typically
18:41:54 <elliott_> ais523: in the future, people like to put spaces in identifiers
18:42:05 <elliott_> so that was added to the ASFL due to popular demand
18:42:06 <ais523> also, hmm, I wonder if the value of ais523 mean would be shared with other values
18:42:34 <ais523> you could do "ais523 mean <<= true" (and probably get yourself stuck in a time loop), but if it was sharing with other booleans at the time, that'd be equivalent to "false <<= true", which, umm, is probably a bad idea
18:42:46 <ais523> (this is assuming you have sugar for false and true, which you probably do)
18:43:02 <ais523> false <<= true looks set to be even more fun than false become: true
18:43:25 <elliott_> what happens if you do, e.g., x <<= [x] where [x] is the singleton list of x?
18:43:33 <elliott_> Feather rapidly allocates memory?
18:43:46 <ais523> you get a list containing the metaold value of x
18:43:57 <ais523> however, that point in the code would be evaluated again, unless something stopped it
18:44:07 <elliott_> ais523: hmm, is there any way to make a cyclic structure in Feather?
18:44:21 <ais523> <<= is incredibly unsafe; if it doesn't change some previous control flow behaviour of the program, you get a time loop
18:44:42 <ais523> so people will probably normally use sugar around it to use some safer operation, such as "add currently nonexisting method"
18:45:08 <ais523> elliott_: the trick would probably be to use the arbitrary number
18:45:28 <ais523> you can't have a true cyclic structure, but you can have a retroactively cyclic structure
18:45:52 <kallisti> in any case my 4D logical graph rewriting language is going to.. what's the word.. baller.
18:46:09 <elliott_> ais523: Feather concurrency sounds like fun
18:46:14 <nooga> anyone taking part in ioccc ?
18:46:18 <ais523> (that is, any test you perform to try to demonstrate it not cyclic, it retroactively becomes just cyclic enough to prevent that test working; if you do something that would be an infinite loop on a cyclic structure, you get an infinite loop)
18:46:23 <ais523> nooga: I am, Gregor is
18:46:30 <kallisti> I do feel like writing something in C
18:46:44 <kallisti> just not sure if I want to write obfuscated C, or why I would bother trying to make an entry.
18:46:53 <elliott_> ais523: here's a fun concurrency strategy: if conflicts occur, retroactively use a different ordering of threads instead
18:47:12 <ais523> really, I'm not going to even attempt concurrency in Feather
18:47:15 <zzo38> Just write whatever in C according to the program you want to write specifically
18:47:22 <Gregor> kallisti: May as well not bother, as I'm going to win.
18:47:26 <ais523> it's sort-of like trying to do concurrency in Haskell, only worse
18:47:29 <ais523> Gregor: there are multiple winners
18:47:44 <Gregor> ais523: Only one "best in show" (or whatever they call it)
18:47:45 <elliott_> ais523: concurrency in haskell works brilliantly
18:47:49 <ais523> Gregor: I'm not aiming for best in show
18:47:58 <ais523> but for small program, and rules abuse
18:48:15 <ais523> elliott_: indeed; but you need external libraries, or else for the compiler to deduce it as an optimisation
18:48:20 <Gregor> ais523: Actually, I want them to invent a category for me.
18:48:24 <ais523> (external = not writable in Haskell)
18:48:25 <Gregor> But failing that, I'll take best in show X-P
18:48:35 <elliott_> ais523: by "concurrency", I just meant lock-step or whatever
18:48:47 <ais523> you'd have to change the entire execution model of the program
18:48:55 <ais523> but the worrying thing is, this is Feather, and you can actually /do/ that
18:49:01 <Phantom_Hoover> <kallisti> in any case my 4D logical graph rewriting language is going to.. what's the word.. baller.
18:49:28 <kallisti> okay fine well what's a graph except now it has distances in a 4D space.
18:49:46 <ais523> kallisti: a labeled-edge graph?
18:49:59 <ais523> (do the positions matter in 4D? or just the distances?)
18:50:07 <kallisti> oh? a labeled-edge GRAPH you say?
18:50:23 <kallisti> maybe just distances? both? -shrug-
18:50:36 <ais523> Phantom_Hoover: indeed; but you can certainly define a sort of graph that does
18:50:36 <kallisti> Phantom_Hoover: believe it or not I am actually familiar with graph theory
18:50:45 <ais523> and they are in fact useful
18:50:47 <Phantom_Hoover> You're just going to be assigning labels to edges based on some embedding of the graph.
18:50:54 <ais523> Phantom_Hoover: that's why I said labeled-edge graph
18:52:17 <kallisti> I'm thinking only distances or relevant, so it may not really have 3 spatial dimensions.
18:53:01 <kallisti> Phantom_Hoover: going for reversability, the 4th dimension would be forward and backward in computation steps.
18:53:05 <Phantom_Hoover> My guess is that the only thing actually having an embedding somewhere is going to change is the fact that the triangle inequality imposes limits.
18:53:52 <ais523> Phantom_Hoover: nah, if you know nearly all the sides and diagonals of a hyper-n-gon, then that's going to lock in the location of the points, thus restricting the other sides and diagonals
18:54:06 <ais523> the value of n depends on the number of dimensions involved
18:55:08 <kallisti> in any case whether or not it actually corresponds to a 3 dimensional space is irrelevant. I don't think I'm going to keep track of position but instead just do distance relationships.
18:55:34 <Phantom_Hoover> But as ais523 says, you need to know position to tell if the distance relationships are meaningful.
18:55:59 <kallisti> meaningful in what sense? can't I just not care?
18:56:15 <ais523> you possibly can not care
18:56:22 <ais523> the problem is wondering about whether or not you have reason to care
18:56:36 <elliott_> ais523: argh, I'm trying to think of how the infinite division memory model works and it's so confusing
18:56:51 <ais523> as in, do you have a reason for them to act like distances? and if so, is it just triangle inequality, or do you need more than that?
18:57:15 <Phantom_Hoover> ais523, BtW, your hyper-n-gon thing might just be a special case of the triangle inequality?
18:57:16 <kallisti> no reason for them to be distances.
18:57:21 <ais523> Phantom_Hoover: *general case?
18:57:32 <ais523> and it is, sort-of, but can lead to equalities as well as inequalities
18:57:33 <elliott_> f(x) = 1 : f(x) is easy to reject, because f^M(x) = 1 + f^M(x)
18:57:49 <elliott_> "The worst example of this sort of thing in my lifetime, and arguably in the entire history of science, has been the AGW (anthropogenic global warming) panic. Now that the wheels are falling off that juggernaut, I’m starting to hear ordinary people around me wonder how I knew it was bullshit and hot air so much in advance…" --esr
18:58:12 <ais523> ESR is a global warming denialist?
18:58:18 <ais523> hmm, I'm not massively surprised
18:58:25 <ais523> I wouldn't have been surprised by the opposite either, though
18:58:45 <elliott_> think of an idiotic far-right libertarian position; if esr doesn't have it, you should be surprised
18:58:59 <ais523> but there are idiotic far-right libertarian positions that contradict each other
18:59:43 <Phantom_Hoover> I've discovered that the idiotic far-right libertarian at my school is a) crazy and b) probably an actual sociopath.
19:00:10 <kallisti> ais523: the nodes corresponding to a physical space was just an interesting idea, but the main proof of concept is the non-deterministic time-based shenanigans (we seem to be doing a lot of those lately)
19:00:24 <elliott_> "Rhetoric that mixes science with the tropes of eschatological panic." actual quote
19:00:26 <ais523> yep, especially as I was playing Braid yesterday
19:00:44 <Phantom_Hoover> Feather transcends the timeline; ais has always not being developing it.
19:00:54 <ais523> hey, I work on it sometimes
19:01:03 <ais523> I even did NEF just fine without getting very bad
19:01:06 <elliott_> ais523: is Braid actually worth playing? I've been put off by how pretentious the developer is
19:01:08 <ais523> although I'm not sure it's useful
19:01:27 <ais523> elliott_: it's, umm, reasonably pretentious plotwise, but the graphics are pretty and the puzzles are interesting
19:01:38 <ais523> the "no filler" rule is really grating, though
19:01:42 <ais523> after a while you start wishing for filler
19:02:04 <ais523> it's also very difficult
19:02:18 <ais523> which is arguably good, as it means you won't reach the ending, which is the most pretentious part
19:03:03 <elliott_> Phantom_Hoover: Can AII be a metaphor for globalisation please.
19:03:25 <elliott_> Like, after you finish the single-player campaign, "IT WAS GLOBALISATION ALL ALONG" pops up and you have to "OH I GET IT" to get back to the menu.
19:03:32 <kallisti> ais523: would a 3D space be easier to manage if I restricted the graph from forming cycles with its present edges. (think of present edges as just... normal graph edges)
19:03:42 -!- ais523 has quit (Read error: Connection reset by peer).
19:03:46 <elliott_> Phantom_Hoover: Except clicking "OH I GET IT" just makes it change into "VERY CLEVER".
19:03:48 <zzo38> I fixed another thing in Super ASCII MZX Town game
19:03:54 <elliott_> Phantom_Hoover: And you have to click it again.
19:04:07 -!- ais523 has joined.
19:04:32 <kallisti> < kallisti> ais523: would a 3D space be easier to manage if I restricted the graph from forming cycles with its present edges. (think of present edges as just... normal graph edges)
19:04:35 <ais523> [error] Closing Link: 147.188.254.189 (No more connections allowed in your connection class)
19:05:00 <kallisti> ais523: get off the internet, low-class scum.
19:05:04 <ais523> kallisti: yes, in fact you could do it even in a 2D space, but then you basically have a tree, not a graph (it becomes an actual tree if you give it a root)
19:05:38 <kallisti> ais523: wow, so a tree is like... a graph without cycles?
19:06:00 <ais523> kallisti: that is the graph-theoretic definition of "tree", yes
19:06:15 <kallisti> (don't forget it's connected!)
19:06:17 <ais523> rooting it gives you the programming-language definition of "tree"
19:06:24 <ais523> well, OK, it's not a tree if it isn't connected
19:06:27 <ais523> it has to be connected to be a tree
19:06:34 <ais523> otherwise it's a forest (actual technical term)
19:06:36 <elliott_> "No more connections allowed in your connection class"
19:06:37 <elliott_> In English, this means the server is full for people like you, at least for now. People from different providers might still be able to connect. You might see this sometimes on servers that you were able to connect to just recently. Try a different port on the same server (other than 6667) or try a different server for a while.
19:06:39 <zzo38> I made barrier monad transform now. newtype BarrierT f b m t = BarrierT { runBarrierT :: m (Either t (f, b -> BarrierT f b m t)) };
19:07:14 <kallisti> ais523: are you sure a tree has to have a root to be a tree in computer science? seems kind of arbitrary.
19:07:27 <kallisti> I mean, I know they typically do...
19:07:50 <elliott_> kallisti: it's not arbitrary; it's hard to define an ADT without one
19:07:56 <ais523> kallisti: I'm talking about the usual recursive definition in terms of trees having a possible value (perhaps only if they have no branches), and 0-n branches
19:07:59 <ais523> that naturally leads to a route
19:08:29 <ais523> you can imagine a sort of "doubly-linked tree" which wouldn't need one, but it probably wouldn't be very useful given the typical applications of trees in CS
19:08:39 <elliott_> ais523: that doesn't encompass, e.g. data Tree a = Branch (Tree a) (Tree a) | Leaf a
19:08:53 <elliott_> <ais523> you can imagine a sort of "doubly-linked tree" which wouldn't need one, but it probably wouldn't be very useful given the typical applications of trees in CS
19:08:58 <elliott_> ais523: the closest thing is a tree zipper
19:09:01 <kallisti> I honestly haven't considered efficiency at all for this language.
19:09:11 <elliott_> list zippers are what we use instead of doubly-linked lists, after all
19:09:34 <ais523> elliott_: right, indeed; I was talking about not needing a root, rather than not having the links back (which are potentially useful for reasons unrelated to rooting)
19:09:50 <kallisti> rewriting nodes based on whether or not they satisfy logical predicates in a huge graph that never shrinks is probably not going to be fast.
19:10:03 <ais523> also, the "n is fixed" is a special case; that's a binary tree, which is a case of a tree where n = 0 or 2
19:10:43 <elliott_> fair enough, but the n=2 case has no value
19:10:58 <elliott_> also, what about data Tree a = Branch a (Tree a) (Tree a) | Leaf? that has a value only when n=2
19:11:41 <kallisti> perhaps if I restrict the kinds of predicates that one can use, then I can make the lookup algorithm fairly efficient..
19:11:57 <ais523> elliott_: a conditional value is fine as well, I think
19:12:06 <ais523> conditional on n, or maybe even on something else
19:12:23 <ais523> kallisti: part of the reason I haven't implemented eodermdrome is that I can't think of an efficient way to do it
19:12:50 <kallisti> ais523: in particular I intend to restrict the rewrite rules so that subgraphs cannot be replaced in one rewrite.
19:13:11 <kallisti> well, single nodes are subgraphs I guess.
19:13:15 <elliott_> ais523: didn't oklopol come up with an efficient way? Phantom_Hoover?
19:13:25 <ais523> elliott_: I think oklopol was working on it, but I can't remember the outcome
19:13:40 <elliott_> I thought the efficient way has been well-known in here for ages.
19:13:56 <elliott_> ais523: can we delete [[Excela]] so people stop vandalising it?
19:13:58 <ais523> hmm, come to think of it, indexing by degree, and context degree up to n levels, would be pretty efficient
19:14:03 <elliott_> ais523: you should probably protect it, anyway
19:14:17 <ais523> elliott_: if it gets spammed much more, I'll put an appropriate protection level on
19:14:20 <ais523> is it anons or registered users?
19:14:26 <elliott_> http://esoteric.voxelperfect.net/w/index.php?title=Excela&action=history
19:14:32 <elliott_> I don't think it's going to stop
19:14:46 <elliott_> it's every three days, roughly
19:14:47 <kallisti> I'm thinking I could probably make it efficient if I restrict the kinds of rewrite rules and predicates that can be expressed, and by using other data structures besides a graph in the implementation, at the expense of more memory overhead.
19:14:52 <ais523> elliott_: you just made me revert your revert by mistake!
19:14:57 <kallisti> for a language that, as far as I can tell, does not ever free memory.
19:15:18 <kallisti> unless a garbage collection or manual memory management scheme can be created... but I have no idea how that would work.
19:15:35 <ais523> elliott_: with those spambots, in the past, all the spamming they've done has been confined to one article, but moves to a different one if you protect it
19:16:06 <elliott_> kallisti: most modern languages never free memory
19:16:28 <kallisti> ..wha? is this some weird technical distinction I'm missing?
19:16:56 <elliott_> Python has no free(), Perl has no free()
19:16:57 <ais523> elliott_: do you mean "return memory to the OS" by "free"?
19:17:06 <elliott_> Common Lisp and Scheme have no free()
19:17:12 <ais523> ah, no, you mean "don't have an explicit command to free"
19:17:18 <elliott_> ais523: no, I mean "don't free"
19:17:27 <ais523> elliott_: $x = undef; will free the previous thing that $x referred to if it was the only reference
19:17:32 <elliott_> the fact that most implementations optimise things by discarding memory that they can prove won't be referenced in the future is irrelevant tot he language
19:17:45 <ais523> elliott_: and even run its finalisers
19:17:50 <kallisti> s/language/implementation/ --debate solved
19:17:53 <elliott_> well, finalisers are usually implementation-specific
19:18:10 <elliott_> for instance, I bet Jython won't run finalisers if you do x = None
19:18:12 <ais523> elliott_: they're part of the language in Perl 5 and predictable; this sort of thing may be /why/ it only has one impl
19:18:14 <elliott_> because it doesn't use refcounting
19:18:23 <ais523> does Python even have finalisers?
19:18:40 <ais523> (also, is "finaliser" or "destructor" the more common name nowadays?)
19:19:07 <Phantom_Hoover> <elliott_> ais523: didn't oklopol come up with an efficient way? Phantom_Hoover?
19:19:17 <elliott_> destructor is Python jargon meaning something else, I think, which is why kallisti might see it more often
19:19:25 <elliott_> certainly I always see "finaliser" in memory-management texts
19:19:39 <kallisti> elliott_: no I see it in my Java and C++ classes as well.
19:19:40 <Phantom_Hoover> I concluded that implementing Ullman's algorithm with appropriate specialisations would get the match stage (the real time sink) down to polynomial time.
19:19:59 <ais523> I normally go with Java terminology for javaish-OO stuff, bceause Java's implementation on the javaish-OO world is quite large
19:20:05 <elliott_> Phantom_Hoover: I thought there was something simpler than that
19:20:14 <ais523> (we really need a name for the Java/C++/C#ish OO to distinguish it from Smalltalky OO)
19:20:18 <elliott_> ais523: well, they're called finalisers in java
19:20:29 <elliott_> ais523: anyway, destructors are something subtly different, I believe
19:20:29 <ais523> that's why I used that name without really thinking
19:20:37 <elliott_> ais523: they're things you run explicitly
19:20:42 <ais523> even though you aren't meant to use finalisers in Java ever nowadays
19:20:45 <Phantom_Hoover> Well, Ullman's algorithm optimises subgraph matching down to polynomial if you have constant subgraphs.
19:20:49 <ais523> because they're so unpredictable
19:21:04 <kallisti> ais523: I think it's usually called class-based OO
19:21:06 <elliott_> ais523: why unpredictable? just because GC is?
19:21:09 <elliott_> kallisti: smalltalk is class-based
19:21:23 <kallisti> right. I was thinking of self and friends.
19:21:28 <ais523> elliott_: in Java, there's no guarantee that they're ever actually run at all
19:21:37 <elliott_> ais523: sure; that doesn't seem relevant to me
19:21:46 <ais523> and I'm not sure if it's purely GC-related
19:21:48 <elliott_> GHC's finalisers have the same property and they're used with abandon
19:21:48 <ais523> although it probably is
19:22:18 <ais523> also, hmm, what context do GHC finalizers run in? some suitable IO monad that's made to happen at an arbitrary time relative to other events?
19:22:39 <elliott_> http://hackage.haskell.org/packages/archive/base/4.4.1.0/doc/html/Foreign-ForeignPtr-Safe.html
19:22:53 <elliott_> your question is incoherent and contains type errors, so i'll just link you docs instead :P
19:23:01 <ais523> indeed, it contains type errors
19:23:10 <ais523> I missed that they aren't Haskell
19:23:21 <kallisti> elliott_: your mouth is a type error
19:23:41 <ais523> well, they're run via the FFI
19:23:42 -!- oerjan has joined.
19:23:43 <elliott_> oh, http://hackage.haskell.org/packages/archive/base/4.4.1.0/doc/html/System-Mem-Weak.html also has finalisers
19:24:11 <ais523> "A finalizer is represented as a pointer to a foreign function…"
19:24:23 <elliott_> well, OK, but that's not relevant: http://hackage.haskell.org/packages/archive/base/4.4.1.0/doc/html/Foreign-Concurrent.html
19:24:35 <elliott_> and the System.Mem.Weak finalisers are just actions too
19:25:49 <ais523> so the answer is, they have to return a marshallable type, or an IO of a marshallable type
19:26:01 <ais523> and making them pure functions is obviously ridiculous, so in practice, they're IO actions
19:27:06 <Phantom_Hoover> Hey guys if you're libraring can you see if you can find an implementation of that algorithm.
19:27:59 <elliott_> <ais523> so the answer is, they have to return a marshallable type, or an IO of a marshallable type
19:28:03 <elliott_> this is wrong and/or makes no sense
19:28:31 <ais523> ah, I saw type FinalizerPtr a = FunPtr (Ptr a -> IO ())
19:28:42 <ais523> then looked up the definition of FunPtr, and saw its restriction on types it accepted
19:28:53 <ais523> and missed that FinalizerPtr had a stronger restriction (specificlaly, that it returned IO ())
19:29:13 <elliott_> well, it's true that the types are always used that way in finaliser use
19:29:16 <ais523> elliott_: look, it's pointless linking me to docs if you're going to disagree with everything that I glean from them
19:29:21 <elliott_> but it's quite irrelevant, since the FinalizerPtr takes a Ptr
19:29:33 <elliott_> so it's irrelevant whether the a being finalised is marshallable or not
19:29:51 <ais523> I didn't say it was relevant
19:29:55 <ais523> I was talking merely about the return value
19:29:57 <elliott_> ais523: I link you to documentation because I can't think of any way to answer your question because it doesn't make any sense; I can just ignore false things you deduce from it if you want *shrugs*
19:30:39 <ais523> the return value is IO (), the argument isn't IO anything, thus the finalizer is an IO action
19:30:43 <ais523> which is what the question was in the first place
19:30:54 <elliott_> err, "the argument isn't IO anything"?
19:32:01 <ais523> elliott_: a function of type IO a -> IO a isn't really an IO action
19:32:15 <elliott_> IO actions look like IO a for some a
19:32:29 <elliott_> (id m :: IO a) for some m, a is certainly an IO action
19:32:37 <elliott_> and (IO a -> IO a) is certainly a function from an IO action to an IO action
19:32:53 <ais523> the IO /value/ is what's referred to as the action
19:32:56 <elliott_> ais523: no, just the typical non-Haskeller mistake of assuming something like (IO a) is a "function of 0 arguments"
19:33:07 <elliott_> thus assuming that if (IO a) is an action then (... -> IO a) must be too
19:33:13 <elliott_> at least, that's how I usually see that mistake being made
19:33:22 <ais523> hmm, I think I might have made it based on different reasoning
19:33:27 <ais523> it's because of the whole do-sugar thing
19:33:43 <ais523> it's because you can >>= onto a function of type x -> IO a
19:33:54 <ais523> and that's a behaviour of >>= rather than of IO
19:34:00 <ais523> but it feels like a behaviour of IO unless you concentrate
19:34:07 <elliott_> anyway, can anyone here get behind ACM paywalls who isn't too legalistic to share the spoils?
19:34:29 <elliott_> ais523: I think "join :: IO (IO a) -> IO a" may be clarifying, then, since you can use fmap/return/join instead of return/(>>=)
19:34:35 <zzo38> But of course there is more than >>= since there is also fmap, join, <$>, <*>, and so on
19:34:44 <ais523> elliott_: even people who can get behind the paywalls, it's heavily DRMed
19:34:56 <ais523> so I'm not entirely sure copying the resulting file would work, although it probably would to some extent
19:34:59 <elliott_> ais523: i.e., "if you have an IO program that produces another IO program that produces an a, then you can turn that into an IO program that produces an a (by just executing the program you get out of it)"
19:35:14 <elliott_> ais523: also, I'm pretty sure it would, since people regularly get pdfs behind paywalls for others...
19:35:33 <ais523> my guess is you'd be able to read it, but need a hacked PDF reader to be able to do anything but read it
19:35:42 <ais523> perhaps it'd allow printing, if you were lucky
19:35:51 <elliott_> ais523: you realise that no pdf reader apart from like
19:36:00 <elliott_> actually obey the drm bullshit
19:36:14 <zzo38> Retype it if you need to...
19:36:18 <ais523> elliott_: in that case, they're illegal in the US, or some such nonsense
19:36:29 <elliott_> ais523: I doubt that very much
19:37:08 <ais523> the DMCA is kind-of ridiculous
19:37:15 <ais523> it's much the same thing as libdvdcss, just on a smaller scale
19:37:39 <ais523> (in that instead of heavy encryption, it's just a note saying "please")
19:37:39 <Phantom_Hoover> <elliott_> anyway, can anyone here get behind ACM paywalls who isn't too legalistic to share the spoils?
19:37:59 <Phantom_Hoover> I have several friends in university who probably have access.
19:38:03 <Vorpal> <kallisti> Sgeo: updersation between itidus21, Vorpal, and kallisdeet <-- what?
19:38:05 <elliott_> ais523: you should delete evince, it's clearly illegal :)
19:38:09 <elliott_> Phantom_Hoover: Dude, I just linked you to the pdf.
19:38:22 <ais523> elliott_: this sort of thing is why I refuse to go to the US :)
19:38:42 <elliott_> ais523: I'm sure we have something draconian enough to outlaw it
19:38:42 <ais523> also, why I didn't take any sort of computer with me to Canada, although that was at least just as much a distrust of airports
19:39:22 <ais523> I spent a week without Internet access there (except for a few minutes when I sneaked onto one of the computers the lecture hall used for projecting stuff on the screen; an old trick)
19:39:42 <ais523> without even usable phone, either, mobile or landline
19:40:09 <ais523> (there were payphones, but they took around 5 minutes to calculate the cost of a call to the UK, and then quoted an amount so large it'd have been really awkward to pay using coins)
19:42:28 <elliott_> OK, ais523 has to hear my terrible idea now because it'll either help me forget about it, or reassure me that I'm not the only one suffering
19:42:44 <ais523> elliott_: you have found your own Feather :)
19:43:16 <elliott_> ais523: a simple POSIX-alike where everything is run in ring 0 with @-style techniques; memory access requires checking that it's owned by the process
19:43:41 <ais523> a ring 0 process could trivially change the perms
19:43:48 <elliott_> I /think/ it would end up more efficient than traditional implementations, because a branch per RAM access is cheaper than the syscall overhead
19:44:02 <elliott_> ais523: yep; although I was also considering if hardware virtualisation stuff could do it
19:44:03 <ais523> you verify that the program is itself doing access checks on itself
19:44:05 <elliott_> since that's ubiquitous nowadays
19:44:08 <ais523> and don't run it if it doesn't
19:44:13 <ais523> that feels strangely evil
19:44:18 <elliott_> ais523: well, I was just going to make a C compiler do it
19:44:29 <elliott_> but checking the binary would be viable, too
19:44:32 <ais523> yes, but what it does to the poor binary is beautifully ridiculous
19:44:47 <ais523> it'd be the age of lawful programs
19:44:56 <ais523> don't do anything without checking it's legal first, even though they /could/
19:45:01 <elliott_> ais523: oh, and if the compiler is trusted that lets it optimise out certain checks
19:45:18 <elliott_> e.g. a = malloc(...); if (a) { ... *a ... } -- you don't need to check a afterwards
19:45:23 <ais523> that sounds like a recipe for exploiting compiler bugs
19:45:35 <elliott_> ais523: compiler bugs can already lead to exploits, though
19:45:42 <elliott_> if a daemon running as root is miscompiled
19:46:04 <ais523> probably less likely to be exploitable on average, but it's still a qualititative difference
19:46:14 <elliott_> anyway, I'm tempted to do this because it sounds easier than @, and would be a neat proof-of-concept that some of its low-level details do increase efficiency
19:46:36 <ais523> hmm, I remember the paper that found that if a processor got even a single multiplication wrong, it would be possible to crack some sort of encryption (I forget what) done on it
19:46:36 <elliott_> and ofc with @ the risk for compiler bugs is reduced since it's not based on "checks" for safety, but safety-by-design using the object capability model and the type system
19:46:44 <kallisti> There is no statement of there ever being any male Sheikah since the true gender of Sheik is debated by many fans.
19:46:47 <ais523> assuming you can get it to encrypt arbitrary text for you, or something like that
19:47:14 <ais523> kallisti: I think it's mostly an issue of semantics
19:47:21 -!- zzo38 has quit (Quit: zzo38).
19:47:43 <ais523> this reminds me of the argument over Metroid Prime's gender (he, she, it are all viable options with plausible arguments makeable for them; plot-wise, it doesn't matter in the least)
19:48:00 <ais523> and, by extension, Dark Samus'
19:48:13 <kallisti> and it doesn't explicitly mention anything about Sheik actually being male
19:48:18 <ais523> kallisti: I'd be very surprised if that prevented people writing Sheik/Zelda slashfic
19:48:32 <kallisti> that Sheik is a female, like Zelda, since they're the same person
19:48:37 <ais523> Sheik was deliberately made with a male 3D model
19:48:46 <ais523> but that was to keep the Sheik=Zelda thing secret from the player until right at the end of the game
19:48:48 <kallisti> sure MAGICAL GENDER CHANGING is possible but... not mentioned so not canon.
19:49:11 <ais523> I think the most plausible argument is that Zelda is just very good at disguising herself, even if it includes cross-dressing
19:49:25 <kallisti> basically I think some people just want Sheik to have a penis.
19:50:21 <kallisti> or like, they played the game thinking Sheik was a male and then when it was revealed they.... resisted changing their mind or something?
19:51:29 <kallisti> though you could argue that there may be magic involved, since sheik has different eye color (red, like a Sheikah)
19:51:41 <kallisti> maybe Zelda just has some awesome contacts though.
19:51:50 <kallisti> you know what's fun? speculation about video game characters.
19:55:51 <Phantom_Hoover> Conservation of volume is presumably still conserved under normal circumstances, no matter how many bandages you use.
19:56:14 -!- calamari has quit (Quit: Leaving).
20:01:27 <elliott_> back; disappointed not to see "biarb" from ais523
20:02:10 <elliott_> kallisti: I find it odd to posit that magic is used for changing eye-colour but to consider it unreasonable to posit that magic was used to change a far more drastic change in bodily structure (note: I have never played a Zelda game for long)
20:02:26 <elliott_> ofc, this is unrelated to the question of gender
20:03:41 <elliott_> does anyone know much about AMD-V / Intel VT-x?
20:12:43 <ais523> elliott_: in Zelda games, magic exists but mostly only has a few defined effects
20:12:53 <elliott_> ais523: is changing eye-colour one of them?
20:13:07 <ais523> but Zelda seems capable of unusual magical abilities
20:13:22 <ais523> so who knows what magic she can do
20:13:32 <ais523> I'm wondering if she was just using coloured contact lenses, though
20:14:37 <elliott_> thing it's hard to find information on: whether you can do hardware virtualisation in ring 0
20:14:42 <elliott_> as in, the code being virtualised runs in ring 0
20:15:34 <elliott_> that's what hardware virtualisation is for, it seems
20:20:29 <elliott_> ais523: hmm, I think what I'm doing is something like Xen, but where each program is an OS
20:21:16 <ais523> this sounds like decent practice for @
20:21:55 <elliott_> ais523: yes, the only problem is that (a) I don't have a machine with the virtualisation stuff I need (b) it's literally all about low-level hardware details :)
20:23:01 <ais523> elliott_: I'm not sure if I should advise you to put @ off, or complete it now before you end up getting a job and not having time for that sort of large project
20:23:29 <elliott_> ais523: clearly the only solution is to have someone pay me to work on @
20:23:51 <elliott_> actually, I should write all but one line of @ while it's still in my head, and then write the last line whenever I need a Ph.D. handy :D
20:24:42 <ais523> elliott_: you can actually get a PhD entirely on work you've already done
20:24:49 <ais523> just, you're unlikely to get funded in that situation
20:25:17 <elliott_> I think the main problem is that I'd have to write a book justifying @
20:25:23 <elliott_> actually, I've probably already done that in here
20:25:59 <ais523> the main problem is finding all the previous work on mildly related things
20:26:07 <ais523> to show how a) you were inspired by it, and b) it's different from what you're doing
20:26:33 <elliott_> ais523: I'm kind of already doing that by digging up everything related I can find to take inspiration from it :P
20:26:46 <ais523> elliott_: keep a record of it, then
20:26:53 <ais523> citation details, at least
20:27:02 <elliott_> but I probably should at least have a bookmark folder or something
20:27:06 <ais523> nah, less boring doing it at the time when it's easy, then later when it takes a lot longer
20:27:14 <elliott_> ais523: s/then/than/, presumably
20:27:22 <ais523> grabbing citation details is quick and easy
20:27:33 <ais523> formatting them for consistency is the boring part, but that can easily be done much later
20:28:06 <elliott_> ais523: ooh, I know, I'll just do @ now, and then my Ph.D. can be /naming/ it
20:28:22 <elliott_> lots of graphs and statistics on the emotional response to various potential names
20:28:33 <ais523> then it'd, umm, be a PhD in marketing
20:28:45 <ais523> which would be a bizarre thing for you to have
20:28:58 <elliott_> ais523: no, I'd, er, develop a New Kind of Name Generation Algorithm
20:29:04 <elliott_> that only works on @, for some reason
20:29:28 <ais523> elliott_: spambot-based naming?
20:29:39 <elliott_> perfect @ name generator algorithm that only works on @: get_current_os_name()
20:31:02 <ais523> but it only works on @ /after it's named/
20:31:13 <elliott_> ais523: it's not @ until it's named!
20:31:38 <ais523> wow, will this conversation look weird once @ /is/ named and we search-and-replace the logs
20:33:08 -!- GreaseMonkey has joined.
20:33:39 <elliott_> ais523: ooh, now i really hope Gregor does tha
20:33:53 <ais523> and clog's owners too?
20:34:09 <elliott_> ais523: clog will probably turn to rust before then
20:34:22 <ais523> but the logs will probably be backed up
20:34:24 <ais523> also, can IRC bots rust?
20:35:28 <oerjan> it'll just eventually clog up
20:37:06 <shachaf> @ elliott_ You can't rewrite history!
20:37:21 <shachaf> @ ais523 I'm just going to start Twitter-addressing everybody.
20:37:24 <elliott_> I changed it after the completion of @ to honour it.
20:37:38 <elliott_> shachaf: that's not twitter-addressing, you need to omit the space, and also replace @ with an at sign
20:38:06 <shachaf> I don't know if I have it on my keyboard; you should type it so I can copy it.
20:39:13 <elliott_> (thankfully, the regexp will take escapes into account)
20:39:54 <shachaf> You could've picked a less common character...
20:41:15 <elliott_> [elliott@dinky esoteric]$ fgrep '\@' ????-??-??.txt | wc -l
20:41:50 <shachaf> I mean, less common than '@'.
20:42:01 <ais523> `run fgrep '\@' ????-??-??.txt | wc -l
20:42:04 <HackEgo> fgrep: ????-??-??.txt: No such file or directory \ 0
20:42:08 <elliott_> shachaf: @ is the only thing that's right for it
20:42:09 <ais523> wait, I need to change the directory
20:42:13 <ais523> `run fgrep '\@' logs/????-??-??.txt | wc -l
20:42:16 <HackEgo> fgrep: logs/????-??-??.txt: No such file or directory \ 0
20:42:20 <elliott_> `run fgrep '\@' /var/irclogs/_esoteric/????-??-??.txt | wc -l
20:42:25 <ais523> aha, that's where it is?
20:42:44 <HackEgo> bin \ canary \ karma \ lib \ paste \ quotes \ share \ wisdom
20:43:01 <HackEgo> bin/ \ canary \ karma \ lib/ \ paste/ \ quotes \ share/ \ wisdom/
20:43:58 <HackEgo> Runs arbitrary code in GNU/Linux. Type "`<command>", or "`run <command>" for full shell commands. "`fetch <URL>" downloads files. Files saved to $PWD are persistent, and $PWD/bin is in $PATH. $PWD is a mercurial repository, "`revert <rev>" can be used to revert to a revision. See http://codu.org/projects/hackbot/fshg/
20:44:24 <HackEgo> 1170: No such file or directory \ 1171: No such file or directory
20:44:31 <HackEgo> diff -r 0d97b97d3636 -r 1cc5d9c44760 wisdom/shachaf \ --- a/wisdom/shachaf.Sat Nov 26 18:17:45 2011 +0000 \ +++ /dev/null.Thu Jan 01 00:00:00 1970 +0000 \ @@ -1,1 +0,0 @@ \ -shachaf mad
20:44:42 <elliott_> `run hg diff -r 1170 -r 1171 | patch
20:44:45 <HackEgo> The next patch would delete the file shachaf, \ which does not exist! Assume -R? [n] \ Apply anyway? [n] \ Skipping patch. \ 1 out of 1 hunk ignored
20:44:49 <elliott_> `run hg diff -r 1170 -r 1171 | patch -R
20:45:02 <HackEgo> ? \ ais523 \ augur \ banach-tarski \ c \ cakeprophet \ category \ elliott \ everyone \ finland \ finns \ fizzie \ flower \ friendship \ functor \ fungot \ gregor \ hackego \ haskell \ ievan \ intercal \ itidus20 \ kallisti \ mad \ monad \ monads \ monoid \ monqy \ nooga \ oerjan \ oklopol \ phantom__hoover \ phantom_hoover \ php \ qdb \ qdbformat \ quine \ sgeo \ u \ vorpal \ welcome \ wiki \ you
20:45:33 * shachaf is flattered that you went to all that trouble.
20:45:37 <ais523> why not just re-add it by hand?
20:45:51 <ais523> it'd probably have been simpler
20:45:58 <HackEgo> "Banach-Tarski" is an anagram of "Banach-Tarski Banach-Tarski".
20:46:31 <ais523> elliott_: don't you need to revert 2? or does it just revert the last side-effecting command?
20:46:43 <elliott_> ais523: only mutating commands commit
20:46:54 <HackEgo> C is the language of��V�>WIד�.��Segmentation fault
20:46:54 <Vorpal> elliott_, like `quote ?
20:47:13 <Vorpal> elliott_, oh? Why did you remove that feature?
20:47:15 <HackEgo> abort: could not lock working directory of /hackenv: Read-only file system
20:47:22 <elliott_> Vorpal: because it'd mess up transactional hackego :)
20:47:26 * shachaf has no idea how to use hg.
20:48:09 <HackEgo> cat: bin/revert: No such file or directory
20:48:13 <elliott_> How is HackEgo talking withotu commands?
20:48:24 <Vorpal> shachaf, at least two people want to keep it. Me and elliott. That means a majority of us three.
20:48:36 <elliott_> It's okay, he can have it deleted.
20:48:40 <shachaf> Vorpal: I have extra votes because I'm me.
20:48:53 <Vorpal> elliott_, you just did that to annoy me. Good job :P
20:49:03 <ais523> shachaf: but kallisti has extra votes because he's Bjorn
20:49:28 <HackEgo> Runs arbitrary code in GNU/Linux. Type "`<command>", or "`run <command>" for full shell commands. "`fetch <URL>" downloads files. Files saved to $PWD are persistent, and $PWD/bin is in $PATH. $PWD is a mercurial repository, "`revert <rev>" can be used to revert to a revision. See http://codu.org/projects/hackbot/fshg/
20:49:32 <shachaf> Vorpal: The only reason you wanted to keep it was that elliott_ wanted it.
20:49:39 <shachaf> elliott_: You should get rid of the _.
20:49:45 <shachaf> It's grating on the fingers, you know.
20:49:45 <Vorpal> shachaf, come on. We two usually never agree on /anything/
20:49:58 <shachaf> Vorpal: Unless annoying a third party is at stake!
20:50:10 <Vorpal> shachaf, not really no
20:50:27 <ais523> shachaf: wait, you're annoying? I hadn't realised
20:50:41 <elliott_> Yes, shachaf is super annoy(ing|ed).
20:52:08 <ais523> <Oswald McWeany> Yeah, I was buying cell-batteries the other day and the retailer wanted me to enter a facebook user and password so it could automatically insert a facebook comment that I had purchased batteries from them.
20:52:37 <ais523> gah, my mind cannot comprehend the amount of stupidity in existence implied by that comment
20:52:44 <ais523> (not from the author, he clearly couldn't either)
20:53:23 <elliott_> ais523: if it makes money, it's not stupidity
20:53:40 <ais523> elliott_: I'm not convinced it's stupid from the retailers' point of view either
20:53:55 <ais523> but for it to be sensible from their point of view, implies a sufficient number of stupid people around that it actually makes a profit
20:54:59 <Vorpal> ais523, it could be an experiment to find out if that is the case?
20:55:00 <elliott_> ais523: well, it's not necessarily stupid to prioritise not being bothered by a retailer over very minorly annoying some people, considering how much noise facebook has anyway
20:55:05 <Vorpal> hopefully it is not the case
20:55:32 <ais523> elliott_: it /is/ stupid to give a username and password that you probably use for everything to a random retailer, though
20:56:15 <elliott_> ais523: well, OK, but I'd rather blame (a) the username/password model to start with and (b) the lack of proper computer security education, although (b) is massively impaired by the fact that the current systems are unusable (see (a))
20:56:39 <ais523> what model would be better than username/password, and also that people could be persuaded to use?
20:56:44 <elliott_> and there are situations where you have to give away your password; for instance, when trying to get my MacBook replaced, Apple demanded my password
20:56:53 <elliott_> which doesn't exactly educate people not to give their passwords away
20:57:11 <ais523> elliott_: err, what? that seems like a bizarre thing for them to want
20:57:22 <ais523> is that the login password to unlock the computer for the main user?
20:57:24 <elliott_> ais523: I tried notto think too much about it
20:57:42 <ais523> ah, OK, probably to verify that you're an actual customer of theirs
20:57:58 <ais523> a password to log in to the person at the other end of the phone is reasonable
20:58:07 <ais523> no obvious reason why they should be restricted to computers
20:58:15 <elliott_> yes, but it's still giving your password to someone else, so it's hardly surprising that people aren't averse to doing that
20:58:20 <ais523> other than salting/hashing being hard to do mentally
20:58:33 <Vorpal> ais523, hardware certificates + password entered on the hardware certificate device use to sign a response code. That should be better than classical user/password. Major PITA for anything except bank transactions and other high security stuff
20:58:35 <ais523> (actually, salting is easy)
20:58:49 <ais523> a password existing for the purpose of giving to specific other people is reasonable to give to those people
20:58:55 <elliott_> ais523: anyway, I don't know which model is necessarily better than passwords, but things like OpenID are a start, even if they have a password at the base of it; public key crypto is also promising
20:59:32 <Vorpal> elliott_, hardware certificates :P
20:59:42 <elliott_> Vorpal: a GPG key on a USB key integrated into your browser that asks for the passphrase when it's plugged in doesn't seem that bad to me
20:59:54 <elliott_> especially if the USB key doesn't expose the GPG key but just signs things as it
20:59:58 <Vorpal> elliott_, I was thinking along the lines of smartcard but sure
21:00:11 <ais523> elliott_: in that case, you can put a fingerprint reader on the USB device
21:00:25 <elliott_> ais523: everything i've read suggests fingerprint readers are completely insecure
21:00:27 <ais523> probably saves time over password memorisation, and you still have two factors
21:00:42 <ais523> elliott_: right, the problem is that they're too easily brute-forced
21:00:47 <Vorpal> fingerprint readers are insecure yeah
21:00:49 <elliott_> ais523: and copiable, I believe?
21:00:53 <ais523> but someone would probably notice brute-forcing in a shop
21:00:58 <Vorpal> you want an iris scanner!
21:01:12 <elliott_> ais523: true, but nobody wants an authentication mechanism that only works in shops
21:01:31 <ais523> all biometrics are copiable for the same reason that all videos are copiable
21:01:38 <ais523> they have to be translated to data at some point, and you can copy that
21:01:51 <Vorpal> ais523, fingerprints are easy to copy however iirc
21:01:51 <elliott_> ais523: in a shop, something like logging in on a smartphone and passing an authentication to post a status update wirelessly seems like the most reasonable way to do something like this (not that it /should/ be done)
21:01:53 <ais523> and just use it directly rather than scanning it in
21:02:12 <elliott_> that way, the shop can't do anything at all apart from post one status update right then
21:02:15 <ais523> elliott_: hmm, perhaps the shop should have a QR code, and the smartphone scans that
21:02:23 <ais523> it probably knows the Facebook username/password already
21:02:25 <Vorpal> ais523, like if you have a laser printer + some stuff that is easy to get your hands on for not a lot of money you can copy a fingerprint
21:02:30 <elliott_> heh; I gather that QR codes aren't gaining traction because they're really ugly,t hough
21:02:34 <Vorpal> forgot the exact details
21:02:37 <ais523> you'd probably have to accept an authorisation popup first time
21:02:42 <ais523> elliott_: also, because they seem to have too much computational power
21:02:49 <ais523> I heard a rumour of QR code trojans a while back
21:02:50 <Vorpal> elliott_, they are gaining traction here in Sweden, slowly.
21:02:57 <ais523> but I have no idea what level of social engineering that required to work
21:03:06 <elliott_> Vorpal: they might be a growing fad, but that doesn't mean they're gaining long-term traction
21:03:19 <elliott_> ais523: they only encode a small bit of textual data to my knowledge, so that's surprising
21:03:24 <ais523> it might have been as simple as "QR code points at website containing malicious software download"
21:03:55 <ais523> probably was, actually, and the media went crazy about it as usual
21:04:11 <coppro> qr codes just encode data
21:04:28 <Vorpal> don't listen to mainstream media wrt viruses. They are bloody useless.
21:05:16 <elliott_> s/computers/anything/ (per Knoll's Law)
21:05:41 <ais523> Vorpal: well, this was tech media
21:05:45 <ais523> but they can be just as bad sometimes
21:05:51 <ais523> they just sound more like they know what they were doing
21:06:36 <elliott_> ais523: that's why you stick to respected institutions like The Register!
21:06:53 <ais523> elliott_: at least the Register is reasonably consistently biased
21:07:02 <ais523> (it has a strong pro-Paris-Hiltion bias)
21:07:37 -!- oerjan has quit (Quit: Good night).
21:07:43 <elliott_> Vorpal: do you know anything about x86 hardware virtualisation
21:08:25 <Vorpal> elliott_, not much though
21:08:52 <elliott_> Vorpal: well, I know it can be used to virtualise code running in ring 0
21:08:59 <elliott_> presumably it can be used to remap memory accesses by that code?
21:09:06 <elliott_> I know it can remap memory accesses by virtualised stuff in ring-3
21:09:33 <Vorpal> elliott_, no idea. Probably depends on if it is hardware stuff, in which case you need an IOMMU, which is not yet common on consumer (read: non-server) hardware
21:09:45 <elliott_> http://en.wikipedia.org/wiki/Extended_Page_Table
21:09:55 <elliott_> "A separate set of page tables (the EPT tables) translate from guest-physical addresses to the host-physical addresses that are used to access memory."
21:10:07 <Vorpal> elliott_, what about it?
21:10:11 <Vorpal> and why do you want it
21:10:13 <elliott_> well, it'll let me remap the memory
21:10:17 <elliott_> of ring-0 stuff being virtualised
21:10:26 <Vorpal> why are you virtualizing ring-0 stuff?
21:10:28 <elliott_> only Nehalem-onwards, but oh well
21:10:32 <elliott_> and looks like AMD implements the same thing
21:10:42 <Vorpal> elliott_, you want to use kvm. Because AMD and Intel use different models for it
21:11:16 <elliott_> it's an OS ide I've had that is both significantly easier to do than @, and demonstrates/tests some of its low-level performance benefits
21:11:32 <elliott_> basically, it's a POSIX-ish kernel that runs everything in ring 0 that virtualises every process
21:11:53 <Vorpal> my desktop can run that
21:12:03 <Vorpal> elliott_, I think virtualbox has it as a "nested page table" thingy
21:12:05 <elliott_> hmm, although, I'm not sure how expensive ring 0 stuff talking to the virtualisation code is
21:12:22 <Vorpal> elliott_, without that feature you just handle those page tables in you hypervisor software
21:12:24 <elliott_> if it's as expensive as a syscall, then my adventage is lost
21:12:39 <Vorpal> elliott_, might be more expensive
21:12:39 <elliott_> so if anyone knows the answer... let me know
21:12:55 <elliott_> Vorpal: well, not much more expensive, at least, or Xen would be really slow
21:13:03 <elliott_> Vorpal: ISTR that running Linux under Xen is actually faster than running it natively
21:13:24 <Vorpal> I really want to see a citation on that
21:13:51 <Vorpal> elliott_, anyway linux has special code to run better as a guest
21:13:52 <elliott_> Vorpal: anyway, even if virtualisation isn't possible the OS idea will still work... I'll just go back to my original idea of building the checks into the compiled code
21:14:21 <elliott_> because I think a branch on every memory access will pay itself off by the vastly reduced syscall overhead
21:16:11 <elliott_> ais523: OK, your new job (changed from discouraging me to write this) is to make sure I continue writing it after I get a bootloader
21:16:18 <elliott_> I really like writing bootloaders
21:17:37 <elliott_> one of the main problems with @ is that it's not at all clear where it actually starts running
21:18:36 <ais523> presumably you have some outside-@ bootloader that just sets up for bits of disk to be swapped into memory so they can start running again
21:20:52 <ais523> to where the IP was the last time stuff got flushed to disk
21:20:53 -!- sebbu2 has changed nick to sebbu.
21:20:55 <ais523> which should be very recent
21:21:15 <ais523> in fact, it's going to be in the disk-flushing routines, which makes life rather easier
21:21:19 <elliott_> ais523: there's more than one IP, and there's more machine state than just RAM + registers
21:21:40 <elliott_> ais523: anyway, that doesn't work, because you need to set up more than that
21:21:47 <ais523> elliott_: well, it jumps to stuff to restore that, then to where stuff was
21:21:56 <ais523> the problem may be difficult, but it's easy to describe
21:21:56 <elliott_> (the IP of the disk-flushing stuff won't be stored)
21:22:06 <elliott_> (because it's run from a timer, and doesn't block anything)
21:22:13 <elliott_> (well, it does blockt hings, but not /everything/)
21:22:18 <elliott_> (it just causes a switch to another thread, mostly)
21:22:39 <elliott_> ais523: right, but where is that stuff? :)
21:22:52 <ais523> for proper orthogonal persistence, it has to be persisted
21:23:28 <ais523> alternatively, you could decide that some of it can't meaningfully be persisted (network driver state, for instance), in which case it'd be the driver's job to initialise it
21:23:44 <ais523> basically, look at what Linux does on hibernate/unhibernate; it's basically that
21:23:57 <elliott_> I know that much, but Linux unhibernate is too specialised
21:24:03 <elliott_> because it assumes all the structures and the like are the same
21:24:09 <Vorpal> <elliott_> because I think a branch on every memory access will pay itself off by the vastly reduced syscall overhead <-- depends on how IO-bound the code is.
21:24:11 <elliott_> @ can't assume that, it needs to have a completely generic bootloader
21:24:19 <Vorpal> for IO you traditionally need lots of syscalls
21:24:36 <elliott_> Vorpal: even CPU-bound tasks that do, e.g. concurrency of any sort, have to do communication
21:24:49 <ais523> elliott_: it's not the bootloader's job to do most of the unhibernate
21:25:02 <elliott_> ais523: then whose job /is/ it, and how does the bootloader get to it?
21:25:22 <ais523> also, wrt the other conversation, concurrency primitives don't touch the kernel except when there's contention, nowadays
21:25:31 <Vorpal> elliott_, I'm considering the sort of heavy task I personally do a lot of. Which is stuff like optimising non-linear equations over thousands of data points for best fit.
21:25:37 <ais523> elliott_: it's the init scripts' job, IIRC
21:25:39 <elliott_> <ais523> also, wrt the other conversation, concurrency primitives don't touch the kernel except when there's contention, nowadays
21:25:44 <elliott_> ais523: yes, because syscalls are slow
21:25:45 <ais523> I can't remember if they're run by init directly during unhibernate, or some other way
21:25:49 <elliott_> and so removing syscall overhead sped things up
21:26:04 <ais523> but the point is, there isn't currently syscall overhead in that because it was removed a different way
21:26:16 <Vorpal> elliott_, avoiding checks on memory access by being smart in the compiler will certainly pay off for some tasks though
21:26:17 <elliott_> Vorpal: "tight loop of number crunching with a data set that fits into RAM and absolutely no concurrency whatsoever" is rare and becoming even rarer as multicore gets more and more ubiquitous
21:26:25 <ais523> so the issue is about how syscall-bound the program is
21:26:37 <elliott_> Vorpal: for a job like that, anyway, a /scheduler/ is a bottleneck
21:26:39 <ais523> Web of Lies gives you a really good idea of how syscall-bound a program is
21:26:46 <elliott_> and if you're not calling any syscalls, why not run it directly on bare hardware?
21:26:48 <ais523> as it has no timing effect on anything but syscalls
21:26:53 <elliott_> so OSes are already working against tasks like that
21:27:00 <elliott_> nobody will care if they work against them a bit more
21:27:13 <ais523> elliott_: I've actually been wondering how @'s scheduler works, or if it has one, and if it doesn't have one what it does instead
21:27:25 <Vorpal> <elliott_> and if you're not calling any syscalls, why not run it directly on bare hardware? <-- because it is less convenient when debugging :P
21:27:55 <Vorpal> and usually you do some syscalls even in those cases. Load initial data set, write out final result
21:28:15 <elliott_> so reducing sysccall overhead helps there
21:28:18 <Vorpal> so that is like 3 syscalls minimum, one read, one write, one exit
21:28:26 <elliott_> probably not as much as you lose, but it's likely that you do a bunch of read and writes
21:28:33 <elliott_> because a lot of datasets can't fit into RAM
21:28:40 <elliott_> at least, the datasets where you /really/ care about performance do
21:28:51 <elliott_> because a small change in constant factors has a large change on the end result due to the size of the data
21:28:56 <Vorpal> elliott_, the thing about those syscalls in this case is that they are one-time. They don't really vary that much between data sets of different sizes either. It is still a single read and a single write
21:29:02 <elliott_> ais523: that's something I've been thinking about a lot recently
21:29:10 <elliott_> ais523: it definitely does have a scheduler
21:29:21 <Vorpal> elliott_, if your data set can't fit into your ram things are going to be horribly slow anyway
21:29:23 -!- Patashu has joined.
21:29:39 <Vorpal> elliott_, even without considering IO overhead disks are way slower than ram
21:29:47 <pikhq_> Vorpal: Most data sets don't fit in RAM.
21:29:50 <elliott_> Vorpal: not really, if you can do it in chunks of 8 gigs or so at a time...
21:29:56 <pikhq_> At least, most data sets you give a shit about.
21:29:59 <elliott_> assuming there's not too much interdependency
21:30:19 <elliott_> ais523: and, problematically, it needs a /really good/ scheduler
21:30:36 <pikhq_> In a land where heavy computing jobs go through a terabyte drive in a day, everything is IO bound.
21:30:37 <ais523> elliott_: with the caps to do anything
21:30:39 <Vorpal> anyway my /personal/ use case here is mostly stuff that fits into ram. Like 5-6 GB of data.
21:30:41 <elliott_> ais523: and it needs to handle millions of tasks (= processes/threads) running
21:30:54 <elliott_> ais523: oh, it's not a problem for such low-level code to have all permissions
21:31:00 <elliott_> although it doesn't need quite that many
21:31:22 <ais523> elliott_: it needs to be able to stick the IP in the middle of arbitrary code
21:31:28 <elliott_> ais523: basically I need tasks to be as cheap as lightweight threads in GHC(/Erlang/whatever)
21:31:57 <ais523> there's no real problem with a million-task scheduler with current technology; the issue is more adapting for various patterns of blocked/nonblocked
21:31:59 <Vorpal> yeah erlang have really light weight processes
21:32:08 <Vorpal> iirc ~300 words per thread + stack
21:32:08 <elliott_> Vorpal: not as lightweight as GHC, to my knowledge
21:32:22 <ais523> for handling operations like sleep, etc, you aren't going to do better than n log n (possible with a heap-like priority queue)
21:32:28 <ais523> is that going to be good enough?
21:32:30 <Vorpal> elliott_, quite possible
21:32:32 <elliott_> ais523: well, the problem is more memory usage
21:32:48 <elliott_> ais523: I need some subdivision of the massive heap to do effective GC
21:32:52 <Vorpal> just throw in more RAM. that is where computers are heading anyway
21:32:57 <elliott_> ais523: I want to be able to do copying, incremental GC
21:33:04 <ais523> elliott_: is the scheduler doing that?
21:33:05 <elliott_> ais523: tasks seem a reasonable unit to do that at
21:33:07 <Vorpal> elliott_, can't you have per-process heap for stuff not likely to be sent between threads?
21:33:10 <elliott_> ais523: but the point is, how do you divide it?
21:33:16 <elliott_> there's no concept of "process"
21:33:19 <elliott_> Vorpal: there's no concept of "process"
21:33:20 <Vorpal> elliott_, per task then
21:33:31 <ais523> I assume there is a concept of "unlikely to be sent to a different task", but it'd be quite hard to determine
21:33:42 <Vorpal> elliott_, or per unit that can be stopped independently from other units for GC tasks
21:33:43 <elliott_> my memory management strategy involved 2 mebioctets + 4 kibioctets per pool
21:33:50 <ais523> I suppose you could just use the generational GC approach, treating all data as that until it's actually sent to another task
21:33:51 <elliott_> that's not viable for millions of threads
21:34:03 <elliott_> 2 megs * 1 million = 2 terabytes
21:34:12 <Vorpal> elliott_, do you need to split on whole pages?
21:34:13 <elliott_> (and this has to be in /RAM/, not on disk)
21:34:14 <ais523> elliott_: why not? just use a system where the address space is way bigger than the actual amount of memory
21:34:23 <ais523> although, x64 probably doesn't meet that requirement
21:34:27 <Vorpal> elliott_, afaik erlang does not use a whole page per process
21:34:32 <ais523> elliott_: oh, physical, ouch
21:34:39 <elliott_> Vorpal: well, that was my memory management trick, to make an allocation take 2 cycles
21:34:51 <elliott_> for allocations of less than 4 kilobytes
21:34:53 <Vorpal> elliott_, ... that might not be a good tradeoff
21:35:06 <elliott_> Vorpal: it's an excellent tradeoff, it just means I can't have a pool per task
21:35:18 <elliott_> which brings up the question, how /do/ I divide pools?
21:35:31 <elliott_> note: two CPUs cannot allocate from the same pool at once
21:35:43 <elliott_> so I can't just say "oh, divide it between 100 tasks"
21:35:56 <elliott_> because those tasks will have vastly reduced concurrency
21:36:25 <elliott_> Vorpal: a CPU isn't really anything; this has to be of the real heap, which is of ~a terabyte in size
21:36:31 <elliott_> because GC is done on the real heap
21:36:41 <Vorpal> elliott_, I don't see any reason why all the allocations of a single task have to come from the same pool
21:36:46 <Vorpal> if it is moved to a different CPU
21:36:49 <elliott_> that would tie tasks to CPUs permanently
21:37:04 <elliott_> Vorpal: it's nothing to do with cache lines, but that's not what I said
21:37:13 <elliott_> the reason two CPUs can't use a pool is because there's a really nasty race condition
21:37:20 <Vorpal> elliott_, you don't want to share a page between two CPUs unless it is actually shared data :P
21:37:22 <elliott_> that could only be solved with a lock or slower CAS shit
21:37:27 <elliott_> which defeats my 2 cycle allocation strategy
21:37:38 <Vorpal> elliott_, when allocating yes. But not when /using/ said pages
21:37:50 <Vorpal> if you allocated offset 40-57 in the page
21:37:55 <Vorpal> you can use that freely
21:37:56 <elliott_> a program can allocate from its pool at any time
21:38:01 <elliott_> and a program only uses one pool at a time
21:38:05 <elliott_> (it's expanded when necessary)
21:38:17 <Vorpal> elliott_, I suggest tying the pool to the cpu instead.
21:38:22 <ais523> elliott_: hmm, how common are allocations? and how common would they be if they were very cheap?
21:38:24 <elliott_> Vorpal: I just told you that doesn't work at all
21:38:32 <Vorpal> elliott_, I don't think your GC design is viable.
21:38:44 <Vorpal> not with millions of tasks
21:38:49 <elliott_> because you keep making references to "CPUs" and other things that don't exist
21:38:55 <ais523> also, hmm, how do you verify that a process doesn't access out-of-address-space when it's allocating memory dynamically
21:39:02 <elliott_> Vorpal: I never said I want a pool per task
21:39:04 <Vorpal> elliott_, what the fuck do you execute the damn code on then?
21:39:05 <elliott_> that's what I'm trying to avoid right now
21:39:23 <elliott_> Vorpal: you cannot make reference to CPU in the distribution of pools
21:39:32 <ais523> elliott_: CPU affinity is only meaningful wrt per-CPU cache, AFAICT
21:39:36 <pikhq_> elliott_: Then your memory model does not handle NUMA.
21:39:45 <ais523> and possibly, in the future, per-CPU RAM that isn't cache, but that's not standard yet
21:39:50 <Vorpal> and yes pikhq_ has a point
21:39:59 <ais523> however, I'm not convinced that per-CPU cache is unimportant here
21:39:59 <elliott_> Vorpal: I've decided explaining to you won't make you any less stupid, so I'm just going to answer ais523 instead
21:40:05 <elliott_> <ais523> elliott_: hmm, how common are allocations? and how common would they be if they were very cheap?
21:40:07 <pikhq_> Non-Uniform Memory Access.
21:40:11 <Vorpal> Phantom_Hoover, Non-uniform memory access
21:40:19 <elliott_> <ais523> also, hmm, how do you verify that a process doesn't access out-of-address-space when it's allocating memory dynamically
21:40:22 <Vorpal> at least with dual cpus (not cores)
21:40:44 <ais523> elliott_: say a process writes the equivalent of char* a = malloc(5); putc(a[7]);
21:40:54 <pikhq_> Wherein each CPU has its own memory (but can access that of others, though more slowly)
21:40:57 <ais523> hmm, that's not a huge problem, you could just insist on bounds checks everywhere
21:41:03 <ais523> and I think that'd be enough
21:41:11 <elliott_> ais523: it can't, and bounds checks aren't necessary
21:41:18 <Vorpal> pikhq_, I believe nehalem and after is that, rihght?
21:41:22 <ais523> elliott_: umm, I mean char[], not char*
21:41:24 <elliott_> ais523: the whole point of @ is that it doesn't run untrusted code
21:41:36 <pikhq_> Vorpal: For Intel, yeah.
21:41:38 <ais523> elliott_: I know; the question is, how do you determine whether such code is trustworthy
21:41:45 <elliott_> ais523: umm, the capability model? come on
21:41:48 <ais523> and the answer, AFAICT, involves bounds checks, either runtime or statically
21:41:52 <Vorpal> pikhq_, I believe amd have on-cpu MMUs too?
21:41:55 <elliott_> ais523: if you can prove to the @lang compiler that you never access out of bounds, bounds checks can be omitted
21:41:56 <Vorpal> pikhq_, since even longer
21:41:59 <elliott_> ais523: for instance, length-carrying vectors
21:42:02 <Vorpal> didn't k8 introduce that?
21:42:09 <ais523> that's what I meant by static bounds checks
21:42:09 <elliott_> there's no "checks" there, your program just doesn't type if it accesses things wrong
21:42:10 <pikhq_> Yeah, AMD's been doing NUMA a long freaking time.
21:42:15 <elliott_> ais523: I typed that before you said it
21:42:16 <ais523> I thought it was a problem, just realised it wasn't one
21:42:23 <Vorpal> pikhq_, and elliott_ has no clue about it...
21:42:42 <elliott_> Vorpal: stop being a fucking moron and assuming that because you don't understand how @'s GC works, I know nothing about NUMA
21:43:12 <Vorpal> elliott_, well pikhq_ had a point about you needing to use a local pool if possible or suffer bad speed.
21:44:00 <elliott_> that's irrelevant, since processes point to the abstract memory space.
21:44:13 <elliott_> if necessary, the pool can be loaded into the RAM of the CPU it's running on.
21:44:31 <Vorpal> elliott_, but you said there was no such thing as a CPU :P
21:44:50 <pikhq_> Vorpal: Insofar as virtual memory is concerned, there is no meaningful notion of "CPU".
21:44:56 <elliott_> Vorpal: because you kept trying to define pool allocation in terms of CPUs after I repeatedly told you that made no sense
21:45:01 <Vorpal> pikhq_, well obviously
21:45:02 <pikhq_> As the virtual memory space would be identical with 1 CPU or 1000.
21:45:03 <ais523> summary of elliott_'s arguments: CPUs are not a program-visible concept, in the cases where they're relevant that's handled by the memory allocator or pager
21:45:18 <elliott_> you can't tie pools to CPUs because
21:45:24 <elliott_> (a) that'd mean tasks would be permanently tied to one CPU
21:45:24 <Vorpal> elliott_, I'm suggesting that as a way to avoid having as many pools *and avoid the race conditions*
21:45:32 <elliott_> (b) what the hell do you do for tasks on disk?
21:45:33 <Vorpal> elliott_, it means a completely different GC model though
21:45:59 <elliott_> Vorpal: well thanks, that's a really unuseful suggestion and also not what you actually said?
21:46:10 <Vorpal> <elliott_> (a) that'd mean tasks would be permanently tied to one CPU <-- no, the pool of the current cpu would be transparently used when allocating.
21:46:17 <Vorpal> and you could access any pool
21:46:25 <Vorpal> for stuff you already allocated
21:46:33 <Vorpal> <elliott_> (b) what the hell do you do for tasks on disk? <-- hm?
21:46:34 <elliott_> my GC model works perfectly fine with a decent way to allocate tasks, which you have so far not offered a single idea for, so I'm going to assume that you just don't understand the model, since you haven't asked for it or demonstrated any knowledge of it
21:47:11 <Vorpal> <elliott_> Vorpal: well thanks, that's a really unuseful suggestion and also not what you actually said? <-- it was exactly what I said
21:47:20 <pikhq_> elliott_: I vote you have a certain number of pools (based on RAM or disk size?), and when a thread starts it gets assigned the least used pool.
21:47:28 <elliott_> "pool per cpu durrr" != "<Vorpal> elliott_, I'm suggesting that as a way to avoid having as many pools *and avoid the race conditions*"
21:47:48 <Vorpal> elliott_, then you misunderstood me
21:48:02 <ais523> hmm, what's the reason for having more than one pool? I know it's a good one, but it'd probably make this clearer to have it spelt out
21:48:06 <Vorpal> elliott_, pikhq_'s idea makes sense
21:48:12 <Vorpal> elliott_, but you are likely going to ignore it
21:48:16 <elliott_> ais523: you can't do copying GC on a terabyte if you don't have another terabyte
21:48:34 <elliott_> Vorpal: i'm working on a response to him because he's not an insufferable shithead; you, on the other hand, are going on /ignore
21:48:42 <elliott_> fun fact: I can't type infinitely fast
21:49:00 <pikhq_> ais523: Incremental GC.
21:49:09 <elliott_> pikhq_: that's not viable, since GC of a pool pauses every task using that pool, and two tasks on the same pool cannot ever be run at the same time (= on different SMP CPUs)
21:49:13 <ais523> elliott_: hmm, OK; what's stopping you having half the memory as one pool, and the other half as the place it gets copied to? other than the wastefulness?
21:49:20 <elliott_> ais523: and you can hardly pause the entire OS while you GC an entire terabyte, either
21:49:24 <elliott_> that'd take an awfully long time
21:49:42 <elliott_> ais523: well, that's wasteful, but even then, doing a single atomic copying-GC on a terabyte pool -- on disk! -- would be insanely slow
21:49:55 <ais523> so, hmm, are you planning to go on a stop-and-copy architecture specifically? or some other sort of copying GC?
21:50:14 <elliott_> ais523: well, it'll be generational (pools will contain multiple generations, I think)
21:50:30 <elliott_> (and past a certain generation, they'll be dissociated from a pool entirely)
21:50:42 <elliott_> (so that really long-lived objects just sort of hang around on disk and are basically never touched by the GC)
21:50:59 <pikhq_> elliott_: That sounds like the limits of having multiple tasks per pool.
21:51:14 <pikhq_> And you already agreed that one pool per task isn't viable, so.
21:51:19 <elliott_> ais523: stop-and-copy seems the most viable strategy
21:51:32 <elliott_> ais523: although, it would be nice if you could have a tight loop with allocation that was guaranteed to never pause for long at all
21:51:51 <elliott_> ais523: so you could write things that really have to be realtimeish, e.g. small-buffer video/audio code
21:51:59 <elliott_> without having to avoid allocations (nearly impossible in @lang)
21:52:06 <pikhq_> What you need is a scheme for assigning task to pool, and so I gave you a simple one and claimed it was impractical because, basically, it would involve multiple tasks in a pool.
21:52:42 <pikhq_> Though: if you want to limit the stoppage, there's no reason for the pool assignment for a task to be *permanent*.
21:52:51 <Vorpal> pikhq_, I gave him another scheme for the same thing and he claimed it was impractical too. This discussion is being pretty pointless
21:52:52 <elliott_> pikhq_: well, you need to assign them with some intelligence
21:53:12 <elliott_> pikhq_: e.g., a cluster of 10 threads that "work together" in some sense to serve some larger task that started them, are probably OK to put on the same pool
21:53:22 <pikhq_> That's a fairly 'mundane' scheduling problem.
21:53:31 <elliott_> because they're "related", and so it doesn't matter if they don't run at the same time SMPly
21:53:41 <pikhq_> You get similar issues with trying to stick related tasks in the same NUMA group.
21:54:02 <pikhq_> It's not exactly an *easy* problem, but it's at least a rather well-understood one, and not at all @-specific.
21:54:31 <elliott_> pikhq_: I wonder how fast I could get a concurrent allocator
21:54:47 <elliott_> I basically need an atomic form of {*y += n; x = *y;}
21:54:58 <elliott_> where x is a register and y is a memory location
21:56:35 <pikhq_> (x86's primary atomic instruction)
21:56:36 <Vorpal> pikhq_, that might need retrying if it fails
21:56:46 <Vorpal> isn't there an atomic increment?
21:56:52 <Vorpal> Not sure if it returns the old value
21:56:55 <elliott_> pikhq_: I have a feeling it's not going to be quite as fast as MOV + ADD
21:57:31 <pikhq_> elliott_: It is if there's no contention.
21:57:58 <elliott_> hmm, I'm not sure how cmpxchg would work, because you need to do an increment, not just a swap with some predetermined value
21:58:02 <elliott_> so it'll need some lock layering on top
21:58:48 <Vorpal> pikhq_, I presume elliott_ is actually ignoring me. But lock xadd might do the job
21:59:26 <Vorpal> unless I misunderstood the docs
21:59:35 <elliott_> which definitely won't be as fast
21:59:44 <pikhq_> elliott_: What you do is blithly fetch the value, increment it, and attempt the cmpxchg. If it fails, you restart.
21:59:45 <Vorpal> elliott_, oh lock xadd will be
21:59:56 <pikhq_> The thing is, you pass cmpxchg what the old value should be.
22:00:03 <elliott_> how cheap is cmpxchg with no contention?
22:00:11 <Vorpal> pikhq_, I'm /pretty/ sure lock xadd will do this even cheaper.
22:00:20 <elliott_> presumably, you branch to determine whether the cmpxchg worked or not?
22:00:21 <Vorpal> pikhq_, you might want to inform elliott_
22:00:29 <elliott_> the whole idea with my 2-cycle allocator is to avoid branches
22:00:57 <pikhq_> Having a single branch that'll be predicted correctly almost always is not going to be notably worse. :)
22:01:09 <Vorpal> oh looks like pikhq_ is ignoring as well
22:01:13 <elliott_> pikhq_: it is when it's something as common as this :P
22:01:24 <elliott_> pikhq_: and I'm not so sure it'll always be predicted correctly
22:01:38 <Vorpal> ^say elliott I know the solution to this. There is a better atomic instruction. I told you above.
22:01:50 <fungot> ^<lang> <code>; ^def <command> <lang> <code>; ^show [command]; lang=bf/ul, code=text/str:N; ^str 0-9 get/set/add [text]; ^style [style]; ^bool
22:01:50 <elliott_> allocation is really common, and probably follows very predictable patterns in @lang's generated code, so I would not be surprised if the contention rate was high for a pool
22:01:52 <pikhq_> Vorpal: Is xadd atomic?
22:01:59 <Vorpal> pikhq_, with the lock prefix
22:02:20 <Vorpal> pikhq_, but you need that for anything to be atomic
22:02:34 <pikhq_> Hmm, sure enough, that works better.
22:02:53 <elliott_> hmm, xadd? this looks like the right thing
22:02:53 <Vorpal> pikhq_, don't tell elliott_ since he doesn't want to know what I have to say :P
22:03:21 <elliott_> the question is how much slower LOCK XADD is compared to ADD + MOV in a uniprocessor situation
22:03:34 <elliott_> probably not noticeably, but it'd be interesting to know exactly
22:03:53 <Vorpal> you can trivially specialise the code on the fly
22:03:55 <pikhq_> In a uniprocessor situation, it's "ADD + MOV + MOV".
22:04:03 <Vorpal> and uniprocessors are kind of outdated anyway
22:04:36 <Vorpal> pikhq_, isn't it xchg,add even?
22:04:39 <elliott_> pikhq_: hmm, I don't think xadd can do memory
22:04:42 <elliott_> 0F C1/r XADD r/m32, r32 Exchange r32 and r/m32; load sum into r/m32.
22:04:55 <pikhq_> If it couldn't it would be worthless.
22:05:15 <pikhq_> "It's atomic because it accesses a per-thread resource!"
22:05:17 <elliott_> the fact that xadd has sparse google results is worrying, though
22:05:27 <elliott_> is it one of those CISCy instructions that nobody generates any more and so has really badly optimised microcode? :p
22:05:48 <pikhq_> No, it's one of the basic atomic primitives.
22:06:14 <elliott_> http://www.xadd.net/ Why did someone buy a domain for this
22:06:16 <Vorpal> what do you do when a pool is full anyway
22:06:51 <Vorpal> pikhq_, yeah but you need to reset the counter to be able to use this simple allocation stratergy
22:06:59 <elliott_> Vorpal: accesses to it will go into the 4k barrier page space and thus cause a page fault
22:07:05 <Vorpal> pikhq_, this simple scheme can't handle skipping holes after all
22:07:19 <pikhq_> Vorpal: Moving GCs are not magic.
22:07:27 <elliott_> everyone uses a pointer-bumping allocator these days
22:07:42 <pikhq_> Yeah, basically everyone but Boehm.
22:07:46 <elliott_> Vorpal: yes, which is why you allocate a new pool and compact as you move it there
22:07:51 <pikhq_> And Boehm only doesn't because it needs to work with C.
22:07:53 <Vorpal> I thought the glibc allocator for example was extent based
22:07:56 <ais523> <elliott_> http://www.xadd.net/ Why did someone buy a domain for this <-- I thought you were in favour of foldl.whatever?
22:08:00 <elliott_> Vorpal: glibc: "a garbage collector"
22:08:01 <pikhq_> Vorpal: That's *not* a GC.
22:08:06 <Vorpal> elliott_, well true, not the case
22:08:09 <elliott_> ais523: those were cute, this is just silly
22:08:27 <ais523> also, TLDs are getting increasingly obnoxious to remember
22:08:34 <ais523> if they were used for their original purposes, there wouldn't be a problem
22:08:41 <ais523> but there isn't really a TLD for "novelty website"
22:08:56 <elliott_> ais523: hey, I have a .net that's actually an internet service provider!
22:08:57 <pikhq_> The TLD system is just very poorly suited to the modern 'net.
22:09:17 <ais523> arguably something like Freenode can plausibly correctly be .net too
22:09:26 <Vorpal> pikhq_, the ccTLDs kind of work still. Except for US.
22:09:34 <elliott_> ais523: admittedly, the service we provide is mainly a minecraft server
22:09:40 <elliott_> but that's an internet service that we're providing
22:09:48 <elliott_> and web hosts are considered ISPs, so I don't see why that shouldn't be
22:10:13 <pikhq_> Vorpal: In a sense. They provide a service on the Internet.
22:10:13 <elliott_> http://en.wikipedia.org/wiki/Internet_service_provider
22:10:19 <elliott_> the technical meaning differs from the colloquial meaning
22:10:24 <elliott_> (which only means "an actual internet link provider")
22:10:29 <Vorpal> pikhq_, well, that is not what people /usually/ mean by ISP
22:10:36 <elliott_> bah, that page has the wrong definition
22:10:36 <pikhq_> Or "a provider of Internet service".
22:10:46 <elliott_> but .net was originally meant for the technical meaning
22:11:16 <Vorpal> <elliott_> but .net was originally meant for the technical meaning <-- that would include pretty much everything then
22:11:17 <ais523> elliott_: I think nowadays, I conclude that "internet service provider" and "ISP" actually have somewhat different meanings
22:11:40 <elliott_> Vorpal: not really; a corporation not in the business of selling internet services wouldn't
22:11:56 <elliott_> a web server isn't really "providing" anything
22:12:31 <Vorpal> hm x68/x87 really doesn't have that many general purpose instructions. It just have a lot of variants of each one. It *does* have a lot of floating point and SIMD instructions though.
22:12:56 <ais523> elliott_: well, m68k is an arch
22:13:31 <Vorpal> it is still CISC obviously due to that nearly everything can do memory accesses.
22:13:41 <elliott_> pikhq_: I don't suppose there's a LOCK XADD AND ALSO JUMP HERE IF IT EXCEEDS A CERTAIN VALUE :)
22:13:49 <elliott_> or, to phrase that another way:
22:13:52 <elliott_> how do I do atomic allocations of >4k?
22:14:14 <elliott_> pikhq_: ouch, there's a nasty race condition even with atomic <4k allocations
22:14:29 <elliott_> what if you have exactly 1 byte left in the pool, and two processes do 4k allocations at once?
22:14:34 <elliott_> one of them gets an address /beyond/ the barrier page
22:14:38 <Vorpal> elliott_, I doubt there is. Possibly you could optimise if you know the allocation is larger/smaller than the size and do a slow path when you don't know.
22:14:41 <elliott_> that might even be in some other task's valid memory
22:14:55 -!- Slereah has quit (Ping timeout: 244 seconds).
22:15:14 <elliott_> if you restrict pools to non-concurrent access you can solve that easily, by checking the pool pointer for overflow on context switch
22:15:24 <elliott_> that's actually a general flaw
22:15:31 <elliott_> if you allocate twice without actually accessing the RAM
22:15:33 -!- Slereah_ has joined.
22:15:40 <elliott_> I suppose the solution is to just ban allocating before you access a previous allocation
22:16:08 * ais523 works out how to mark a question where one of the requirements is "efficiently"
22:16:10 <Vorpal> elliott_, you could allocate numtask*largest barrier memory?
22:16:25 <ais523> luckily, this is easier than the mergesort issue, because I can populate the caches with invalid data and then see if the algo blindly trusts it
22:16:32 <ais523> if it doesn't, it's not efficient
22:16:41 <Vorpal> ais523, if applicable look for complexity?
22:16:57 <ais523> Vorpal: I thought of that first, and it is possibly applicable
22:17:25 <ais523> the average-case performance is probably the same, but I could make the worst-case performance for the most obvious unwanted method blow up
22:17:30 <ais523> but that's probably harder to write
22:17:45 <ais523> (the same in terms of complexity, that is, not in overall performance)
22:17:49 <Vorpal> elliott_, well if you can allocate at most n bytes if you have n*tasks_in_pool barrier memory it would be safe
22:17:59 <Vorpal> assuming you access all before next allocation
22:18:08 <elliott_> Vorpal: no, you would have to allocate n*tasks
22:18:34 <elliott_> {2M pool page}, {4k barrier page}, {2M pool page of another task entirely}
22:18:40 <elliott_> if you're 1 byte from the end of the first pool page
22:18:46 <elliott_> you're in someone else's memory
22:18:51 <elliott_> and it won't page fault when you access it
22:19:18 -!- kmc has joined.
22:19:18 <Vorpal> elliott_, is that 2M huge page?
22:19:33 <Vorpal> elliott_, x86 can do unaligned ones?
22:19:49 <Vorpal> I would expect them to have to be aligned on 2 MB boundaries
22:20:04 <elliott_> even if I used a 2M barrier page
22:20:07 <Vorpal> which means your scheme would kind of not work very well, though beautiful
22:20:12 <elliott_> you just need to increase the number of allocations
22:20:18 <elliott_> to show that it's still a problem
22:20:25 <elliott_> 2 megs is about as big as 4 megs
22:20:34 <elliott_> I only need to wait a few years for everybody's memory to double
22:21:24 <Vorpal> elliott_, I don't think I will be getting 32 GB in a hurry :P
22:22:14 <elliott_> actually, one problem with this allocator style is that you have to calloc pools
22:23:03 <ais523> elliott_: you definitely don't want processes reading privileged data from leftover pools, so you have to statically ensure it's not used before alloc, or else zero it on the alloc
22:23:16 <Vorpal> elliott_, hm why would the code be allowed to read uninitialised memory? After all isn't the system generating the machine code from @lang?
22:23:25 <Vorpal> which could ensure that didn't happen
22:23:33 <elliott_> ais523: @lang programs aren't allowed to just arbitrarily read from their pool, ofc
22:23:38 <ais523> elliott_: right, indeed
22:23:42 <Vorpal> elliott_, then it shouldn't be a problem
22:23:46 <ais523> they're only allowed to interpret it in ways they're allowed to
22:23:46 <elliott_> ais523: a Haskell compiler won't spit out code looking like that, so an @lang compiler won't either
22:23:59 <elliott_> the GC has to look at the bytes in the heap to determine object structure
22:24:11 <elliott_> how does it know it's looking at a real, fully-allocated object, instead of just the garbage at the end?
22:24:14 <ais523> elliott_: bleh, no typed GC?
22:24:21 <elliott_> ais523: of course it's "typed"...
22:24:25 <elliott_> because the GC is only called on overflow
22:24:30 <Vorpal> elliott_, typed allocations.
22:24:31 <elliott_> so you /know/ the last object wasn't fully allocated
22:24:42 <elliott_> Vorpal: yes, of course; how do you think that solves the problem?
22:25:35 <Vorpal> well the GC could see how far we allocated. And we might write a bit in a header of the allocation to indicate that we have allocated it but not yet used it
22:25:45 <Vorpal> hm, probably rather awkward way of doing it
22:26:27 <elliott_> Vorpal: what happens when another CPU overflows the pool after incrementing pointer
22:26:42 <elliott_> before _this_ cpu sets the bit
22:26:47 <elliott_> these are all problems caused by concurrent pool access
22:26:58 <elliott_> why don't CPUs have transactional memory ffs
22:27:11 <Vorpal> elliott_, iirc powerpc does
22:27:28 <Vorpal> oh wait, it was load-store barriers
22:27:41 <Vorpal> still, they are considerably more powerful iirc
22:28:26 <elliott_> i'm tempted to just forbid concurrent access again and think of another way to do things
22:28:58 <Vorpal> elliott_, concurrent access has another problem anyway
22:29:06 <elliott_> maybe I could use small pools by default without the fancy barrier stuff and expand that on first gc
22:29:15 <Vorpal> and that is that of cache line ownership moving between CPUs
22:29:35 <elliott_> Vorpal: well. that will happen anyway
22:29:36 <Vorpal> cache lines are iirc about 64 bytes or such
22:29:51 <elliott_> Vorpal: since another task on the same pool will run on another CPU while other tasks on the same pool are stopped
22:30:06 <elliott_> I suppose I could tie pools to CPUs but that sounds like a pain on e.g. 4-core systems
22:30:11 <elliott_> where you just don't have many CPUs
22:30:22 <elliott_> (where by "CPU" i mean "core")
22:30:25 <Vorpal> elliott_, yes but you don't want that to happen for no good reason. Sure it will happen when rescheduling. And when sharing a lock for something (and you will need locks for some stuff I bet, hardware access at the very least)
22:30:39 <Vorpal> (like a lock for "accessing ethernet card memory mapped registers")
22:30:42 <elliott_> <elliott_> Vorpal: what happens when another CPU overflows the pool after incrementing pointer
22:30:42 <elliott_> <elliott_> but before setting the bit
22:30:42 <elliott_> <elliott_> before _this_ cpu sets the bit
22:30:44 <elliott_> i thought of a solution to this
22:31:00 <elliott_> i could make the GC wait until every process on the pool allocates again
22:31:04 <elliott_> and thus causes another pagefault
22:31:12 <elliott_> which would ensure that no partial allocations have been done
22:32:12 <Vorpal> elliott_, actually no you can't. Segfault is a *nix term. The x86 term is general protection fault or page fault depending on what exactly you are doing
22:32:46 <Vorpal> I did a double take on seeing "segfault"
22:33:31 <Vorpal> elliott_, anyway wouldn't that go into the next page anyway?
22:33:37 <elliott_> hmm, even if i don't use this fancy barrier page strategy
22:33:51 <elliott_> I don't see any way to avoid allocating one page per task if I'm going the "really lightweight, no concurrent access model"
22:33:55 <Vorpal> elliott_, do you plan to have much of a stack btw?
22:34:10 <Vorpal> because allocation on a task local stack would be /way/ cheaper.
22:34:51 <Vorpal> of course that means at least two pages anyway... with the barrier page
22:36:38 -!- ais523 has quit (Remote host closed the connection).
22:37:05 <elliott_> stack allocation is pointer-bumping
22:38:27 <elliott_> pikhq_: hmm, xadd (/without/ lock) will probably be slower than mov + add, right? thinking about a non-concurrent access scenario
22:41:44 <elliott_> Vorpal: stacks are basically thought to be faster because people use simpler allocators with them
22:43:06 -!- Jafet has quit (Quit: Leaving.).
22:43:42 <Vorpal> <elliott_> stack allocation is pointer-bumping <-- yes
22:43:50 <Vorpal> elliott_, but you still need to detect stack overflow
22:44:06 <elliott_> yes. so it is more expensive than my allocator
22:44:30 <elliott_> so i don't see how a stack would help
22:44:32 <Vorpal> elliott_, what is your GC root btw?
22:45:50 <Vorpal> stack allocators have one advantage: no need to GC. Because returning just bumps the pointer the other way
22:46:01 <pikhq_> elliott_: xadd without lock is not much more than mov+add.
22:46:08 <elliott_> pikhq_: right. but it is more :)
22:46:22 <elliott_> Vorpal: they also require a traditional notion of stack
22:47:29 <Vorpal> I have to say that the rep prefix of x86 is quite curious
22:48:34 <elliott_> useful for boot sector golfing
22:49:05 <Vorpal> it is truly a CISC left over
22:50:57 -!- derrik has quit (Quit: nights).
22:53:39 <Vorpal> "Any VEX-encoded instruction with a LOCK prefix preceding VEX will #UD." <-- it doesn't say anything else under "VEX and the LOCK prefix". Like it would be useful to say if it works in the other order.
22:54:08 <Vorpal> because VEX isn't a prefix anyway
22:54:14 <Vorpal> so why no LOCK on VEX?
23:03:51 <elliott_> hmm, looks like my tasks have to take up at least 144 bytes
23:04:17 <elliott_> that's just the number of registers on x86-64, including IP
23:04:28 <elliott_> ofc if i don't use all registers for computation then they can take less...
23:04:41 <elliott_> or if certain registers are always used as like scratch space before being put into memory
23:04:52 <Vorpal> elliott_, "A newly spawned Erlang process uses 309 words of memory in the non-SMP emulator without HiPE support. (SMP support and HiPE support will both add to this size.)"
23:04:59 <Vorpal> so far you beat erlang
23:05:10 <elliott_> hmm, why do they need that much?
23:05:35 <Vorpal> elliott_, it may include the default stack
23:05:41 <elliott_> gah, i just thought of a response to something ais said, but he's left
23:06:09 <elliott_> that doesn't have immediate payoff :) but fine!
23:06:18 <Vorpal> elliott_, "The size includes 233 words for the heap area (which includes the stack). The garbage collector will increase the heap as needed."
23:06:22 <Vorpal> elliott_, that is why it is so large
23:06:33 <elliott_> @tell ais523 <ais523> there's no real problem with a million-task scheduler with current technology; the issue is more adapting for various patterns of blocked/nonblocked
23:07:08 <elliott_> @tell ais523 in @, there's no such thing as a "blocked task"; a blocked task's data (not necessarily including its pool data, just the pointer) is moved into whatever's being /blocked on/
23:07:16 <elliott_> @tell ais523 and then removed from the scheduler's list of tasks
23:07:18 <Vorpal> elliott_, anyway so the real overhead is 76 words
23:07:35 <elliott_> @tell ais523 that is, sockets know which threads are blocked on them, and resume those threads when they receive data or whatever
23:07:37 <Vorpal> elliott_, which is far smaller
23:08:03 <Vorpal> elliott_, 304 on 32-bit
23:08:36 <Vorpal> 32-bit systems still exist
23:09:08 <Vorpal> elliott_, but globally most processors are likely 16-bit or 8-bit still
23:09:14 <elliott_> yeah, but they don't run erlang
23:09:25 <elliott_> also, i think 32-bit is the most common nowadays actually, because of ARM in the embedded space
23:09:34 <Vorpal> elliott_, still erlang can run on vxworks. Which opens up a whole embedded market
23:09:37 <elliott_> full CPUs in embedded stuff is becomming more common
23:09:49 <elliott_> unfortunately I don't think @ will work very well on 32-bit
23:10:14 <elliott_> what kind of disks do vxworks devices have :P
23:10:16 <Vorpal> elliott_, 64-bit in embedded is rare. it is mostly consoles and PCs that are 64-bit
23:11:03 <Vorpal> elliott_, hm... the ones I used at university had either flash with some weird connector or plain CF cards.
23:11:23 <Vorpal> elliott_, well I have a CF card somewhere. Let me find a ruler ;)
23:11:32 <Vorpal> elliott_, anyway it was a dev system. Kind of high end.
23:11:43 <Vorpal> like x86, pentium, 500 MHz
23:11:50 <Vorpal> or something absurdly overpowered like that
23:11:57 <Vorpal> 1 or 2 GB flash probably
23:12:08 <elliott_> basically, a 32-bit @ system can address 4 gigabytes, total, including disk
23:12:10 <Vorpal> elliott_, but it varies depending on applications :P
23:12:25 <elliott_> so it works fine in like most embedded scenarios i guess
23:12:42 <elliott_> i can think of workarounds, but they're all sloooooooow
23:12:52 <Vorpal> anyway there is large file system support on other systems. Obviously not on @
23:13:07 <Vorpal> elliott_, wait, x86-64 systems actually have 48 bits virtual address space right?
23:13:10 <elliott_> Vorpal: well it doesn't really work because of the uniform address space
23:13:23 <elliott_> basically you'd need to store all pointers as large filesystem addresses
23:13:30 <elliott_> dereferencing those would be slow as shit
23:13:30 <pikhq_> That's a limit of the MMU, not the ISA.
23:14:24 <Vorpal> elliott_, that is kind of close to modern storage size.
23:15:00 <elliott_> Vorpal: when single machines start addressing 35 terabytes, AMD and Intel will start releasing CPUs with MMUs that can address 64 bits.
23:15:06 <pikhq_> elliott_: Better/worse: you could use segmentation.
23:15:21 <Vorpal> elliott_, I have like slightly more than 1/17th of that in disks in my computer
23:15:29 <elliott_> pikhq_: I don't see how that would work; pointers would have to store the segment they're in
23:15:35 <elliott_> Vorpal: moore's law doesn't work _that_ fast.
23:15:36 <Vorpal> elliott_, I meant for disks, Not for ram
23:15:48 <Vorpal> elliott_, since you do uniform address space
23:15:53 <Vorpal> the disk size matters for you
23:16:21 <Vorpal> elliott_, I was just finishing my line of thought before reading further. I use blocking IO
23:16:26 <elliott_> Vorpal: I'm pretty sure that the MMU bit width will increase when we're living in the space age and people have 35 terabytes of disk.
23:16:36 <pikhq_> elliott_: Segments map to physical space. Recent x86 has 36-bit address space. :P
23:16:38 <elliott_> Even if it doesn't, 35 terabytes is a lot of storage.
23:16:54 <elliott_> I doubt you, as a person, will need >35 terabytes of personal storage before @ takes over the world.
23:17:24 <pikhq_> elliott_: Also, alternately you *could* make it so that far pointer dereferencing is the expensive operation.
23:17:31 <pikhq_> Which nets you a potentially 46-bit address space.
23:17:40 <pikhq_> This would be an *insane* hack, though.
23:18:07 <Vorpal> elliott_, 35 TB is ~1501 blueray disc
23:18:25 <elliott_> Vorpal: I will consider your concerns if you personally buy 1501 blu-ray discs.
23:18:49 <Vorpal> elliott_, I wonder how much traffic I download in a year
23:18:51 <pikhq_> Vorpal: If you use sane encodings, chop a order of magnitude off that.
23:18:55 <pikhq_> (x264 is awesome shit)
23:18:56 <Vorpal> err how much traffic downstream I mean
23:19:09 <Vorpal> pikhq_, who said movies
23:19:18 * elliott_ attempts to find a blank blu-ray on Amazon.
23:19:20 <Vorpal> pikhq_, games on blueray happens nowdays
23:19:31 <Vorpal> pikhq_, I downloaded a 25 GB game at one point
23:19:33 <pikhq_> Vorpal: Technically, yes. They're generally empty.
23:19:44 <Vorpal> pikhq_, nope. Rage was 25 GB download
23:19:50 <pikhq_> Due to targetting DVD platforms as well, and nobody likes multiple disks.
23:20:09 <pikhq_> Jesus, what did they include, the genomes of all sequenced species?
23:20:18 <Vorpal> pikhq_, really bad texture quality
23:20:22 <Vorpal> pikhq_, the install size was 27 GB iirc
23:20:49 <Vorpal> pikhq_, iirc they said the raw data of the game they had on their development servers was over 1 TB
23:21:15 <Vorpal> pikhq_, and Rage is a really bad game. Boring, uninspired story, mediocre gameplay
23:21:22 <Vorpal> and quite uneven texture quality
23:21:32 <Vorpal> everything from state of the art to something utterly jagged.
23:21:43 -!- kmc has quit (Quit: Leaving).
23:22:19 <pikhq_> "Higher res is better. Derp, scale!"?
23:22:39 <Vorpal> pikhq_, it feels like a tech demo for the engine to tell the truth :P
23:23:26 <Vorpal> pikhq_, the skydome was truly impressive though
23:24:58 <Vorpal> pikhq_, anyway there are many games that come on dual layer DVDs these days
23:25:19 <Vorpal> iirc witcher 2 was about 7 GB large download. Somewhat more when installed on disk
23:25:35 <Vorpal> and that game has high texture quality and good gameplay and everything :P
23:26:02 <Vorpal> hm system requirements is 16 GB free disk
23:27:17 <Vorpal> pikhq_, speaking of which... that is a rare game these days. Witcher 2 is completely DRM free.
23:27:39 <Vorpal> (except when bought from steam iirc)
23:30:07 <Vorpal> elliott_, where have you been?
23:30:42 <Vorpal> elliott_, steam has DRM that is fairly easy to work around by replacing a few dll files
23:31:00 <Vorpal> replacement ones are kind of well developed already
23:31:05 <Vorpal> elliott_, pretty much.
23:31:46 <Vorpal> not all steam games use the drm of course
23:32:10 <Vorpal> generally you know when a game refuses to run without steam running, then it uses the drm
23:32:13 <Vorpal> elliott_, like skyrim does
23:32:22 <Vorpal> (note: easy to work around :P)
23:32:51 <Vorpal> elliott_, yes we are talking about steam indeed :P
23:33:07 <elliott_> Why do people like Steam again?
23:33:49 <Vorpal> elliott_, because it was first and it is convenient. And there are far worse DRM examples.
23:34:13 <elliott_> Vorpal: But I've actually seen people rejoice when games they already own became available on Steam.
23:34:18 <Vorpal> elliott_, and because it has all the games (pretty much). Which it does because it is popular with the users.
23:34:35 <Vorpal> elliott_, is it for the steam achievements?
23:34:47 <elliott_> Vorpal: The only reasons I've heard are because of the "social" features of it and the achievements and crap. Which I find completely incomprehensible.
23:35:08 <elliott_> I mean, I'd prefer to just ask people if they want a game rather than cyberstalking them for the purpose.
23:35:11 <Vorpal> elliott_, oh yeah you can use it for easy invites to friends for multiplayer games iirc.
23:35:16 <elliott_> And achievements are a scourge.
23:35:31 <elliott_> Achievements are what happen when you can't think of a decent in-game way to reward players for doing things.
23:35:37 <elliott_> So you decide to annoy them instead
23:35:48 <Vorpal> elliott_, it is easier to click a friend's name in a list than to ask them to provide a port number and so on
23:36:23 * elliott_ is used to playing multiplayer games with decent lobby systems.
23:36:33 <elliott_> Admittedly skipping the lobby entirely would be preferable.
23:36:35 <Vorpal> <elliott_> Achievements are what happen when you can't think of a decent in-game way to reward players for doing things. <-- I like stuff that are kind of like achievements but are for the current game only and have an in game effect
23:37:24 <Vorpal> elliott_, like, in witcher 2, if you stay within a protective spell bubble during a part of the introduction of chapter 1 you get a +5 or something bonus to something
23:37:57 <Vorpal> or following a certain path doing a certain mission within certain parameters grants you 100 extra carrying capacity
23:38:41 <Vorpal> elliott_, anyway you might want to reward a player who went through the entire game without killing any enemy, using sneaking and such instead.
23:38:46 <Vorpal> how would you do that?
23:38:53 <Vorpal> achievement is the usual answer
23:38:57 <elliott_> Well, badges at the end are OK
23:39:06 <elliott_> Achievements that happen mid-game not so much
23:39:13 <elliott_> If it's just for things like easter eggs sure
23:39:17 <elliott_> But if it's like "100 kills" fuck that
23:40:04 <Vorpal> elliott_, what about stuff like "navigated down a steep hill without taking fall damage". Yogscast suggested that should be an achievement in skyrim (it isn't, it has the boring type of achievements, mostly "did questline x")
23:40:25 <Vorpal> of course it would be hard to measure that
23:40:36 -!- pumpkin has joined.
23:40:57 <Vorpal> elliott_, but yes, I seen pretty bad achievements. And I seen less bad ones.
23:41:03 <elliott_> The achievement comes from managing that in the first place :P
23:41:16 <elliott_> If it's obvious that you've done something hard, you don't need to yell at players that they've done it
23:41:22 <Vorpal> elliott_, but you want something you can brag about on your steam profile!
23:42:25 <elliott_> pikhq_: Do you know much about hardware virtualisation
23:43:02 <Vorpal> elliott_, anyway I remember reading about some game where the devs put in achievements for stuff they thought were so improbable that they were for all practical purposes impossible. Just to see how long it took for players to figure out a way to do them.
23:43:09 -!- Jafet has joined.
23:43:19 <Vorpal> all were done within a year iirc
23:43:23 <Vorpal> forgot which game it was
23:43:37 -!- copumpkin has quit (Ping timeout: 248 seconds).
23:44:39 <Vorpal> elliott_, anyway gamersgate is a better online store than steam really. No silly client crap.
23:46:09 <Vorpal> elliott_, another one I heard was good but which I never used myself is desura. Mostly focused on indie stuff iirc
23:46:21 <Vorpal> elliott_, so there are alternatives to steam that are less shitty
23:46:50 <Vorpal> elliott_, yes, but a less obnoxious one
23:47:06 <elliott_> What ever happened to just delivering binaries.
23:47:35 <Vorpal> elliott_, that is gamersgate. They let you download a downloader program basically. And then that downloads the binary.
23:47:51 <Vorpal> I guess a downloader makes sense on windows because I doubt IE can resume a broken download
23:48:02 <elliott_> But Firefox sucks at resuming downloads
23:48:14 <Vorpal> elliott_, so that is why they use a downloader
23:48:18 <Vorpal> I use wget for such stuff
23:49:55 -!- Phantom_Hoover has quit (Quit: Leaving).
23:50:04 <Vorpal> heh gamersgate is a Swedish company? Didn't know that
23:50:25 -!- nooga has quit (Ping timeout: 244 seconds).
23:51:39 <elliott_> Why does scan.co.uk have to be so unusable.
23:53:56 <elliott_> pikhq_: So you wouldn't know how expensive something in ring 0 calling on the hypervisor would be?