00:00:07 <Razor-X> Uggh. You reminded me of an awful SAT article.
00:00:16 <RodgerTheGreat> one could say that it's rejection of traditional artistic concepts is indeed annoying
00:00:35 <RodgerTheGreat> the SAT was easy. I enjoyed it the most the second time I took it.
00:00:56 <RodgerTheGreat> I was really quite disappointed with some of the revisions, however.
00:05:10 <RodgerTheGreat> that's with the latest revision. The national average is approximately 1028
00:07:34 <RodgerTheGreat> (this is for the multiple-choice versions of the test)
00:46:53 -!- Anders has changed nick to anders.
00:53:18 -!- ihope has joined.
00:56:09 <ihope> (As opposed to "gasp", a very different word.)
00:56:30 <oerjan> hasp: a new esoteric language horrendously mixing haskell and lisp
00:57:01 <ihope> http://en.wiktionary.org/wiki/hasp
00:59:45 <oerjan> but if two stacks can emulate a tape, isn't this then essensially a three-stack language?
01:01:28 <oerjan> now if we used four stacks and let <>^V all act analogously...
01:05:05 <oerjan> not without some heavy copying, i assume
01:05:53 <oerjan> actually, if you have one reserved symbol you could do it with merely a lot of movement
01:06:28 <oerjan> by putting the tops of the stacks at either _end_ of the tape
01:06:45 <oerjan> and letting the bottoms meet in the middle
01:07:05 <oerjan> assuming the tape is infinite in both directions.
01:07:51 <oerjan> otherwise you could still do it by keeping one stack on the odd addresses and the other on the even ones.
01:08:08 <oerjan> sometimes they are endless just in one direction.
01:08:46 <oerjan> but of course all of these _can_ emulate the others, being enough for turing-completeness
01:09:29 <oerjan> no, you just put the reserved symbol on the top positions, and search for them. i am not saying there would be constant-time access.
01:11:09 <oerjan> if you don't then you can code one character set as strings in another.
01:12:57 <oerjan> you can for example code the stack abcdef as 0a0b0c0d0e0f1
01:15:45 <pikhq> I don't see why you couldn't do 2 stacks in a single tape. . .
01:16:07 <pikhq> |s1|s2|s1|s2|. . .
01:16:17 <oerjan> i thought that was what i just said!
01:16:41 <oerjan> about odd and even addresses
01:17:25 <pikhq> (c would be used for stopping a loop for finding stack locations (in Brainfuck).)
01:17:46 <oerjan> that would be combining the two techniques we just discussed.
01:18:24 <pikhq> Didn't pay attention. ;)
01:19:51 <oerjan> it's ok. we hadn't made it explicit how to combine them.
01:20:01 <pikhq> I didn't even read the whole discussion.
01:28:32 <oerjan> imagine if the contents of stacks were stacks
01:31:10 <lament> imagine if the contents of the contents were contents!
01:31:47 <oerjan> imagine if the imagination of the images were imagined!
01:33:20 <oerjan> you could distinguish empty stacks
01:34:51 <oerjan> this is probably rather equivalent to lists in Lisp that only contain lists.
01:36:00 <oerjan> also, it resembles somewhat the coding of set theory, where every element of a set is a set and you can still emulate any mathematical object
01:36:27 <oerjan> well, let 0 = [], 1 = [[]].
01:36:51 <oerjan> now you have enough for a stack of bits...
01:37:13 <lament> i'm not quite sure you can emulate any mathematical object with just sets
01:39:00 <lament> bah, i suppose you can.
01:39:19 <oerjan> just about any. there are some issues with proper classes that create paradoxes if you make them sets.
01:40:08 <lament> i wonder if it's provable?
01:40:16 <lament> oh, true, there's classes
01:41:01 <oerjan> however you can sort of get around that by assuming your classes live as sets in an even larger universe
01:43:44 <oerjan> it's not so silly. there are researchers in logic/set theory that investigate large cardinalities that if they exist, imply there are smaller universes inside your set theory
01:45:07 <oerjan> and if you want to investigate category theory with set theory, you need to make such assumptions to allow you to build the categories you want (categories are major sources of proper classes)
01:45:42 <lament> oerjan: it's not silly in itself, it's silly as a way of reducing all mathematical objects to sets because it doesn't work
01:45:43 -!- puzzlet has quit (Client Quit).
01:46:09 <lament> oerjan: unless you accept paradoxes and treat ZFC as a paradox-free part of the whole universe
01:46:11 -!- puzzlet has joined.
01:46:25 <lament> but, er, i don't think that's generally done
01:47:52 <oerjan> but large cardinalities are essentially about accepting ZFC as a part of something larger. but their existence cannot be proven because of Gdel's theorem.
01:48:37 <lament> you mean something larger but paradox-free?
01:48:49 <oerjan> hopefully paradox-free, yes.
01:49:22 <lament> but i think as long as you try to have "everything is a set", you can't possibly escape russel's paradox
01:49:39 <lament> so no matter what paradox-free stuff you have, you will also have non-paradox-free stuff
01:49:46 <oerjan> it actually combines both Gdel's completeness theorem and his incompleteness theorem.
01:50:57 <oerjan> the completeness theorem says that if you have a model of set theory that is a set, then set theory is consistent, while the incompleteness theorem shows that set theory cannot prove itself consistent.
01:51:49 <lament> that doesn't prove much, does it.
01:52:07 <oerjan> so you can never prove that there are smaller universes, unless you are already inconsistent.
01:53:41 <lament> not sure how that's relevant.
01:55:56 <oerjan> well, it means that while you might be alright assuming all of your mathematics fits into a smaller set, you can never prove it for sure.
01:56:47 <oerjan> small enough to be a set rather than a class.
01:57:04 <lament> how can you possibly fit "the set of everything" that way?
01:58:10 <oerjan> let me try a different tack, which actually is more relevant to making everything a set.
01:58:51 <oerjan> Gdel's completeness theorem says that any mathematical theory which is consistent can be modeled as a set.
02:00:28 <lament> to me that just seems to imply that "the set of everything" is not an object in that model.
02:00:39 <lament> sorry, in that theory.
02:01:24 <oerjan> there is a problem though: if the theory itself talks about sets then the model might represent them as something different than the set of their elements
02:02:00 <lament> right. I guess you could just have a special flag for "whether this set is a set of everything"
02:03:40 <oerjan> well, any "normal" set theory which allows subset comprehension cannot have a set of everything without running into Russell's paradox.
02:05:08 <oerjan> that flag would probably be something like the distinction between proper class and set
02:05:10 <lament> like most of set theory
02:05:20 <lament> this discussion is utterly pointless :)
02:05:43 <oerjan> so we should turn to point set topology then? :)
02:05:48 <lament> nobody seriosly tries representing everything as sets
02:06:08 <oerjan> the ZFC foundation of mathematics does so.
02:06:26 <lament> well, the ZFC doesn't, they freely admit classes
02:06:49 <oerjan> actually they don't it is NBG which does that
02:07:15 <oerjan> slightly different formulation with equivalent results for sets
02:07:26 <lament> well, either they freely admit classes or they simply don't consider a whole class of mathematical objects.
02:07:48 <oerjan> (von Neumann - Bernays - Gdel, I think)
02:08:42 <lament> "class of everything" is clearly a mathematical object, doesn't create any paradoxes, behaves nicely in every respect, and is even rather boring.
02:08:47 <oerjan> nono, there is no class of classes :)
02:09:25 <oerjan> there is however a class of every set
02:10:08 <oerjan> if you want a class of classes you need to add some type theory or large cardinality embedding
02:10:55 <lament> all i want is numbers :)
02:11:11 <oerjan> why then we are all set with the von Neumann cardinals.
02:11:49 <oerjan> fine, use Peano arithmetic.
02:12:53 <lament> i wouldn't even use that
02:13:03 <lament> i would just use integers :D
02:13:27 <oerjan> um, Peano arithmetic uses only natural numbers
02:14:06 <lament> i mean, i don't need to bother constructing stuff
02:14:14 <lament> i will just use integers :)
02:14:35 <lament> after all i've been learning for like 18 years how to use them
02:15:06 <CakeProphet> newoperator $ <param1> newoperator <param2> $ print param1 + param2
02:15:29 <oerjan> well, if you are willing to use induction, then all you know about integers probably includes Peano arithmetic already
02:16:21 <oerjan> what language is that? slightly resembles haskell but not quite
02:16:55 <lament> slightly resembles a horrible haskell slash forth derivative?
02:17:15 <CakeProphet> Not haskell.. just some concept I made up.
02:17:24 <oerjan> nah, newoperator looks infix to me
02:17:36 <CakeProphet> for a programming language that allows you to define new operators with customized grammatical structure.
02:17:45 <lament> oerjan: what CakeProphet just said.
02:18:14 <lament> oerjan: that's Forth, and syntax seems to be forthish
02:18:24 <lament> forth doesn't even have to be postfix, of course
02:19:37 <CakeProphet> (operator name) $ (grammatical syntax) $ (definition)
02:19:51 <lament> CakeProphet: how do you know where the definition ends?
02:20:15 <CakeProphet> *shrugs* Dunno... I'll think of that later.
02:20:28 <lament> i suggest you think about it reasonably soon :)
02:21:08 <CakeProphet> Could probably just denote it with a blank line.
02:21:24 <lament> or a more visible token
02:21:26 <CakeProphet> Unless people absolutely cherish the ability to make blank lines for logical divisions.
02:22:04 <oerjan> you could use indentation
02:22:13 <CakeProphet> and then the other principle I had was "mutual association"
02:22:36 <CakeProphet> Let's say % is the operator for mutual association
02:23:05 <lament> use :( instead, he clearly likes that :)
02:23:46 <lament> so, x returns 2, 2 returns x
02:24:01 <oerjan> in that case you should use :( and :) for the first and second $, respectively.
02:24:17 <lament> are you sure you want 2 to return stuff? it's a number after all
02:24:21 <CakeProphet> If we wanted to make it more esoteric... we could have numbers return their ASCII character correspondent... and have characters return their ASCII ordinals.
02:24:27 <lament> oerjan: speaking of 2 returning stuff, functions are so much cooler than sets.
02:24:44 <CakeProphet> Don't see why not... having rules is for silly people
02:25:17 <lament> oerjan: especially if you allow functions to never terminate to avoid all the boring turing issues
02:25:35 <oerjan> resembles FORTE a bit in that way
02:26:19 <oerjan> that doesn't avoid anything...
02:26:21 <lament> (allow functions to never terminate but still return a value, that is)
02:27:10 <CakeProphet> and then <>'s denote an argument for the operators local scope.
02:27:23 <CakeProphet> with everything else just being themselves (or something they return if they have an association)
02:28:06 <oerjan> that still doesn't avoid anything.
02:28:40 <lament> sorry, what i meant is
02:28:41 <oerjan> remember, the halting problem is essentially the computation version of Russell's paradox.
02:29:23 <lament> have all functions return a value, which might require infinite computation
02:30:08 <CakeProphet> Hmmm.. I need a langauge that has indexed functions... simply because that would be strange
02:30:26 <lament> CakeProphet: you mean functions that behave like arrays?
02:31:06 <oerjan> that would just be a different syntax for function calling
02:31:28 <lament> oerjan: there's no halting problem when everything halts :)
02:32:22 <CakeProphet> so then.... []'s could denote optional gramatically particles in the operators syntax...
02:32:30 <oerjan> no, but you could construct a paradox of sorts.
02:32:44 <CakeProphet> so... the grammar definition would basically look like all those syntax explainations you see.
02:33:37 <oerjan> right, some form of BNF.
02:33:44 <lament> oerjan: yeah, i'm sure you could.
02:34:46 <CakeProphet> blah $ <someparam> [with <someparam1> [in <someparam2>] ] # (code code code code) :P
02:35:11 <lament> suppose you have a function x=-x, what would that return...
02:35:11 <oerjan> actually there might not be a paradox, it would just have strange semantics.
02:35:19 <lament> very strange semantics indeed
02:35:42 <lament> (i guess that function ought to return 0 :D)
02:37:04 <lament> x=x+1 returns infinity...
02:38:15 <oerjan> the problem appears if there is no reasonable fix point for the x = f(x).
02:38:19 <CakeProphet> and \ would be the standard "ignore special stuff associated with the next character" thing.
02:39:03 <CakeProphet> So you could put brackets and tags in your gramar definition without the parser reading it as part of the definitions structure.
02:39:16 <lament> oerjan: yes, but isn't there one always?
02:39:24 <oerjan> the problem with such a scheme is that the syntax will easily become ambiguous if it is too flexible.
02:39:53 <lament> CakeProphet: do look at forth, which works similarly
02:40:14 <lament> you can define new stuff on the fly
02:41:02 <lament> oerjan: hm... type error? :)
02:41:05 <CakeProphet> Well.... with some more polishing... this concept-language would make an excellent language-construction language.
02:41:48 <oerjan> how is there a type error?
02:42:05 <lament> oerjan: i guess if x=x+1 returns infinity (which is not a number) then x=not x returns some kind of Maybe (which is not a boolean)
02:42:34 <CakeProphet> In Python.... x = not x returns the opposite boolean value.... so infinity would have to have some sort of boolean value.
02:42:44 <lament> so the type of the function cannot be deduced simply from what functions it uses internally
02:43:11 <lament> 'not' takes booleans, but we extend it to include the fixed point.
02:43:37 <lament> explicitly define a value as "that which is the fixed point of x=not x" and return that :)
02:43:48 <oerjan> but then infinity becomes essentially a bottom value, in that any function applied to infinity is infinity. in the haskell semantics, this is equivalent to nontermination.
02:44:33 <CakeProphet> x = not infinity could just return None (or nil, or void... depending on your naitive language)
02:45:07 <oerjan> but then infinity would not be a fixpoint of x = not x, and so couldn't be returned by it.
02:45:08 <CakeProphet> say As something that is not in everything is nothing. :D
02:45:09 -!- GregorR-L has joined.
02:45:34 <lament> i don't want x = not x to return infinity
02:45:49 <lament> by 'infinity' i meant 'the fixed point of x=x+1' :)
02:46:20 <oerjan> yes, i was referring to cakeprophet's suggestion
02:46:35 <lament> "every type can be extended to include the fixed point of a function returning a value of that type" seems reasonable
02:47:13 <lament> in haskell i suppose the extension is always Bottom but does it have to be?
02:47:52 <lament> x=-x returning 0 is already different semantics from Haskell though.
02:48:12 <lament> x=x would return..... uhh... a randomly chosen fixed point? the class of Everything? dunno.. :)
02:48:43 <oerjan> if you do randomization, then why not just let x=not x return randomly True or False...
02:48:59 <lament> because those are not the fixed points of that function.
02:49:28 <oerjan> you could return sets (:C
02:49:42 <lament> x = x or false would return randomly true or false :)
02:49:46 <oerjan> x=not x returning {True,False}
02:50:10 <lament> it should return the fixed point
02:50:34 <lament> otherwise it's kinda pointless...
02:50:40 <oerjan> but {True,False} would be a fixed point of not, if it acted pointwise.
02:51:37 <lament> then x=x+1 would return Z
02:52:45 <lament> x=x^2 would return the set of all squares :)
02:53:13 <oerjan> actually no. because not all squares are squares of squares.
02:53:38 <oerjan> in fact you would probably return {0, infinity}
02:54:22 <lament> well, inf is not a number so just 0,1
02:54:27 <lament> assuming the default type is integers
02:54:42 <oerjan> but then what about x = x^2+1? :)
02:54:47 <CakeProphet> Hmm.. yeah FORTH looks similar to my idea... but it seems to use different structures and stuff...
02:55:19 <lament> oerjan: that would return "a newly added integer equal to its own square plus 1"
02:55:35 <lament> ...i can see potential for abuse :)
02:56:15 <oerjan> you might do something with nonstandard analysis
02:56:20 <lament> i guess that "newly created integer" IS bottom after all
02:56:37 <lament> since most of the operations are undefined for it
02:57:45 <lament> call this "new integer" q, then q-1 just returns "a newly created integer r", and sqrt(r) returns q
02:58:17 <lament> ...now i'm pretty sure there's gotta a paradox somewhere.
02:58:49 <oerjan> well, it should satisfy q % 3 == 2
02:59:35 <lament> it satisfies a bunch of things
02:59:43 <lament> some of which will probably lead to contradictions
03:00:18 <oerjan> now, what about x = if x == 0 then 1 else 0
03:00:42 <lament> well, obviously that can't return 0 or 1
03:01:11 <lament> although if we use sets like you suggested, then it's just {0,1}
03:01:57 <oerjan> hm... this reminds me of Icon iterators.
03:02:29 <lament> i guess it would return a "newly created integer that is both equal and not equal to zero and one"? :)))
03:02:34 <oerjan> because obviously {0,1} == 0 would have to give {True, False}
03:02:54 <oerjan> and then the if would need to take both branches
03:02:56 <lament> yes, so both 'then' and 'else' are followed
03:03:05 <lament> so it returns {1,0} as expected
03:04:30 <lament> oerjan: i guess the language cannot have an "object identity equality" operator
03:04:38 <oerjan> this reminds me a lot of non-standard analysis, where you add infinite numbers in a consistent way
03:04:47 <lament> oerjan: that always returns true when the operands are the same, and false otherwise
03:05:01 <lament> but if we disallow that, there're no problems once again.
03:05:14 <lament> your function returns something like 0.5 and == has integer semantics.
03:06:14 <oerjan> actually that description fails on x = if x == 0 then 2 else 0
03:06:48 <CakeProphet> Hooks are extremly powerful weapons of mass destruction.
03:07:04 <oerjan> what kind of hooks are these?
03:07:25 <lament> oerjan: by "0.5" i mean "a newly created integer that's equal to both 0 and 1"
03:07:31 <CakeProphet> The kinds that are performed before or after something else automagically.
03:08:09 <oerjan> ah, this thing i've heard mentioned called aspect oriented programming?
03:08:30 <lament> oerjan: hmmmmmmmmmmmmmm
03:08:46 <lament> oerjan: if it does return such an integer
03:08:56 <lament> oerjan: then it's effectively the same as returning {0,1}
03:09:22 <lament> call that integer s, then s+s is "new integer that's equal to 0,1 and 2" etc
03:09:27 <oerjan> yes. it seems to me that if x = f(x) goes through a bounded set then it will return that set.
03:09:34 <lament> so we can't avoid returning sets
03:09:49 <oerjan> ah, there is a problem.
03:10:05 <oerjan> it should really just be equal to 0 and 2
03:10:10 * pikhq notes that it's probably already been done
03:10:53 <lament> oerjan: we don't consider the integers to be a ring anymore
03:11:13 <oerjan> we're not in Kansas anymore...
03:11:14 <lament> oerjan: just treat them as a type with operations + and * defined on the "original" integers so that they form a ring
03:11:28 <lament> but they could and will act differently on sets
03:11:50 <oerjan> i think the semantics is turning out even weirder than i expected.
03:12:21 <lament> but no paradox so far! :)
03:12:47 <oerjan> well, you can easily avoid paradox if you are willing to remove all your theorems :)
03:12:51 <pikhq> @ takes two arguments, not one.
03:13:07 <Razor-X> Actually, @ only requires one item already on the stack.
03:13:07 <lament> oerjan: it's a programming language, who needs theorems?
03:13:27 <lament> oerjan: everything will still work provided your program takes care to halt in the "usual" way
03:13:47 <lament> oerjan: and if it doesn't, everything will work "differently" but still in a predictable fashion
03:14:03 <oerjan> Warning: this language solves the halting problem by doing even more unspeakable things...
03:14:39 <pikhq> Warning: this language is in violation of the Laws Of turing.
03:15:24 <Razor-X> Not you EgoBot. Go back to sleep.
03:16:13 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
03:16:15 <EgoBot> 1l 2l adjust axo bch bf{8,[16],32,64} funge93 fyb fybs glass glypho kipple lambda lazyk linguine malbolge pbrain qbf rail rhotor sadol sceql trigger udage01 unlambda whirl
03:16:27 <Razor-X> Don't tell me it's Ruby on Rails.
03:16:39 <EgoBot> To use an interpreter: <interpreter> <program> Note: <program> can be the actual program, an http:// URL, or a file:// URL which refers to my pseudofilesystem.
03:17:05 <EgoBot> Internal Error: Crash: No 'main' function found
03:17:12 <EgoBot> Internal Error: Crash: No 'main' function found
03:17:13 <EgoBot> 69 ++++++++[>+++++++++++++>++++++++++++>++++><<<<-]>.+.>>.<++.<++++++.>. [97]
03:17:15 <EgoBot> Internal Error: Crash: No 'main' function found
03:17:23 <bsmntbombdood> !bf ++++++++[>+++++++++++++>++++++++++++>++++><<<<-]>.+.>>.<++.<++++++.>.
03:17:27 <EgoBot> Internal Error: Crash: No 'main' function found
03:17:39 <Razor-X> What is this ``rail'' hmm....
03:17:42 <oerjan> <Wiki>Rail was invented by User:Duerig in 2005. It is a two-dimensional language along the lines of Befunge and PATH.
03:17:53 <EgoBot> 111 +++++++++++++++[>+++++++>++++++++>+++++++>++<<<<-]>-.>>.>++.<<<------.>-----.>++++.+.<+.<.>-----.>-.<<.++.>..<. [640]
03:18:03 <Razor-X> Thank you for switching to your browser which I will not.
03:19:11 <EgoBot> 1 EgoBot: daemon EgoBot reload
03:19:13 <EgoBot> 2 GregorR-L: daemon cat bf
03:19:28 <pikhq> !EgoBot hates infinite loops
03:19:51 <EgoBot> 34 ++++++++[>++++++++++++>>><<<<-]>+. [40]
03:20:03 <pikhq> !cat I also hate you.
03:21:52 <oerjan> i think !flush only does input
03:21:57 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
03:21:59 <EgoBot> 1l 2l adjust axo bch bf{8,[16],32,64} funge93 fyb fybs glass glypho kipple lambda lazyk linguine malbolge pbrain qbf rail rhotor sadol sceql trigger udage01 unlambda whirl
03:22:07 <EgoBot> Use: flush Function: flush the output buffer, discarding any current output
03:22:15 <EgoBot> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
03:22:22 <pikhq> The rest goes to your PM.
03:22:56 <Razor-X> Smashing the EgoBot for Fun and Profit.
03:22:59 <bsmntbombdood> !bf ++++++++++[>>++++++++[>++++++++++++>>><<<<-]>+.<-]
03:24:17 <EgoBot> Pikhq, you really should learn to use messages.
03:24:43 <EgoBot> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
03:24:59 <bsmntbombdood> !bf ++++++++++[>>>>>>>>>>>++++++++[>++++++++++++>>><<<<-]>+.<<<<<<<<<<-]
03:25:11 <EgoBot> ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!
03:25:43 <EgoBot> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
03:27:40 -!- EgoBot has quit (Excess Flood).
03:29:12 <Razor-X> Nah. We always find ways to crash EgoBot.
03:29:31 <Razor-X> I'll bet GregorR has sure learned a thing or two about safe computing with us around.
03:30:44 <Razor-X> I remember we crashed it some 4 times in an hour once and GregorR got mad and suspended EgoBot from the channel.
03:37:13 <Razor-X> [Naruto Rip] We are fighting coders! [/Rip]
03:40:35 -!- EgoBot has joined.
03:41:51 -!- EgoBot has quit (Excess Flood).
03:41:53 <pikhq> bsmntbombdood: That would involve a rewrite.
03:42:22 -!- EgoBot has joined.
03:42:48 <pikhq> Now, if we can just exploit a buffer overflow in EgoBot, we can take over his machine. :p
03:42:59 <Razor-X> Nah. He's not *that* stupid.
03:43:01 <pikhq> Download an EgoBot tarball, and scan for buffer overflows.
03:43:30 <pikhq> http://esolangs.org/files/egobot/
03:48:21 -!- CakeProphet has quit (Read error: 113 (No route to host)).
03:48:40 <pikhq> Damn it; he designed it 'well'.
03:49:17 * pikhq wonders how the hell egobotIRC.sh works
03:50:42 <Razor-X> : A-TABLE 255 0 DO I DUP . SPACE EMIT CR LOOP
03:50:56 <Razor-X> Add that word in and execute it. It prints out the ASCII table.
03:53:08 * pikhq looks for a bug in sendOutput
03:59:20 <oerjan> i wondered if that meant _well_ or "well" :)
04:00:32 <oerjan> finally, an EgoBot quine!
04:01:48 <Razor-X> I posted my Forth quine earlier.
04:03:02 <pikhq> !bf ++++++++>++++[-<.>]
04:03:08 <bsmntbombdood> !bf ->+>+++>>+>++>+>+++>>+>++>>>+>+>+>++>+>>>>+++>+>>++>+>+++>>++>++>>+>>+>++>++>+>>>>+++>+>>>>++>++>>>>+>>++>+>+++>>>++>>++++++>>+>>++>+>>>>+++>>+++++>>+>+++>>>++>>++>>+>>++>+>+++>>>++>>+++++++++++++>>+>>++>+>+++>+>+++>>>++>>++++>>+>>++>+>>>>+++>>+++++>>>>++>>>>+>+>++>>+++>+>>>>+++>+>>>>+++>+>>>>+++>>++>++>+>+++>+>++>++>>>>>>++>+>+++>>>>>+++>>>++>+>+++>+>+>++>>>>>>++>>>+>>>++>+>>>>+++>+>>>+>>++>+>++++++++++++++++++>>>>+>+>>>+>>++
04:03:15 <bsmntbombdood> +++++>>+>>++>+>>>>+++>>++++++>>>+>++>>+++>+>+>++>+>+++>>>>>+++>>>+>+>>++>+>+++>>>++>>++++++++>>+>>++>+>>>>+++>>++++>>+>+++>>>>>>++>+>+++>>+>++>>>>+>+>++>+>>>>+++>>+++>>>+[[->>+<<]<+]+++++[->+++++++++<]>.[+]>>[<<+++++++[->+++++++++<]>-.------------------->-[-<.<+>>]<[+]<+>>>]<<<[-[-[-[>>+<++++++[->+++++<]]>++++++++++++++<]>+++<]++++++[->+++++++<]>+<<<-[->>>++<<<]>[->>.<<]<<]
04:03:29 <Razor-X> I think EgoBot can't parse that.
04:03:30 <pikhq> Aaaw; it doesn't do any actual backspacing.
04:04:19 -!- EgoBot has quit (Success).
04:04:37 <Razor-X> Razor-X has not quit: Failure.
04:04:49 -!- EgoBot has joined.
04:05:50 <GregorR-L> Now EgoBot runs through slox, which prevents it from taking 100% CPU :)
04:06:05 <EgoBot> Use: i <pid> <input> Function: send input to a process
04:06:09 <lament> yes, it does input, just no output
04:09:20 <bsmntbombdood> >++++++++++>>+<+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<]>.>[->[<++>-]<[>+
04:09:23 <bsmntbombdood> <-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>[-]>[-]++<<-[>+<-]]]]]]]]]]]+>>]<<]
04:10:14 <bsmntbombdood> !bf >++++++++++>>+<+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<]>.>[->[<++>-]<[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>[-]>[-]++<<-[>+<-]]]]]]]]]]]+>>]<<]
04:10:51 -!- EgoBot has quit (Excess Flood).
04:11:29 <GregorR-L> I can't seem to commit to the esofiles archive >_O
04:11:32 -!- EgoBot has joined.
04:17:02 <Razor-X> ^_O <-- guy wearing a monocle.
04:20:32 <GregorR-L> Anybody active have files access? >_>
04:20:48 <Razor-X> Seems there was a hostile takeover GregorR-L.
04:21:13 <Razor-X> The old Republic of Esome has been overthrown. Long live Easar!
04:21:40 -!- GregorR-L has quit ("Leaving").
04:59:49 -!- thematrixeatsyou has joined.
05:13:32 -!- Sgeo has quit (Read error: 54 (Connection reset by peer)).
05:14:48 <thematrixeatsyou> each instruction: 6-bit opcode, two 1-bit flags (0=data is value, 1=data is pointer), two x-bit data slots
05:16:10 <thematrixeatsyou> 16-bit e.g: MOV $2000,($2002) - set data at position $2000 to data at position $2002
05:16:26 <thematrixeatsyou> MOV ($2000),$2002 - set data at position at position $2000 to value $2002
05:17:28 <thematrixeatsyou> MOV $2000,($2002) = 00000101 00100000 00000000 00100000 00000010 = 05 20 00 20 02
05:17:41 <thematrixeatsyou> MOV ($2000),$2002 = 00000110 00100000 00000000 00100000 00000010 = 06 20 00 20 02
05:18:05 <thematrixeatsyou> there's 20 instructions so far and the flags can be read/written individually
05:28:15 -!- Arrogant has joined.
05:30:02 -!- oerjan has quit ("Good night.").
05:31:13 <thematrixeatsyou> 64 potential commands (20 so far) and a reasonable internal cache :)
05:32:36 <thematrixeatsyou> in a 16-bit design: 0000-0FFF = BIOS, 1000-1FFF = fixed memory, 2000-3FFF = cache, 4000-7FFF+8000-BFFF+C000-FFFF = 3 banks
05:32:55 <thematrixeatsyou> each instruction: 6-bit opcode, two 1-bit flags (0=data is value, 1=data is pointer), two x-bit data slots
05:34:47 <thematrixeatsyou> in this 16-bit design, there is a 40-bit read bus and a 16-bit read/write bus. the 24 extra bits in the read bus are available once you activate high-bandwidth mode
05:46:02 <Arrogant> make a brainfuck interpreter in wireworld
06:14:31 -!- Razor-X has quit (Read error: 110 (Connection timed out)).
06:15:32 -!- Razor-X has joined.
06:15:49 <thematrixeatsyou> NCEA marks: N=not achieved(Fail), A=achieved(Pass), M=merit(Passed Well), E=excellence(Completely Aced)
06:16:16 <thematrixeatsyou> questions can be marked by A, M, or E, some with combinations of the three
06:16:47 <Arrogant> High school exams are just starting to get standardized, bringing in the Cambridge program that'll be covering most of the courses
06:17:10 <thematrixeatsyou> most tests: you need enough A's to get Achieved, enough A's and M's to get Merit, and enough A's and M's and E's to get Excellence
06:17:41 <thematrixeatsyou> english tests: A = answered both parts of the question, M = that done well, E = no fucking hope
06:19:09 <thematrixeatsyou> actually, M = A AND following the standard S.E.X structure (Subject, Explanation, eXample), E = give an indirect opinion
06:23:55 <thematrixeatsyou> excellence questions are the ultimate bitch, yoiu have to explain it as if the examiners were 10-year-olds
06:25:57 <thematrixeatsyou> Some rows seat 24 students and the remainder of the rows seat 18 students.
06:26:17 <thematrixeatsyou> Use algebraic techniques to find the number of rows that seat 18 students.
06:26:45 <thematrixeatsyou> - that would be a relatively easy one if there wasn't the damn explaining.
06:27:03 <thematrixeatsyou> acutally, it's one of the easiest excellence questions i've seen.
06:29:22 <Razor-X> That's an.... excellence question?
06:32:10 <thematrixeatsyou> shoulda explained that w = rows with 24 seats and n = rows with 18 seats
06:32:11 <GregorR> Slox now has a GUI, and lets you change program speed at runtime 8-D
06:32:35 <Razor-X> Incredibly incredibly easy homework.
06:33:08 <Razor-X> My homework right now is 20 problems of finding the relative minima, maxima, intervals of increase, and intervals of decrease of the given function.
06:33:56 <Razor-X> I'm also in the 3rd year of high school.
06:34:06 <Arrogant> I graduated but that's okay, I'm stupid.
06:34:46 <Razor-X> It's only mildly interesting to set theory, IMO.
06:35:17 <Razor-X> But I'm gonna write a symbolic differentiation utility some time later.
06:35:18 <Arrogant> Razor-X is some kind of sorceress
06:35:37 <Razor-X> It's not atypical to take Calculus in HS.
06:36:11 <Arrogant> Don't take your double negatives lightly, missy
06:36:22 <thematrixeatsyou> it's called college here, and i'm going into exams in nearly 2 weeks
06:36:58 <Arrogant> I took Calculus my senior year
06:39:54 <wooby> in new york state the state exams (regents) in the primary subjects usually happen in 10th and 11th grade, or the 2nd and 3rd years of high school
06:40:29 <Arrogant> We have the FCAT down here but that's a joke
06:40:44 <wooby> the NYS regents are more or less also a joke
06:41:00 <Arrogant> AP classes are the "proper exams"
06:41:04 <wooby> most serious students take standardized tests which are often accepted as college credits, AP
06:42:06 <wooby> good thing you didn't take 5 :)
06:42:34 <Arrogant> Would've had to shake it up a little :)
06:49:02 -!- anonfunc has joined.
06:53:57 <Razor-X> I took 2 AP exams last year, I'll be taking 4 (maybe 5) more this year.
06:57:52 <anonfunc> Back to the religious language? :-P
07:06:40 -!- pgimeno has quit (niven.freenode.net irc.freenode.net).
07:06:40 -!- pikhq has quit (niven.freenode.net irc.freenode.net).
07:07:01 -!- pgimeno has joined.
07:31:27 <thematrixeatsyou> arrogant: finished the memory side of the tape on the interpreter, working on the pointer
07:32:47 <Arrogant> now actually it can't be brainfuck
07:33:04 <Arrogant> i suppose you could ready a stream of bits to be read
07:33:09 <Arrogant> and the output is going to be terrible :D
07:33:37 -!- Sillyman has joined.
07:35:17 <Arrogant> and it doesn't really support letters :)
07:35:40 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
07:35:42 <EgoBot> 1l 2l adjust axo bch bf{8,[16],32,64} funge93 fyb fybs glass glypho kipple lambda lazyk linguine malbolge pbrain qbf rail rhotor sadol sceql trigger udage01 unlambda whirl
07:36:05 <thematrixeatsyou> i actually know how the LCD works and have build an LCD display myself
07:36:32 <Arrogant> the conversions are what kill you
07:36:34 <thematrixeatsyou> then LCD = Liquid Crystal Display: i said Liquid Crystal Display Display
07:37:29 <Arrogant> I think someone should go through the trouble of just making a display that could do Hello, world!
07:38:25 <Razor-X> Where are the Wireworld rules?
07:38:39 <RodgerTheGreat> you'd probably want to make a bitstream decoder that could handle a simple character set
07:40:13 <RodgerTheGreat> this is really an incredible machine: http://www.quinapalus.com/wires11.html
07:40:28 <RodgerTheGreat> as I've said before, I'd be fascinated to code for it.
07:41:08 <RodgerTheGreat> and the computer itself is really quite pretty just to look at.
07:41:52 <Arrogant> unfortunate that the display is rather limited
07:46:11 <RodgerTheGreat> it would be pretty straightforward to build a simple delay line system based on the registers in the computer to serve as a form of buffered input.
07:46:43 <RodgerTheGreat> if electrons moved that slowly, that's how electronics would be.
07:47:45 <Razor-X> ? How would that simulate a computer?
07:48:21 <RodgerTheGreat> notice the irregular design of the bottom registers- those are how you can perform logical and mathematical operations.
07:48:21 <Razor-X> (Sorry, X did one of it's famous I WANTS J00Z CPU temper tantrums.)
07:49:13 <Arrogant> I like that organization much more
07:49:24 <RodgerTheGreat> the entire computer is based on an OISC design, with specialized registers and a writeable program counter providing all desired functionality
07:49:32 <thematrixeatsyou> this is also cool, not wireworld but on the same site: http://www.quinapalus.com/picsi.html
07:49:57 <RodgerTheGreat> I'll bet this would be a snap to extend, although adjusting the clock for a larger storage space might be tricky.
07:52:23 <RodgerTheGreat> as I said, the wireworld computer is a beautiful, elegant machine.
07:57:03 <Razor-X> Truth be told, I'm afraid :D
07:57:30 <RodgerTheGreat> just read through the descriptions- the more I understood about it, the more I was in awe
07:57:54 <Razor-X> Computers tend to lend their analogies to my brain's workings pretty well, no matter what the level. But it seems... incredibly that you're simulating electricity flow (correct?) through WireWorld rules...
07:57:55 <RodgerTheGreat> I'm tempted to make an emulator for the computer itself just for fun- extremely easy to do, really.
07:58:59 <Razor-X> How do you simulate a clock signal?
07:59:08 <Razor-X> Or the concept of time in general?
07:59:29 <Razor-X> Or does the entire system work via an implicit clock because of time flow in the wireworld rules?
07:59:31 <RodgerTheGreat> closed loops that spit out an "electron" at a fixed rate
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:00:12 <RodgerTheGreat> all of the loopbacks and coils you see in the computer are there to tightly control the amount of time signals take to propogate
08:02:21 <thematrixeatsyou> the binary adders I call "OUT" adders because it looks like they spell "OUT"
08:02:40 <RodgerTheGreat> a BCD signal is sent to each digit, which filters through a ROM to trigger the appropriate domino patterns. these patterns are generated by routing ROM outputs to flipflops/oscilators that "fill" each domino with a series of pulsing electrons.
08:05:13 <RodgerTheGreat> the whole thing is basically a clock that connects to a system that can transfer data between registers. The registers themselves do operations (including the PC), and one is attached to a hex->BCD converter that in turn connects to a multiplexer for each display element. Finally, we have the digits themselves.
08:06:01 <thematrixeatsyou> The instructions are stored in the registers themselves: the source and destination register numbers are coded as six bits each, and stored in the two halves of a sixteen bit value.
08:06:29 <thematrixeatsyou> For efficiency, the next instruction is prefetched while the destination register is being written, and hence there is one branch delay slot.
08:06:39 <RodgerTheGreat> I meant in terms of adding new "instructions" - additional specialized registers
08:07:33 <RodgerTheGreat> well, I think I'm going to get some sleep. G'night, all!
08:15:28 <Sillyman> Anyways, now that we've discussed turing complete simple CA, howabout turing complete complex CA?
08:24:39 -!- Sillyman has left (?).
08:40:23 -!- lindi- has quit (Remote closed the connection).
08:40:31 -!- lindi- has joined.
08:45:30 -!- thematrixeatsyou has quit ("MOV eax,awos").
09:11:17 -!- Arrogant has quit ("Leaving").
09:13:03 -!- bsmntbombdood has quit (Read error: 60 (Operation timed out)).
09:31:48 -!- xor has joined.
09:42:05 -!- clog has joined.
09:42:05 -!- clog has joined.
09:42:08 -!- Razor-X` has joined.
09:42:42 -!- Eidolos has joined.
09:42:51 -!- GregorR has joined.
09:45:14 -!- RodgerTheGreat has joined.
09:51:42 -!- sp3tt has joined.
13:54:37 -!- clog has joined.
13:54:37 -!- clog has joined.
13:55:09 -!- EgoBot has joined.
13:55:37 -!- nooga has joined.
13:55:49 -!- pgimeno has joined.
13:56:00 -!- anders has joined.
13:56:26 -!- meatmanek has joined.
13:57:01 -!- mtve has joined.
13:57:18 -!- pikhq has joined.
13:59:48 -!- tokigun has joined.
14:32:19 <nooga> pitty that the curent run is ended
14:36:38 -!- lindi- has joined.
14:50:31 -!- sekhmet has joined.
14:53:05 -!- fizzie has quit (kornbluth.freenode.net irc.freenode.net).
14:58:06 -!- fizzie has joined.
14:58:27 -!- fizzie has quit (kornbluth.freenode.net irc.freenode.net).
15:01:54 -!- cmeme has joined.
15:02:26 -!- RodgerTheGreat has joined.
15:03:06 -!- fizzie has joined.
15:25:18 <nooga> am I transparent? ;/
15:55:46 -!- ihope has joined.
16:22:56 -!- jix has joined.
16:29:05 <jix> nah i don't know a hal quote right now
16:29:08 <jix> that's bad
16:30:14 <nooga> my congrats about ABCDEF
16:30:50 <nooga> pitty that it's too late to contribute sth for the first run
16:33:50 <jix> nooga: it is somehow stalled :/
16:34:43 <jix> nooga: I'm sorry nooga, I'm afraid i can't do that.
16:35:48 <nooga> maybe next time... :>
16:35:52 <jix> (that was a hal quote...)
16:36:17 <jix> but rplace nooga with dave
16:38:20 <nooga> I didn't get it at first ;D
16:45:15 <nooga> currently i'm thinking about WAM based esolang
16:45:41 <nooga> something like twisted and minimal Prolog dialect
16:48:05 <nooga> but I can't find any digestible papers on WAM
16:53:05 -!- nooga has quit.
16:59:44 -!- Sph1nx has joined.
17:23:00 -!- Sph1nx has quit (Remote closed the connection).
17:25:06 -!- lament has joined.
20:21:54 -!- ihope_ has joined.
20:38:09 -!- ihope has quit (Read error: 110 (Connection timed out)).
20:57:27 -!- CakeProphet has joined.
21:00:15 -!- Sgeo has joined.
21:03:55 -!- kipple_ has joined.
21:13:10 <ihope_> I declare IRP to be either not Turing-complete or not well-defined, by the way.
21:14:03 <ihope_> Unless somebody can come up with a specification of just how other people are supposed to act, that is.
21:14:23 <ihope_> I think most of us will agree that IRP minus network connections is not Turing-complete.
21:19:30 <ihope_> (Oh, and that re-summon was about QBF, not IRP.)
21:19:56 <RodgerTheGreat> my argument for it's turing-completeness (on a network) is that you could theoretically have an infinite number of "CPU's", allowing for unbounded storage and processing.
21:20:38 <RodgerTheGreat> storage is not limited by the spec or the language's implicit details, so it is a turing-complete language
21:25:43 <ihope_> The spec does leave some things undefined.
21:25:54 <ihope_> Actually, it leaves pretty much everything undefined.
21:26:27 <RodgerTheGreat> that doesn't really prevent it from being turing-complete, it just makes the language inefficient and unreliable.
21:27:14 <ihope_> Isn't reliability a requirement for Turing-completeness?
21:28:38 <ihope_> Okay then, here's a new language for you: Wheee.
21:28:49 <ihope_> In Wheee, everything is undefined and implementation-dependent.
21:29:56 <ihope_> Is Wheee Turing-complete?
21:30:02 <RodgerTheGreat> in that case, turing-completeness would be defined by the implementation, rather than the spec.
21:30:40 <RodgerTheGreat> you could say that the spec is, but it doesn't ensure that implementations will even vaguely resemble turing-completeness.
21:31:02 <RodgerTheGreat> this isn't really a problem, because I have yet to see a turing-complete implementation for *any* language.
21:33:58 <ihope_> Well then, isn't Turing-completeness of IRP also defined by the implementation?
21:35:25 <RodgerTheGreat> of course. I assume IRC has limits to the number of users on a channel/server/etc, so there is a finite storage capacity. Ergo, not turing complete. This does not invalidate my previous statement that the *language* is turing-complete.
21:38:36 <lament> ihope_: no, wheee is not turing-complete.
21:38:53 <lament> ihope_: turing-completeness verification shouldn't take implementation-dependent issues into account.
21:39:22 <lament> when verifying turing-completness and the spec says something is "implementation dependent", you might as well take that to mean "the universe implodes"
22:01:36 -!- oerjan has joined.
22:12:44 -!- bsmntbombdood has joined.
22:22:19 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:42:12 -!- wooby has quit.
22:56:05 -!- kipple_ has quit (Read error: 60 (Operation timed out)).
23:05:17 -!- oerjan has quit ("Later").
23:46:16 -!- bsmntbombdood has changed nick to xor.
23:54:03 <lament> Razor-X`: please add 1 and 1
23:54:49 <pikhq> Razor-X`: Please interprete the following Brainfuck code: ,[.,]
23:55:39 <Razor-X`> That's what happens when you try and interprete BF code with me.
23:55:46 <xor> !i 1 hi bob
23:55:50 <pikhq> You're not Turing complete.
23:56:07 <pikhq> You didn't interpret the code.
23:56:15 <Razor-X`> No, I didn't. I intepreteed it.