←2006-11-01 2006-11-02 2006-11-03→ ↑2006 ↑all
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:01:37 <Razor-X> Hmm. What did you get?
00:02:09 <RodgerTheGreat> 1320. it served my purposes
00:05:10 <RodgerTheGreat> that's with the latest revision. The national average is approximately 1028
00:05:20 <RodgerTheGreat> a perfect score would be 1600
00:07:34 <RodgerTheGreat> (this is for the multiple-choice versions of the test)
00:07:54 <RodgerTheGreat> s /versions/sections
00:16:43 <Razor-X> Ah.
00:46:53 -!- Anders has changed nick to anders.
00:53:18 -!- ihope has joined.
00:55:26 * bsmntbombdood wastes more time not coding esoteric languages
00:55:53 <ihope> Hasp!
00:56:09 <ihope> (As opposed to "gasp", a very different word.)
00:56:15 <bsmntbombdood> Hasp?
00:56:30 <oerjan> hasp: a new esoteric language horrendously mixing haskell and lisp
00:56:35 <bsmntbombdood> hmmm
00:56:42 <bsmntbombdood> brainfuck + stack == bliss
00:57:01 <ihope> http://en.wiktionary.org/wiki/hasp
00:57:19 * bsmntbombdood has an bf extension
00:58:20 <bsmntbombdood> _ puts the current cell on the stack
00:58:31 <bsmntbombdood> ^ pops the stack into the current cell
00:59:45 <oerjan> but if two stacks can emulate a tape, isn't this then essensially a three-stack language?
01:00:17 <oerjan> *essentially
01:01:28 <oerjan> now if we used four stacks and let <>^V all act analogously...
01:01:41 <bsmntbombdood> wait
01:01:49 <bsmntbombdood> 2 stacks can emulate a tape?
01:02:03 <oerjan> certainly.
01:02:12 <bsmntbombdood> explain
01:02:21 <bsmntbombdood> oh wait
01:02:22 <bsmntbombdood> I get it
01:03:25 <bsmntbombdood> to go over one you just do b.push(a.pop())
01:03:46 <oerjan> exactly.
01:04:42 <bsmntbombdood> but a tape can't emulate 2 stacks
01:05:04 <bsmntbombdood> unless you have two pointers
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:14 <bsmntbombdood> tapes are endless
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:37 <bsmntbombdood> you would still need an extra pointer
01:08:46 <oerjan> but of course all of these _can_ emulate the others, being enough for turing-completeness
01:09:28 <bsmntbombdood> not trivially
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:09:57 <bsmntbombdood> that would work
01:10:16 <bsmntbombdood> Then a tape can emulate any number of stacks
01:10:28 <bsmntbombdood> if you have a reserved character
01:11:09 <oerjan> if you don't then you can code one character set as strings in another.
01:11:40 <bsmntbombdood> ?
01:12:57 <oerjan> you can for example code the stack abcdef as 0a0b0c0d0e0f1
01:13:17 <bsmntbombdood> yeah
01:15:05 <bsmntbombdood> two stacks can emulate any number of tapes
01:15:40 <bsmntbombdood> i think
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:36 <bsmntbombdood> yeah
01:16:41 <oerjan> about odd and even addresses
01:16:41 <pikhq> Or just:
01:16:52 <pikhq> |s1|c|s2|c|. . .
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:00 * pikhq looks back.
01:18:03 <pikhq> . . . Oh.
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:26:40 <bsmntbombdood> ooooh
01:26:47 <bsmntbombdood> imagine if we had a tape of stacks
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:32:43 <bsmntbombdood> a recursive stack wouldn't work
01:32:55 <oerjan> sure it could.
01:32:55 <bsmntbombdood> you wouldn't be able to put any data in it
01:33:15 <bsmntbombdood> unless it held two different data types
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:35:31 <bsmntbombdood> how would you put data in it?
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:40:26 <lament> so it's disprovable
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:41:39 <lament> nah, that's silly
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:44:15 <meatmanek> brainfuck plus stack, eh?
01:44:21 <meatmanek> that actually sounds useable.
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:07 <lament> right
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:16 <lament> "smaller"?
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:04 <lament> anyway
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:05:55 <lament> heh
02:06:08 <oerjan> the ZFC foundation of mathematics does so.
02:06:13 <lament> exactly
02:06:17 <lament> a bunch of wankers :)
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:36 <lament> haha
02:10:55 <lament> all i want is numbers :)
02:10:57 <lament> 1 + 1 = 2
02:11:11 <oerjan> why then we are all set with the von Neumann cardinals.
02:11:24 <lament> no, no
02:11:26 <oerjan> ordinals rather
02:11:28 <lament> i don't want sets
02:11:32 <lament> i just want numbers
02:11:40 <lament> :)
02:11:43 <lament> 1 + 1 = 2
02:11:49 <oerjan> fine, use Peano arithmetic.
02:12:45 <CakeProphet> hmmm...
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:13:36 <oerjan> even less
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:16 <CakeProphet> So...
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:20 <CakeProphet> 1 newoperator 23
02:15:23 <CakeProphet> 24
02:15:29 <oerjan> well, if you are willing to use induction, then all you know about integers probably includes Peano arithmetic already
02:15:58 <lament> sure
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:22 <lament> eh
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:17 <lament> yeah
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:14 <lament> or something like .
02:22:20 <CakeProphet> . works :D
02:22:36 <oerjan> phew, punctuation :(
02:22:36 <CakeProphet> Let's say % is the operator for mutual association
02:22:43 <CakeProphet> x % 2
02:22:47 <lament> okay, not .
02:22:48 <CakeProphet> x returns 2
02:22:51 <CakeProphet> 2 returns x
02:22:53 <lament> oerjan doesn't like 2
02:22:55 <lament> er
02:22:59 <lament> oerjan doesn't like .
02:23:05 <lament> use :( instead, he clearly likes that :)
02:23:06 <CakeProphet> fuck oerjan
02:23:17 <CakeProphet> Hmmm... actually
02:23:21 <CakeProphet> :P
02:23:28 <CakeProphet> We'll use :P for the end-of-definition
02:23:32 <lament> heh
02:23:46 <lament> so, x returns 2, 2 returns x
02:23:48 <lament> now what?
02:23:57 <CakeProphet> That was pretty much it...
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:24:55 <CakeProphet> Make anything associationable.
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:26:30 <lament> :P
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:25 <oerjan> indexed?
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:31:59 <CakeProphet> Hmmm...
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:26 <lament> (but not sure how)
02:34:46 <CakeProphet> blah $ <someparam> [with <someparam1> [in <someparam2>] ] # (code code code code) :P
02:34:55 <CakeProphet> :P being the end-of-definition token.
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:37:55 <lament> x=x returns...uh...
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:41 <CakeProphet> Yes but... I don't care... so it works.
02:39:52 <CakeProphet> :P
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:40:22 <oerjan> what about x=not x ?
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:49:57 <lament> no
02:50:10 <lament> it should return the fixed point
02:50:34 <lament> otherwise it's kinda pointless...
02:50:36 <lament> ..and adrift...
02:50:40 <oerjan> but {True,False} would be a fixed point of not, if it acted pointwise.
02:50:47 <lament> oh
02:50:54 <lament> right
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:27 <lament> er, right
02:53:38 <oerjan> in fact you would probably return {0, infinity}
02:53:42 <lament> 1
02:53:47 <oerjan> that too
02:53:47 <lament> 0,1,inf
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:29 <lament> well, almost
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:31 <lament> hm
03:01:57 <oerjan> hm... this reminds me of Icon iterators.
03:02:02 <lament> hm.
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:04:49 <oerjan> apparently not
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:32 <CakeProphet> Probably.
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:36 * bsmntbombdood thinks of a language that has 3 instructions
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:21 <oerjan> because s+s == 2*s
03:10:34 <lament> oerjan: no
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:11:58 <lament> haha
03:12:21 <lament> but no paradox so far! :)
03:12:23 <Razor-X> Forth not FORTH!
03:12:31 <Razor-X> @ Everyone.
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:12:54 <lament> oerjan: :)
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:04 <pikhq> s/turing/Turing/
03:15:10 <Razor-X> Turning
03:15:11 <Razor-X> !
03:15:15 <EgoBot> Huh?
03:15:24 <Razor-X> Not you EgoBot. Go back to sleep.
03:15:57 <EgoBot> OK.
03:16:09 <bsmntbombdood> !help
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:23 <Razor-X> What's Rail?
03:16:27 <Razor-X> Don't tell me it's Ruby on Rails.
03:16:36 <oerjan> !help rail
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:16:44 <Razor-X> Yes. Very helpful.
03:17:01 <bsmntbombdood> !bf_txtgen hi bob
03:17:02 <lament> !rail 1
03:17:05 <EgoBot> Internal Error: Crash: No 'main' function found
03:17:08 <lament> !rail main
03:17:10 <Razor-X> !rail main
03:17:12 <EgoBot> Internal Error: Crash: No 'main' function found
03:17:13 <EgoBot> 69 ++++++++[>+++++++++++++>++++++++++++>++++><<<<-]>.+.>>.<++.<++++++.>. [97]
03:17:13 <Razor-X> Guh.
03:17:15 <EgoBot> Internal Error: Crash: No 'main' function found
03:17:23 <bsmntbombdood> !bf ++++++++[>+++++++++++++>++++++++++++>++++><<<<-]>.+.>>.<++.<++++++.>.
03:17:23 <Razor-X> !rail main { 4 }
03:17:25 <EgoBot> hi bob
03:17:27 <EgoBot> Internal Error: Crash: No 'main' function found
03:17:37 <bsmntbombdood> !bf_txtgen hi bsmntbombdood
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:51 <Razor-X> Aha
03:17:51 <Razor-X> .
03:17:53 <EgoBot> 111 +++++++++++++++[>+++++++>++++++++>+++++++>++<<<<-]>-.>>.>++.<<<------.>-----.>++++.+.<+.<.>-----.>-.<<.++.>..<. [640]
03:18:03 <Razor-X> Thank you for switching to your browser which I will not.
03:18:30 <bsmntbombdood> !bf +[]
03:19:07 <pikhq> !ps d
03:19:11 <EgoBot> 1 EgoBot: daemon EgoBot reload
03:19:13 <EgoBot> 2 GregorR-L: daemon cat bf
03:19:15 <EgoBot> 3 bsmntbombdood: bf
03:19:17 <EgoBot> 4 pikhq: ps
03:19:18 <pikhq> !kill 3
03:19:21 <EgoBot> Process 3 killed.
03:19:25 <bsmntbombdood> no fair!
03:19:28 <pikhq> !EgoBot hates infinite loops
03:19:31 * EgoBot hates infinite loops
03:19:41 <bsmntbombdood> !bf_txtgen a
03:19:51 <EgoBot> 34 ++++++++[>++++++++++++>>><<<<-]>+. [40]
03:20:03 <pikhq> !cat I also hate you.
03:20:07 <EgoBot> I also hate you.
03:20:39 <bsmntbombdood> \!bf >++++++++[>++++++++++++>>><<<<-]>+[.]
03:20:47 <bsmntbombdood> :D
03:21:03 <pikhq> Do it.
03:21:10 <bsmntbombdood> !bf >++++++++[>++++++++++++>>><<<<-]>+[.]
03:21:28 <bsmntbombdood> hmmm
03:21:30 <pikhq> !flush 3
03:21:30 <bsmntbombdood> !ps
03:21:33 <EgoBot> 3 bsmntbombdood: bf
03:21:35 <EgoBot> 4 bsmntbombdood: ps
03:21:48 <bsmntbombdood> output buffered?
03:21:52 <oerjan> i think !flush only does input
03:21:52 <pikhq> Yes.
03:21:55 <pikhq> Oh.
03:21:56 <pikhq> !help
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:05 <EgoBot> Stop the hatin' !
03:22:06 <pikhq> !help flush
03:22:07 <EgoBot> Use: flush Function: flush the output buffer, discarding any current output
03:22:11 <bsmntbombdood> !kill 3
03:22:13 <EgoBot> Process 3 killed.
03:22:15 <EgoBot> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
03:22:20 <bsmntbombdood> lol
03:22:22 <pikhq> The rest goes to your PM.
03:22:22 <oerjan> oh.
03:22:40 <pikhq> Razor-X: Not yet.
03:22:47 <Razor-X> Awww.
03:22:56 <Razor-X> Smashing the EgoBot for Fun and Profit.
03:22:59 <bsmntbombdood> !bf ++++++++++[>>++++++++[>++++++++++++>>><<<<-]>+.<-]
03:23:01 <pikhq> !cat Hahahah
03:23:03 <EgoBot> Hahahah
03:23:04 <oerjan> poor egobot.
03:23:19 <wooby> hio
03:23:26 <Razor-X> cio
03:23:55 <bsmntbombdood> awwww
03:23:55 <pikhq> !bf .
03:24:01 <bsmntbombdood> how come it didn't do mine
03:24:11 <pikhq> !bf_textgen exit
03:24:12 <bsmntbombdood> !ps
03:24:13 <EgoBot> 3 bsmntbombdood: bf
03:24:15 <EgoBot> 4 bsmntbombdood: ps
03:24:17 <EgoBot> Pikhq, you really should learn to use messages.
03:24:18 <Razor-X> !bf -.
03:24:23 <EgoBot>
03:24:29 <Razor-X> !bf --.
03:24:31 <EgoBot>
03:24:43 <EgoBot> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
03:24:59 <bsmntbombdood> !bf ++++++++++[>>>>>>>>>>>++++++++[>++++++++++++>>><<<<-]>+.<<<<<<<<<<-]
03:25:09 <pikhq> !bf -[-.]
03:25:11 <EgoBot> ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!
03:25:32 <bsmntbombdood> !ps
03:25:33 <EgoBot> 3 bsmntbombdood: bf
03:25:34 <pikhq> It's still going.
03:25:35 <EgoBot> 4 bsmntbombdood: ps
03:25:39 <bsmntbombdood> !kill 3
03:25:41 <EgoBot> Process 3 killed.
03:25:43 <EgoBot> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
03:25:46 <bsmntbombdood> grrrr
03:26:04 <pikhq> ls
03:26:07 <pikhq> Err.
03:26:11 <Razor-X> Hehe.
03:26:20 <pikhq> !bf32 +[+.]
03:26:36 * pikhq is a very bad man
03:26:51 <bsmntbombdood> lol
03:27:06 <pikhq> !bf64 +[+.]
03:27:07 <EgoBot>
03:27:12 <pikhq> You see?
03:27:18 <Razor-X> !bf +>-[<.+>-]
03:27:40 -!- EgoBot has quit (Excess Flood).
03:27:45 <bsmntbombdood> aaaaw
03:27:45 <Razor-X> ;D
03:27:47 <pikhq> Victoly!
03:27:54 <Razor-X> 勝ち!!!
03:28:53 <bsmntbombdood> poor bot
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:14 <wooby> lol
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:34:36 <bsmntbombdood> He just need to harden it a little
03:37:13 <Razor-X> [Naruto Rip] We are fighting coders! [/Rip]
03:40:35 -!- EgoBot has joined.
03:41:15 <Razor-X> !bf +>-[<.+>-]
03:41:19 <EgoBot> <CTCP>
03:41:32 <Razor-X> Oh oh.
03:41:51 -!- EgoBot has quit (Excess Flood).
03:41:53 <pikhq> bsmntbombdood: That would involve a rewrite.
03:41:56 <pikhq> Bravo.
03:42:08 <pikhq> First try; nice.
03:42:14 <Razor-X> もう一度勝ち!!!
03:42:22 -!- EgoBot has joined.
03:42:26 <Razor-X> ;D
03:42:48 <pikhq> Now, if we can just exploit a buffer overflow in EgoBot, we can take over his machine. :p
03:42:55 <bsmntbombdood> heh
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:02 <bsmntbombdood> Is it open source?
03:43:07 <pikhq> GPLed.
03:43:13 <bsmntbombdood> where?
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:44 <Razor-X> ;
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:53:24 <GregorR-L> Hah
03:53:48 * GregorR-L huggles bugg-E-goBot.
03:57:26 <bsmntbombdood> pikhq: 'well'?
03:59:20 <oerjan> i wondered if that meant _well_ or "well" :)
04:00:02 <bsmntbombdood> !!
04:00:06 <EgoBot> Huh?
04:00:12 <bsmntbombdood> !huh?
04:00:16 <EgoBot> Huh?
04:00:21 <oerjan> !Huh?
04:00:24 <EgoBot> Huh?
04:00:32 <oerjan> finally, an EgoBot quine!
04:00:41 <bsmntbombdood> lol
04:00:49 <Razor-X> ;D
04:00:57 <Razor-X> !Huh?
04:01:00 <EgoBot> Huh?
04:01:05 <bsmntbombdood> hmmm
04:01:10 <bsmntbombdood> what's a brainfuck quine?
04:01:14 <Razor-X> ! !Huh
04:01:15 <bsmntbombdood> other than the obvious
04:01:16 <EgoBot> Huh?
04:01:40 <oerjan> very long i presume
04:01:48 <Razor-X> I posted my Forth quine earlier.
04:02:55 <Razor-X> CR TIB #TIB @ TYPE CR
04:03:02 <pikhq> !bf ++++++++>++++[-<.>]
04:03:04 <EgoBot>
04:03:08 <bsmntbombdood> !bf ->+>+++>>+>++>+>+++>>+>++>>>+>+>+>++>+>>>>+++>+>>++>+>+++>>++>++>>+>>+>++>++>+>>>>+++>+>>>>++>++>>>>+>>++>+>+++>>>++>>++++++>>+>>++>+>>>>+++>>+++++>>+>+++>>>++>>++>>+>>++>+>+++>>>++>>+++++++++++++>>+>>++>+>+++>+>+++>>>++>>++++>>+>>++>+>>>>+++>>+++++>>>>++>>>>+>+>++>>+++>+>>>>+++>+>>>>+++>+>>>>+++>>++>++>+>+++>+>++>++>>>>>>++>+>+++>>>>>+++>>>++>+>+++>+>+>++>>>>>>++>>>+>>>++>+>>>>+++>+>>>+>>++>+>++++++++++++++++++>>>>+>+>>>+>>++
04:03:15 <bsmntbombdood> +++++>>+>>++>+>>>>+++>>++++++>>>+>++>>+++>+>+>++>+>+++>>>>>+++>>>+>+>>++>+>+++>>>++>>++++++++>>+>>++>+>>>>+++>>++++>>+>+++>>>>>>++>+>+++>>+>++>>>>+>+>++>+>>>>+++>>+++>>>+[[->>+<<]<+]+++++[->+++++++++<]>.[+]>>[<<+++++++[->+++++++++<]>-.------------------->-[-<.<+>>]<[+]<+>>>]<<<[-[-[-[>>+<++++++[->+++++<]]>++++++++++++++<]>+++<]++++++[->+++++++<]>+<<<-[->>>++<<<]>[->>.<<]<<]
04:03:24 <bsmntbombdood> or not
04:03:27 * GregorR-L takes down EgoBot for a bit.
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:05:50 <bsmntbombdood> does EgoBot do input?
04:06:01 <GregorR-L> !help i
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:06:15 <bsmntbombdood> !bf >,[>,]<[.<]
04:06:19 <bsmntbombdood> !ps
04:06:21 <EgoBot> 3 bsmntbombdood: bf
04:06:23 <EgoBot> 4 bsmntbombdood: ps
04:06:33 <bsmntbombdood> !i 3 abcdefgh
04:06:40 <GregorR-L> !i 3 \n
04:07:13 <GregorR-L> Oh, that'll read 'til EOF :-P
04:07:16 <GregorR-L> !eof 3
04:07:21 <EgoBot> hgfedcba
04:07:26 <bsmntbombdood> cool
04:09:19 <bsmntbombdood> whoa leet
04:09:20 <bsmntbombdood> >++++++++++>>+<+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<]>.>[->[<++>-]<[>+
04:09:23 <bsmntbombdood> <-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>[-]>[-]++<<-[>+<-]]]]]]]]]]]+>>]<<]
04:10:14 <bsmntbombdood> !bf >++++++++++>>+<+[[+++++[>++++++++<-]>.<++++++[>--------<-]+<<]>.>[->[<++>-]<[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-[>[-]>[-]++<<-[>+<-]]]]]]]]]]]+>>]<<]
04:10:21 <bsmntbombdood> !ps
04:10:21 <EgoBot> 3 bsmntbombdood: bf
04:10:23 <EgoBot> 4 bsmntbombdood: ps
04:10:25 <EgoBot> 1
04:10:26 <bsmntbombdood> !kill 3
04:10:33 <EgoBot> Process 3 killed.
04:10:51 -!- EgoBot has quit (Excess Flood).
04:11:04 <bsmntbombdood> oops
04:11:07 <GregorR-L> Thanks :-P
04:11:11 <GregorR-L> It'll come back in a sec..
04:11:29 <GregorR-L> I can't seem to commit to the esofiles archive >_O
04:11:32 -!- EgoBot has joined.
04:16:47 <Razor-X> O_X
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:20:49 <GregorR-L> Actually, no time now.
04:20:51 <GregorR-L> I'll try again later.
04:20:55 <GregorR-L> lol
04:21:13 <Razor-X> The old Republic of Esome has been overthrown. Long live Easar!
04:21:32 * GregorR-L disapperates.
04:21:40 -!- GregorR-L has quit ("Leaving").
04:59:49 -!- thematrixeatsyou has joined.
05:00:23 <thematrixeatsyou> haro
05:00:35 <oerjan> hello
05:00:52 <thematrixeatsyou> been designing a CPU architecture
05:01:53 <oerjan> esoteric?
05:13:32 -!- Sgeo has quit (Read error: 54 (Connection reset by peer)).
05:13:49 <thematrixeatsyou> no, not really
05:13:53 <thematrixeatsyou> but hopefully fast
05:13:56 <thematrixeatsyou> it's a RISC
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:18:15 <thematrixeatsyou> to halt, you use a control register
05:28:15 -!- Arrogant has joined.
05:30:02 -!- oerjan has quit ("Good night.").
05:30:03 <thematrixeatsyou> hey arrogant
05:30:13 <thematrixeatsyou> i've been designing a RISC CPU
05:30:25 <Arrogant> Neat.
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:41:30 <Arrogant> build it in wireworld
05:41:45 <thematrixeatsyou> shit that'd be hard
05:41:50 <Arrogant> yeah
05:41:51 <Arrogant> it would
05:42:14 <thematrixeatsyou> it's mainly the prob of implementing ROM/RAM
05:43:44 <Arrogant> ROM isn't so bad
05:43:54 <Arrogant> RAM looks terrible
05:45:06 <thematrixeatsyou> i know of a method of doing RAM
05:45:18 <thematrixeatsyou> besides, a wireworld computer has already been made
05:45:45 <thematrixeatsyou> . .
05:45:47 <thematrixeatsyou> .....
05:45:51 <thematrixeatsyou> . .
05:45:52 <Arrogant> yeah
05:45:52 <Arrogant> but
05:45:55 <thematrixeatsyou> .. ..
05:45:56 <Arrogant> make a COOLER one
05:45:56 <thematrixeatsyou> ...
05:46:02 <Arrogant> make a brainfuck interpreter in wireworld
05:46:07 <Arrogant> THAT would be hardcore
05:46:09 <thematrixeatsyou> now that'd be nice
05:51:53 <thematrixeatsyou> done bugger all and i already need a cross
05:52:09 <thematrixeatsyou> it's gonna use trusty 6-cycle logic ;)
05:52:41 <thematrixeatsyou> afk food
05:54:12 <Arrogant> 6-cycle ftw
06:09:02 <thematrixeatsyou> btk, just note i'm doing my homework at the same time
06:14:04 <thematrixeatsyou> how old are you arrogant? im 15
06:14:12 <Arrogant> 18
06:14:15 <thematrixeatsyou> first year of NCEA, it's a bitch
06:14:31 -!- Razor-X has quit (Read error: 110 (Connection timed out)).
06:14:32 <thematrixeatsyou> what are high school exams like where you are?
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:01 <Arrogant> I just had AP to deal with :)
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:25 <thematrixeatsyou> ok, now onto maths
06:23:55 <thematrixeatsyou> excellence questions are the ultimate bitch, yoiu have to explain it as if the examiners were 10-year-olds
06:24:13 <thematrixeatsyou> *
06:25:21 <thematrixeatsyou> The school hall has 31 rows of seating.
06:25:31 <thematrixeatsyou> The hall can seat a maximum of 630 people.
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:22 <thematrixeatsyou> Show your working
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:15 <thematrixeatsyou> w + n = 31
06:29:15 <thematrixeatsyou> 24w + 18n = 630
06:29:22 <Razor-X> That's an.... excellence question?
06:29:26 <Razor-X> ......
06:30:01 <thematrixeatsyou> -18w - 18n = 31 * -18
06:30:02 <thematrixeatsyou> = -558
06:31:08 <thematrixeatsyou> combine:
06:31:08 <thematrixeatsyou> 24w - 18w + 18n - 18n = 630-558
06:31:08 <thematrixeatsyou> 24w - 18w = 72
06:31:49 <thematrixeatsyou> 6w = 72
06:31:49 <thematrixeatsyou> w = 72/6
06:31:49 <thematrixeatsyou> = 12
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:19 <thematrixeatsyou> hi gregor
06:32:24 <thematrixeatsyou> just doing homework
06:32:35 <Razor-X> Incredibly incredibly easy homework.
06:33:03 <thematrixeatsyou> w + n = 12 + n = 31
06:33:03 <thematrixeatsyou> n = 31 - 12
06:33:03 <thematrixeatsyou> = 19
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:24 <thematrixeatsyou> So there are 19 rows with 18 seats.
06:33:35 <Razor-X> Baffling.
06:33:47 <thematrixeatsyou> hey, this is 3rd year of high school.
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:15 <thematrixeatsyou> lucky you, you get some decent questions
06:34:16 <wooby> me too :\
06:34:24 <thematrixeatsyou> you seem to actually learn stuff
06:34:32 <Razor-X> We have Calculus here.
06:34:44 <thematrixeatsyou> we're doing the same shit from 2 to 11 years ago
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:31 <Razor-X> ?
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:38:22 <thematrixeatsyou> ok, there are 5 years of high school in new zealand.
06:38:26 <thematrixeatsyou> im in my 3rd
06:38:28 <Arrogant> Ah
06:38:30 <Arrogant> We have 4
06:38:47 <thematrixeatsyou> k. what year do you start proper exams?
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:05 <thematrixeatsyou> ok
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:41:06 <Arrogant> have*
06:41:18 <Arrogant> I took 3 AP exams
06:41:26 <Arrogant> got 5, 4, 3
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:54:00 <Razor-X> Fun.
06:57:08 <thematrixeatsyou> ERROR: anonfunc() requires faith
06:57:25 <GregorR> ...
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:13:18 <thematrixeatsyou> yays netsplit
07:31:27 <thematrixeatsyou> arrogant: finished the memory side of the tape on the interpreter, working on the pointer
07:31:36 <Arrogant> awesome
07:32:44 <Razor-X> In what language?
07:32:47 <Arrogant> now actually it can't be brainfuck
07:32:51 <Arrogant> no input
07:32:54 <Arrogant> not really
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:34:33 <Sillyman> Hello
07:34:37 <thematrixeatsyou> hi
07:34:45 <thematrixeatsyou> well, the ww-computer has an LCD display and it looks good
07:34:50 <Arrogant> yeah
07:34:55 <Arrogant> it is one complex beast
07:34:56 <thematrixeatsyou> -
07:35:13 <thematrixeatsyou> yep
07:35:17 <Arrogant> and it doesn't really support letters :)
07:35:31 <thematrixeatsyou> yah
07:35:37 <Sillyman> !help
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:27 <Arrogant> i know how the display works
07:36:27 <Razor-X> What is this?
07:36:32 <Arrogant> the conversions are what kill you
07:36:34 <Arrogant> wireworled
07:36:34 <thematrixeatsyou> then LCD = Liquid Crystal Display: i said Liquid Crystal Display Display
07:36:36 <Arrogant> wireworld*
07:36:37 <Razor-X> Aha.
07:37:00 <Arrogant> Gonna be a fun chunk of ROM
07:37:08 <thematrixeatsyou> shit
07:37:29 <Arrogant> I think someone should go through the trouble of just making a display that could do Hello, world!
07:37:50 <RodgerTheGreat> hm
07:37:56 <thematrixeatsyou> if i use 5x7 dot characters, that'd be 35 x 256 blocks
07:38:07 <thematrixeatsyou> using one of these lcds:
07:38:12 <thematrixeatsyou> ---
07:38:14 <thematrixeatsyou> | |
07:38:18 <thematrixeatsyou> oops
07:38:19 <thematrixeatsyou> ---
07:38:22 <thematrixeatsyou> |\ /|
07:38:25 <Razor-X> Where are the Wireworld rules?
07:38:25 <thematrixeatsyou> - -
07:38:28 <thematrixeatsyou> |/ \|
07:38:30 <thematrixeatsyou> ---
07:38:39 <RodgerTheGreat> you'd probably want to make a bitstream decoder that could handle a simple character set
07:38:40 <thematrixeatsyou> that's wrong too
07:38:51 <RodgerTheGreat> so... bigass lookup table.
07:39:29 <thematrixeatsyou> http://en.wikipedia.org/wiki/Wireworld_(CA)
07:39:32 <thematrixeatsyou> http://pages.prodigy.net/nylesheise/wireworld.html
07:39:36 <thematrixeatsyou> rules and gates
07:40:13 <RodgerTheGreat> this is really an incredible machine: http://www.quinapalus.com/wires11.html
07:40:28 <Arrogant> yes it is
07:40:28 <RodgerTheGreat> as I've said before, I'd be fascinated to code for it.
07:40:43 <RodgerTheGreat> an elegant RISC implementation.
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:42:20 <RodgerTheGreat> well, it's a very flexible, modular numeric display.
07:42:38 <RodgerTheGreat> text I/O is less important than one might think.
07:44:39 <thematrixeatsyou> yah
07:44:57 <thematrixeatsyou> that's the one im talking about
07:46:04 <thematrixeatsyou> shit i never knew it was a prime number finder
07:46:08 <thematrixeatsyou> so damn slow though
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:26 <RodgerTheGreat> what the hell do you expect?
07:46:43 <RodgerTheGreat> if electrons moved that slowly, that's how electronics would be.
07:47:14 <thematrixeatsyou> yah
07:47:31 <thematrixeatsyou> i didn't know that it executed from the RAM
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:48:31 <RodgerTheGreat> http://www.zen6741.zen.co.uk/quinapalus/ww800x600.gif
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:04 <thematrixeatsyou> yep
07:52:23 <RodgerTheGreat> as I said, the wireworld computer is a beautiful, elegant machine.
07:52:57 <thematrixeatsyou> :D
07:55:29 <RodgerTheGreat> what do you think of it, Razor-X?
07:56:54 <Razor-X> It seems... odd, heh.
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:00 <Razor-X> Yeah.
07:58:29 <Razor-X> s/incredibly/incredibl/
07:58:42 <RodgerTheGreat> yes- wireworld simulates a form of electrical flow
07:58:47 <Razor-X> s/incredibl/incredible/
07:58:52 <RodgerTheGreat> haha
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:39 <RodgerTheGreat> kinda both
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:00:26 <RodgerTheGreat> ... makes me think of a cray, for some reason. :)
08:00:31 <Razor-X> Heh.
08:01:08 <RodgerTheGreat> the displays are clever
08:02:21 <thematrixeatsyou> the binary adders I call "OUT" adders because it looks like they spell "OUT"
08:02:30 <thematrixeatsyou> http://www.quinapalus.com/wires8.html
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:03:08 <RodgerTheGreat> heh
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:05:18 <RodgerTheGreat> fascinating
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:06 <thematrixeatsyou> not that easy to extend
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:30 <thematrixeatsyou> nice
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:08:31 <thematrixeatsyou> gnight
08:09:16 <thematrixeatsyou> shit that is late at your end
08:10:17 <thematrixeatsyou> it looks very cool when you make the wire invisible
08:14:25 <Sillyman> I would imagine...
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:28:09 <thematrixeatsyou> hmm, good idea
08:40:23 -!- lindi- has quit (Remote closed the connection).
08:40:31 -!- lindi- has joined.
08:45:02 <thematrixeatsyou> gotta go get some zzz, gnight
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:43 <nooga> wooo
13:55:49 -!- pgimeno has joined.
13:56:00 -!- anders has joined.
13:56:04 <nooga> what an emptiness
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:02:06 <nooga> ABCDEF xD
14:02:11 <nooga> great idea
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:03:29 <nooga> %/
15:25:18 <nooga> am I transparent? ;/
15:55:46 -!- ihope has joined.
16:22:56 -!- jix has joined.
16:25:00 <nooga> hi hal a.k.a jix
16:29:05 <jix> nah i don't know a hal quote right now
16:29:08 <jix> that's bad
16:30:06 <nooga> ;/
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:31:31 <RodgerTheGreat> 'morning, everyone.
16:32:30 <nooga> hi RTG
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:18 <nooga> oh
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:37:29 <nooga> omfg
16:37:36 <nooga> hahaha
16:37:39 <jix> what?
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.
17:25:13 <lament> OMMMMMMMMMM
17:53:58 <wooby> hio
20:21:54 -!- ihope_ has joined.
20:38:09 -!- ihope has quit (Read error: 110 (Connection timed out)).
20:57:27 -!- CakeProphet has joined.
20:57:54 * CakeProphet 's head is about to explode.
21:00:15 -!- Sgeo has joined.
21:03:55 -!- kipple_ has joined.
21:05:33 * ihope_ re-summons GregorR
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:09 <RodgerTheGreat> hm
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"
21:39:52 <RodgerTheGreat> heh. DS9K-style nasal demons.
21:48:35 <SimonRC> yup
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:53:25 <Razor-X`> IRP?
23:53:40 <Razor-X`> EsoWiki has the info?
23:54:03 <lament> Razor-X`: please add 1 and 1
23:54:08 <Razor-X`> 2
23:54:12 <lament> thank you.
23:54:22 <Razor-X`> Yes!
23:54:27 <Razor-X`> Am I turing complete now?!
23:54:49 <pikhq> Razor-X`: Please interprete the following Brainfuck code: ,[.,]
23:54:51 <lament> yes.
23:55:14 <xor> !bf ,[.,]
23:55:28 <Razor-X`> WOOHOO!
23:55:35 <xor> !ps
23:55:37 <EgoBot> 1 xor: ps
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:49 <xor> !eof 1
23:55:50 <pikhq> You're not Turing complete.
23:55:59 <Razor-X`> Why?
23:56:07 <pikhq> You didn't interpret the code.
23:56:15 <Razor-X`> No, I didn't. I intepreteed it.
←2006-11-01 2006-11-02 2006-11-03→ ↑2006 ↑all