--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/paste/paste.9922	Wed Mar 06 02:20:58 2013 +0000
@@ -0,0 +1,301 @@
+2006-12-29.txt:20:42:41: -!- ehird has joined #esoteric.
+2006-12-29.txt:20:43:09: -!- ehird has parted #esoteric (?).
+2007-05-14.txt:16:48:38: -!- ehird` has joined #esoteric.
+2007-05-14.txt:16:49:00: <ehird`> i honestly think my language may be worse than malbolge
+2007-05-14.txt:16:49:05: <ehird`> ((len*(index>1?index*index:50))+chr) % 50 <-- this is just insane
+2007-05-14.txt:16:49:43: <ehird`> oh yes, and the fact that the middle opcode is evaluated first, then the last, then the rest
+2007-05-14.txt:16:51:36: <ehird`> that's just the interpreter source coe
+2007-05-14.txt:16:51:38: <ehird`> *code
+2007-05-14.txt:16:51:38: <ehird`> well
+2007-05-14.txt:16:51:41: <ehird`> the decryption part
+2007-05-14.txt:16:52:09: <ehird`> what?
+2007-05-14.txt:16:52:33: <ehird`> that code is valid in many languages
+2007-05-14.txt:16:53:06: <ehird`> (((len * (index > 1 ? index * index : 50)) + chr) % 50
+2007-05-14.txt:16:53:10: <ehird`> not that hard to decipher
+2007-05-14.txt:16:54:05: <ehird`> .... ternary operator....
+2007-05-14.txt:16:54:20: <ehird`> it's (if index > 1 then index * index else 50)
+2007-05-14.txt:16:58:52: * ehird` pasted http://pastie.textmate.org/61475
+2007-05-14.txt:16:58:58: <ehird`> this program should print "a" and a newline
+2007-05-14.txt:17:42:56: <ehird`> okay, my interpreter is broken
+2007-05-14.txt:17:43:14: <ehird`> "Invalid decoded opcode 54 at 1 (SyntaxError)", yet my smash-bricks-at-decoder-to-get-program program says its ok
+2007-05-14.txt:18:19:36: * ehird` pasted http://pastie.textmate.org/61490
+2007-05-14.txt:18:19:42: <ehird`> even I can't figure out how that works
+2007-05-14.txt:18:19:46: <ehird`> hmm
+2007-05-14.txt:18:19:48: <ehird`> pastie messed it up
+2007-05-14.txt:18:19:53: <ehird`> it's bigger than that in actuality
+2007-05-14.txt:21:40:24: <ehird`> "this language should be called eyefuck if it is supposed to actually look like that."
+2007-05-14.txt:21:40:26: <ehird`> close, close..
+2007-05-14.txt:23:45:20: <ehird`> you don't have to link to a lyrics page
+2007-05-14.txt:23:45:35: * ehird` would recognize those anywhere
+2007-05-14.txt:23:47:17: <ehird`> with your powers combined, i am captain ge...ahem
+2007-05-14.txt:23:48:59: <ehird`> To be honest, a lot of people holding the "asperger's" badge do it because they "dont fit in lol" and are self-diagnosed
+2007-05-14.txt:23:49:41: <ehird`> i'm aware, having being diagnosed myself years ago :)
+2007-05-14.txt:23:51:24: <SimonRC> ehird`: more constructively, could you recommend other bands to me?  I feel I need to actually acuire some music.
+2007-05-14.txt:23:52:04: <ehird`> *cough* bittorr COUGH ugh COUGH aaa COUGH COUGH CHOKE
+2007-05-14.txt:23:54:10: <ehird`> people would have you believe that prison is school
+2007-05-14.txt:23:54:12: <ehird`> :P
+2007-05-14.txt:23:55:33: <ehird`> fellow geeks? in a public school?
+2007-05-14.txt:23:55:42: <ehird`> you must be kidding me
+2007-05-14.txt:23:55:46: <SimonRC> ehird`: that means something different here...
+2007-05-14.txt:23:56:32: <ehird`> i know what a grammar school is, SimonRC ;)
+2007-05-14.txt:23:57:17: * ehird` is in .uk
+2007-05-14.txt:23:57:29: * ehird` mixes .uk-isms and .us-isms after a while by mistake
+2007-05-15.txt:00:15:16: <ehird`> what's a good way to determine if a language is turing complete or not?
+2007-05-15.txt:00:15:35: <ehird`> heh
+2007-05-15.txt:00:15:39: <ehird`> what fun that will be.
+2007-05-15.txt:00:15:49: <lament> ehird`: it's not hard
+2007-05-15.txt:00:15:58: <lament> ehird`: there's several popular options for this
+2007-05-15.txt:00:16:21: <ehird`> brainfuck probably the easiest.
+2007-05-15.txt:00:32:18: <ehird`> j    lccccccccc.n!
+2007-05-15.txt:00:32:18: <ehird`>      k^Newline.
+2007-05-15.txt:00:32:18: <ehird`> l:10-?
+2007-05-15.txt:00:32:19: <ehird`>      ccccccccccccccc.n!
+2007-05-15.txt:00:32:19: <ehird`>      ^Not a newline. 
+2007-05-15.txt:00:32:19: <ehird`> mwaha
+2007-05-15.txt:00:32:21: <ehird`> er. flood.
+2007-05-15.txt:00:38:17: -!- ehird` has quit ().
+2007-05-15.txt:19:05:25: -!- ehird` has joined #esoteric.
+2007-05-15.txt:19:05:45: <ehird`> http://esoteric.sange.fi/brainfuck/bf-source/prog/oobrain.b oh my go
+2007-05-15.txt:19:05:47: <ehird`> it's beautiful
+2007-05-15.txt:19:10:05: <ehird`> someone make BF++
+2007-05-15.txt:19:12:31: * ehird` wonders what INTERCAL++ would be called
+2007-05-15.txt:19:12:47: * ehird` honestly has no idea how to add one to a number and assign the var to it in intercal
+2007-05-15.txt:19:15:41: <SimonRC> ehird`: !!
+2007-05-15.txt:19:16:10: <ehird`> SimonRC: !! at what?
+2007-05-15.txt:19:16:12: <ehird`> OOP in brainfuck?
+2007-05-15.txt:19:18:12: <ehird`> no, i didn't
+2007-05-15.txt:19:18:16: <ehird`> it was written in 2003
+2007-05-15.txt:19:20:01: <ehird`> mod_bf OOP framework? ;;)
+2007-05-15.txt:19:22:53: <ehird`> you fit libraries to your code, frameworks fit your code to them
+2007-05-15.txt:19:27:00: * ehird` pasted http://pastie.textmate.org/61810
+2007-05-15.txt:19:27:05: <ehird`> worse than befunge, methinks..
+2007-05-15.txt:19:28:22: <ehird`> "2d"
+2007-05-15.txt:19:28:23: <ehird`> mine
+2007-05-15.txt:19:28:32: <ehird`> a horridly morphed 2d language
+2007-05-15.txt:19:29:10: <ehird`> yes
+2007-05-15.txt:19:29:12: <ehird`> vi(1)
+2007-05-15.txt:19:29:51: <ehird`> close
+2007-05-15.txt:19:30:11: <ehird`> : is "get a character of input and push its ascii value to the stack"
+2007-05-15.txt:19:30:20: <ehird`> but the rest is correct
+2007-05-15.txt:19:30:31: <ehird`> yes
+2007-05-15.txt:19:30:42: <ehird`> the numbers
+2007-05-15.txt:19:30:49: <ehird`> it basically walks forward until it stops finding digits.
+2007-05-15.txt:19:30:57: <ehird`> - pops two numbers off the stack, subtracts them, and pushes the result
+2007-05-15.txt:19:31:19: <ehird`> nope
+2007-05-15.txt:19:31:32: <ehird`> < swaps two items on the stack
+2007-05-15.txt:19:31:39: <ehird`> [1,2,3] < results in [1,3,2]
+2007-05-15.txt:19:31:54: <ehird`> why i do that is revealed when you figure out what c does
+2007-05-15.txt:19:32:10: <ehird`> it /does/, but that's not used here
+2007-05-15.txt:19:32:45: <ehird`> a character. c pushes the character below itself as an ascii value
+2007-05-15.txt:19:32:58: <ehird`> which i suspect could be used in quines if going downwards.
+2007-05-15.txt:19:33:16: <ehird`> you see, . the printer, since everything on the stack is just a number, can't tell where the string starts
+2007-05-15.txt:19:33:22: <ehird`> so i just make it stop when it finds ^ ;)
+2007-05-15.txt:19:33:30: <ehird`> (^, $ - regexp start/end of line)
+2007-05-15.txt:19:34:16: <ehird`> heh
+2007-05-15.txt:19:34:41: <ehird`> it's not wtf-inspiring though :)
+2007-05-15.txt:19:34:55: <ehird`> i'm considering making the implementation of ? replace itself with j or h depending on the condition, then going back one
+2007-05-15.txt:19:35:07: <ehird`> and it does, but i've realised it shouldn't 
+2007-05-15.txt:19:35:11: <ehird`> as then i can't print the character
+2007-05-15.txt:19:35:16: <ehird`> thanks, i was  trying to fix that bug!
+2007-05-15.txt:19:36:11: <ehird`> tradition? this is an esolang, is it not? :)
+2007-05-15.txt:19:37:27: <ehird`> awkward languages are the only fun esoteric ones ;)
+2007-05-15.txt:19:39:28: <ehird`> oh fine
+2007-05-15.txt:19:42:34: * ehird` pasted http://pastie.textmate.org/61817
+2007-05-15.txt:19:42:39: <ehird`> hmmm/.. it's hanging after two lines
+2007-05-15.txt:19:42:46: <ehird`> god knows why it even DIES on two lines
+2007-05-15.txt:20:00:42: <SimonRC> ehird`: I think you are mixing up your l with your 1
+2007-05-15.txt:20:06:21: <ehird`> SimonRC: no
+2007-05-15.txt:20:06:31: <ehird`> ? moves up or down, it doesn't change the direction of execution
+2007-05-15.txt:20:07:19: <ehird`> i add 10 because i had subtracted it previously
+2007-05-15.txt:20:07:20: <ehird`> oh wait
+2007-05-15.txt:20:07:22: <ehird`> that's on another copy
+2007-05-15.txt:20:14:02: <ehird`> (C++)-- has no seq points, it is undefined.
+2007-05-15.txt:20:14:16: <ehird`> Possible solution: Seperate the expression into multiple statements.
+2007-05-15.txt:20:14:26: <ehird`> (at c.c, line 4)
+2007-05-15.txt:20:14:41: * ehird` reads too many compiler errors
+2007-05-15.txt:20:18:02: <ehird`> it is wrong
+2007-05-15.txt:20:18:12: <ehird`> x++ is an lvalue
+2007-05-15.txt:20:18:17: <ehird`> e.g. *(ptr++) = 2
+2007-05-15.txt:20:18:34: <ehird`> int C = 0; (C++)--; is undefined, but it probably results in C being 0
+2007-05-15.txt:20:26:04: <ehird`> coatgrinder: undefined.
+2007-05-15.txt:20:26:11: <ehird`> you just understand it as your compiler does.
+2007-05-15.txt:20:26:32: <ehird`> int i = 15; i = ++i + ++i should be 17 if your compiler is worth its salt
+2007-05-15.txt:20:26:45: <ehird`> it translates to int i = 15; increment i; increment i; i = i + i
+2007-05-15.txt:20:26:52: <ehird`> otherwise, it uses a tmp variable and that's slower.
+2007-05-15.txt:20:29:24: <ehird`> correct
+2007-05-15.txt:20:30:49: <ehird`> having it explode would be correct
+2007-05-15.txt:20:30:54: <ehird`> so would having it cry
+2007-05-15.txt:20:35:48: <ehird`> hmm
+2007-05-15.txt:20:35:55: <ehird`> a language entirely made out of the letter Q
+2007-05-15.txt:20:36:50: <ehird`> QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
+2007-05-15.txt:20:40:08: <ehird`> i'm making it basically http://esoteric.voxelperfect.net/wiki/BF_instruction_minimalization but depending on a magical counter :P
+2007-05-15.txt:20:47:50: <ehird`> you got cut off
+2007-05-15.txt:20:48:14: <ehird`> if the standard says it's unspecified, the compiler writers SHOULDN'T bother messing around with making it work on stupid CPUs
+2007-05-15.txt:20:50:19: * ehird` pasted http://pastie.textmate.org/61834
+2007-05-15.txt:20:50:23: <ehird`> somebody want to prove that's as turing-complete as BF? :)
+2007-05-15.txt:20:50:36: <ehird`> hmmm
+2007-05-15.txt:20:50:41: * ehird` pasted http://pastie.textmate.org/61835
+2007-05-15.txt:20:50:43: <ehird`> with that change it should be
+2007-05-15.txt:20:51:39: <ehird`> - can be + 127 times, and > can be ->, and + can be +<
+2007-05-15.txt:22:04:56: -!- ehird` has quit (Remote closed the connection).
+2007-05-15.txt:22:19:40: -!- ehird` has joined #esoteric.
+2007-05-15.txt:23:43:30: -!- ehird` has quit ().
+2007-05-16.txt:16:32:20: -!- ehird` has joined #esoteric.
+2007-05-16.txt:17:50:55: -!- ehird` has quit (Read error: 104 (Connection reset by peer)).
+2007-05-16.txt:17:52:08: -!- ehird` has joined #esoteric.
+2007-05-16.txt:18:18:57: <ehird`> hoo
+2007-05-16.txt:23:33:21: -!- ehird` has quit ().
+2007-05-17.txt:01:55:55: -!- ehird` has joined #esoteric.
+2007-05-17.txt:02:35:14: -!- ehird` has quit ().
+2007-05-17.txt:17:37:46: -!- ehird` has joined #esoteric.
+2007-05-17.txt:19:34:31: -!- ehird` is now known as NOT-ehird`.
+2007-05-17.txt:22:41:31: -!- NOT-ehird` has quit (Read error: 54 (Connection reset by peer)).
+2007-05-17.txt:22:42:42: -!- NOT-ehird` has joined #esoteric.
+2007-05-18.txt:00:10:36: -!- NOT-ehird` has quit ().
+2007-05-18.txt:15:03:14: -!- NOT-ehird` has joined #esoteric.
+2007-05-18.txt:17:23:10: -!- NOT-ehird` has quit (Remote closed the connection).
+2007-05-24.txt:22:13:57: -!- ehird` has joined #esoteric.
+2007-05-24.txt:22:14:24: <ehird`> Is there a word for when you're designing an esolang but it turns out it's actually quite pleasant to program in and hey, this is actually a usable, real language?
+2007-05-24.txt:22:14:28: <ehird`> if not there should be
+2007-05-24.txt:22:19:42: <ehird`> guess not
+2007-05-24.txt:22:30:51: <ehird`> in the context of "yay i actually wrote a useful language, oh time to reimplement all my software in it" or just "yay"
+2007-05-24.txt:22:34:10: <lament> ehird`: 'fuck'
+2007-05-24.txt:22:35:13: <ehird`> lament: in the context of "fuck now i don't get esoteric hell" or just "fuck"
+2007-05-24.txt:22:39:39: <ehird`> factorial = dup 1 > [dup 1 - factorial *] [pop 1] if ;; <-- well, when i said "non-esoteric", I didn't mean "easy"...
+2007-05-24.txt:22:39:53: <ehird`> hmm, make that just 1 -
+2007-05-24.txt:22:40:04: <SimonRC> ehird`: language?
+2007-05-24.txt:22:40:20: <ehird`> SimonRC: TheLanguageThatWasMeantToBeEsotericButIsNowActuallyQuiteUseful
+2007-05-24.txt:22:40:28: <ehird`> stack-based, functional.
+2007-05-24.txt:22:40:42: <ehird`> it does
+2007-05-24.txt:22:40:49: <ehird`> not a downside :)
+2007-05-24.txt:22:41:41: <ehird`> factor is cool looking
+2007-05-24.txt:22:41:47: <ehird`> haven't actually used it tho
+2007-05-24.txt:22:43:16: <ehird`> hmmm... i don't think TheLa... will have that in its implementation - well, the self-hosted one i guess :)
+2007-05-24.txt:22:43:38: * ehird` is putting off implementing it because of the syntax
+2007-05-24.txt:22:43:45: <ehird`> i guess the syntax isn't too bad though
+2007-05-24.txt:22:44:04: <ehird`> "str", [lambda], X = Y ;;
+2007-05-24.txt:22:44:06: <ehird`> and that's about it
+2007-05-25.txt:00:15:26: <ehird`> hmm
+2007-05-25.txt:00:15:31: <ehird`> i don't even have to implement scoping
+2007-05-25.txt:00:15:47: <ehird`> no nested "operator functions" (non-[lambda]-pushed-to-stack functions that is)
+2007-05-25.txt:00:15:51: <ehird`> just a hash table
+2007-05-25.txt:00:17:09: <ehird`> no - just a stack-based, functional language
+2007-05-25.txt:00:17:13: <ehird`> so - evil
+2007-05-25.txt:00:19:03: <ehird`> factorial = dup 1 > [dup 1 - factorial *] [pop 1] if ;;
+2007-05-25.txt:00:19:03: <ehird`> :)
+2007-05-25.txt:00:19:22: <SimonRC> ehird`: no
+2007-05-25.txt:00:19:29: <ehird`> SimonRC: no what
+2007-05-25.txt:00:19:52: <ehird`> ihope: monads? pah! real functional programmers MANUALLY APPLY IO
+2007-05-25.txt:00:20:09: <ehird`> OK, so they get their runtime system to do it for them, but...
+2007-05-25.txt:00:20:21: <ehird`> SimonRC: well - [lambda] forms aren't implicitly called
+2007-05-25.txt:00:20:32: <SimonRC> ehird`: yes, that's my point
+2007-05-25.txt:00:20:37: <ehird`> 2 [dup] --> 2 [dup], instead of 2 [dup] -> 2 2
+2007-05-25.txt:00:20:42: <ehird`> "call" evaluates them
+2007-05-25.txt:00:20:45: <ehird`> 2 [dup] call --> 2 2
+2007-05-25.txt:00:21:05: <ehird`> hrm
+2007-05-25.txt:00:21:10: <ehird`> OK.. but I like the ;;
+2007-05-25.txt:00:21:22: <ehird`> it's ocamlish :P
+2007-05-25.txt:00:21:32: <ehird`> lament: joy uses .
+2007-05-25.txt:00:21:33: <ehird`> plus it's less ugly with multiple lines:
+2007-05-25.txt:00:21:41: * ehird` pasted http://pastie.textmate.org/64416
+2007-05-25.txt:00:23:54: <ehird`> scopes? this is a stack-based language ;)
+2007-05-25.txt:00:24:03: <ehird`> the only scope i need is the global scope to store self-evaluating functions
+2007-05-25.txt:00:25:43: <ehird`> hehe
+2007-05-25.txt:00:26:00: <ehird`> i wonder if i'll be able to handle reverse-polishness to actually write some programs in the language
+2007-05-25.txt:00:26:17: <ehird`> ... probably. i can do some forth.
+2007-05-25.txt:00:46:16: <ehird`> well that parser wasn't hard
+2007-05-25.txt:00:46:23: <ehird`> just have to make it convert X = Y ;; to a hashtable {X => Y}
+2007-05-25.txt:00:56:41: <ehird`> .... which is the hardest part
+2007-05-25.txt:01:00:54: <ehird`> it works
+2007-05-25.txt:01:00:56: <ehird`> yippee
+2007-05-25.txt:01:30:05: -!- ehird` has quit ().
+2007-05-25.txt:22:44:33: -!- ehird` has joined #esoteric.
+2007-05-25.txt:23:10:56: * ehird` wonders why 99bob is doing 99->-98
+2007-05-25.txt:23:15:34: <ehird`> => = dup dup > == or ;;
+2007-05-25.txt:23:23:26: * ehird` pasted http://pastie.textmate.org/64693
+2007-05-25.txt:23:23:28: <ehird`> that's the 99bob program
+2007-05-25.txt:23:23:34: * ehird` pasted http://pastie.textmate.org/64694
+2007-05-25.txt:23:23:49: <ehird`> this is what => etc are defined as
+2007-05-25.txt:23:23:52: <ehird`> the rest is pretty obvious
+2007-05-25.txt:23:23:54: <ehird`> it currently tries to pop from an empty stack in swap
+2007-05-25.txt:23:23:57: <ehird`> L/
+2007-05-25.txt:23:23:58: <ehird`> *:/
+2007-05-25.txt:23:26:49: <ehird`> err
+2007-05-25.txt:23:26:54: <ehird`> it works like this:
+2007-05-25.txt:23:27:00: <ehird`> true false
+2007-05-25.txt:23:27:03: <ehird`> false true (swapped)
+2007-05-25.txt:23:27:13: <ehird`> (false is...false, so run pop) true
+2007-05-25.txt:23:27:17: <ehird`> or::::
+2007-05-25.txt:23:27:19: <ehird`> false true
+2007-05-25.txt:23:27:22: <ehird`> true false (swapped)
+2007-05-25.txt:23:27:27: <ehird`> (true is true, so swap) false true
+2007-05-25.txt:23:27:29: <ehird`> (and pop) true
+2007-05-25.txt:23:27:35: <ehird`> [] is a lambda
+2007-05-25.txt:23:27:57: <ehird`> if pops off IFFALSE, IFTRUE, and COND... you can guess the rest
+2007-05-25.txt:23:28:10: <ehird`> oklopol: > pops twice and replaces it with true or false
+2007-05-25.txt:23:28:14: <ehird`> == does the same
+2007-05-25.txt:23:28:26: <ehird`> so you might have true false (>, not ==) or false true (==, not >)
+2007-05-25.txt:23:28:38: <ehird`> =>, of course, is eq-or-gt
+2007-05-25.txt:23:30:02: <ehird`> well, visualize what or does with the stacks [true, false], [false, true], [false, false] and [true, true] in your head, using these stack signatures:
+2007-05-25.txt:23:30:09: <ehird`> swap = a b -> b a
+2007-05-25.txt:23:30:14: <ehird`> pop = a b -> a
+2007-05-25.txt:23:30:30: <ehird`> if = c t f = result of calling t if c, else result of calling f
+2007-05-25.txt:23:30:45: <ehird`> well - in the core implementation
+2007-05-25.txt:23:30:49: <ehird`> its not hard to figure out what they do
+2007-05-25.txt:23:30:59: <ehird`> or = swap [swap pop] [pop] if ;;
+2007-05-25.txt:23:31:02: <ehird`> i pasted that
+2007-05-25.txt:23:31:07: <ehird`> yes
+2007-05-25.txt:23:31:15: <ehird`> it isn't self-hosting ;;)
+2007-05-25.txt:23:34:29: <ehird`> C T F if => is C true? if so, call T, otherwise call F
+2007-05-25.txt:23:34:32: <ehird`> but you know that now :)
+2007-05-25.txt:23:35:24: <ehird`> look how about i just put the impl online :)
+2007-05-25.txt:23:35:28: <ehird`> it's ruby though and very ugly
+2007-05-25.txt:23:35:49: <ehird`> and plenty of the examples i wrote when tired and are hopelessly wrong or just speculation like writing a daemon in it
+2007-05-25.txt:23:36:11: <oklopol> <ehird`> => = dup dup > == or ;; i mean this one
+2007-05-25.txt:23:36:17: <ehird`> right, what about it
+2007-05-25.txt:23:36:34: <ehird`> it's a definition
+2007-05-25.txt:23:36:37: <ehird`> FUNC = CODE ;;
+2007-05-25.txt:23:36:39: <ehird`> that defines =>
+2007-05-25.txt:23:37:14: <ehird`> ah i think it should be
+2007-05-25.txt:23:37:15: <ehird`> => = dup dup > swap swap == or ;;
+2007-05-25.txt:23:37:31: <ehird`> 1 1 -> 1 1 1 1 -> 1 1 false -> 1 false 1 -> false 1 1 -> false true -> true
+2007-05-25.txt:23:37:59: <ehird`> oops.
+2007-05-25.txt:23:38:12: <ehird`> i'm trying to get a b c d -> a b d c -> a d b c :)
+2007-05-25.txt:23:38:26: <ehird`> oklopol: which is why i do ==, then or
+2007-05-25.txt:23:38:36: <ehird`> so if == is true and > is false, true is returned
+2007-05-25.txt:23:39:05: <ehird`> hmm that dup is wrong yes
+2007-05-25.txt:23:39:11: <ehird`> i'm meaning 1 2 -> 1 2 1 2
+2007-05-25.txt:23:39:13: <ehird`> not 1 2 -> 1 2 2
+2007-05-25.txt:23:39:17: * ehird` fixes
+2007-05-25.txt:23:39:24: <ehird`> * 1 2 2 2
+2007-05-25.txt:23:40:23: <ehird`> hrm... i don't think a b c rot = b c a is selfhostedable...better ruby it
+2007-05-25.txt:23:41:53: <ehird`> programmable in the language itself, not its implementation :)
+2007-05-25.txt:23:42:04: <ehird`> <= = swap dup rot dup rot rot < rot swap == or ;;
+2007-05-25.txt:23:42:39: <ehird`> ugly :)
+2007-05-25.txt:23:43:00: <ehird`> anyway, what i mean about selfhostedable is - can i define rot using only pop/swap/etc
+2007-05-25.txt:23:43:05: <ehird`> or is it a "core" thing
+2007-05-25.txt:23:45:01: <ehird`> == bottles of beer on the wall, 
+2007-05-25.txt:23:45:01: <ehird`> == bottles of beer.
+2007-05-25.txt:23:45:02: <ehird`> Take one down, pass it around,
+2007-05-25.txt:23:45:02: <ehird`> ./core.rb:61:in `-': String can't be coerced into Fixnum (TypeError)
+2007-05-25.txt:23:45:07: <ehird`> i think i need to debug
+2007-05-25.txt:23:46:37: <ehird`> me too actually
+2007-05-25.txt:23:46:40: <ehird`> it's catchier
+2007-05-25.txt:23:47:13: <ehird`> "Equals equals bottles of beer on the wall, equals equals bottles of beer. Take one down, pass it around, core dot rb 61 in minus string can't be coerced into fixnum typeerror."
+2007-05-25.txt:23:48:34: <ehird`> equals is assign :P
+2007-05-25.txt:23:49:40: <ehird`> meh
+2007-05-25.txt:23:56:27: <ehird`> stack = ["swap", "dup", "rot", "dup", "rot", "rot", ">", "rot", "swap", "==", "==", "=="]
+2007-05-25.txt:23:56:27: <ehird`> wtf.
+2007-05-25.txt:23:56:33: <ehird`> that's all the function calls
+2007-05-25.txt:23:56:36: <ehird`> why isn't it...blarh
+2007-05-26.txt:00:18:11: <ehird`> i have one of those
+2007-05-26.txt:00:18:54: <ehird`> like 'X = X and X` = X?
+2007-05-26.txt:00:19:03: <ehird`> ah
+2007-05-26.txt:00:19:04: <ehird`> so
+2007-05-26.txt:00:19:15: <ehird`> 'X = X, X` = .... X is a function?
+2007-05-26.txt:00:19:49: <ehird`> ' == value
+2007-05-26.txt:00:19:57: <ehird`> lisp heritage must be respected ;)
+2007-05-26.txt:00:19:59: <ehird`> need some parens too!
+2007-05-26.txt:00:20:06: <ehird`> (cadr '(1 2 3))
+2007-05-26.txt:00:20:41: <ehird`> hey - that's a good idea, an anti-golf contest
+[too many lines; stopping]