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]