←2006-08-21 2006-08-22 2006-08-23→ ↑2006 ↑all
00:09:44 <Razor-X> As of now the committee has confirmed the pool of challenges. We hope you will be pleasantly amused and challenged by our set of tasks. The competiton will begin in 52 minutes with the unveiling of the tasks.
00:10:04 <Razor-X> [/Official voice]
00:10:38 <RodgerTheGreat> you may now murmur and speculate amongst yourselves.
00:14:22 -!- CXI has quit (Connection timed out).
00:16:18 <GregorR-W> Um
00:16:24 <GregorR-W> Does the wiki page actually mention the dates?
00:16:31 <Razor-X> Yes.
00:16:47 <Razor-X> Thank you again Informed Committee Member.
00:17:23 <GregorR-W> I knew the dates, I just couldn't find them on the wiki page :-P
00:17:25 <GregorR-W> Now I see them.
00:17:33 <Razor-X> Good :P.
00:18:18 <pikhq> Schweet.
00:19:20 <Razor-X> Be prepared to get your mind blown with the awesome death-defying requirements we make of you.
00:19:48 <Razor-X> I'm sorry but, there are no DF interpreters involved.
00:19:59 <pikhq> Proving Malbolge Turing complete? :p
00:20:08 <Razor-X> Drat. He found out!
00:20:50 <GregorR-W> One of them is a web browser.
00:21:02 <GregorR-W> Another one is a reimplementation of Emacs.
00:21:07 <GregorR-W> The latter sort of usurps the former though.
00:21:08 <pikhq> MY EYES! MY BRAIN! MY SANITY!!!
00:21:17 <Razor-X> We also ask to make a C preprocessor.
00:21:19 <pikhq> One need only implement Elisp.
00:21:34 <ihope> You also need to implement a raytracer.
00:21:44 <Razor-X> You gave away the good one *sob*.
00:21:55 <pikhq> Jebus.
00:22:10 <GregorR-W> And then use the raytracer to reimplement DOOM.
00:22:23 <GregorR-W> (Preferably DOOM3-quality, but DOOM{1,2} accepted as well)
00:22:36 <Razor-X> You fiend you.
00:22:50 <ihope> And a roguelike. You must write a roguelike.
00:23:10 <pikhq> Well, a roguelike is much, much saner to do. . .
00:23:18 <pikhq> Still friggin' insane, but. . .
00:23:44 <ihope> Everybody must write every one of these in every language, or else be disqualified.
00:23:46 <ihope> Except Malbolge. You don't have to write a roguelike in Malbolge.
00:24:01 <Razor-X> Stop misleading them ihope. Malbolge is included too.
00:24:13 <ihope> It is?
00:24:14 <GregorR-W> Dude, CakeProphet ... you started the Wikipedia article on Human Cheese? wtf...
00:24:21 <Razor-X> Go and read the confirmation.
00:24:27 <CakeProphet> Yup that was me.
00:24:29 <ihope> I thought there was something that wouldn't have to be done in some language...
00:24:43 <Razor-X> It's weird that CakeProphet started that article. It's weirder that GregorR-W is reading it.
00:25:30 <Razor-X> I also suggest you get highly familiar with zlib ;)
00:25:38 <pikhq> Oh, dear lord.
00:25:42 <GregorR-W> Razor-X: I just clicked through links.
00:25:45 <pikhq> MY BRAIN!!!
00:25:51 <GregorR-W> Razor-X: I didn't search for Human Cheese, I clicked on CakeProphet's user page :P
00:25:56 <Razor-X> Is getting sexual-intecorsed? Yes.
00:26:00 <Razor-X> GregorR-W: Oh :P
00:26:03 <pikhq> Permission requested to code in Glass instead of Brainfuck.
00:26:08 <Razor-X> *intercoursed
00:26:16 <Razor-X> Nope. Glass isn't in this competition. Bub.
00:26:25 <GregorR-W> Glass is too high-level.
00:26:54 <Razor-X> Yeah. Bub.
00:27:30 <Razor-X> I wonder how they'll react to the extra-credit challenge.....
00:27:42 <Razor-X> Oh well. We'll have to see, won't we?
00:28:34 <Razor-X> Can't you feel the excitement in the synthetic air?!
00:29:03 <pikhq> Warning: If I do some Unlambda code, I'm liable to create some libraries in it *making* it high-level. :p
00:29:20 <Razor-X> Go ahead. That's fine by us.
00:29:39 <Razor-X> If you want to write Haskell in Unlambda and then write your program in Haskell, be my guest.
00:30:03 <CakeProphet> He should get extra points for doing that :D
00:30:36 <Razor-X> If the result turns out awful, we'll give him special points for doing something completely unrelated to the task and thusly creating a horrible entry with wasted effort.
00:30:56 <RodgerTheGreat> "special" points.
00:31:08 <pikhq> But what if I do something friggin' great?
00:31:09 <RodgerTheGreat> as in "special" olympics.
00:31:15 <pikhq> Oh, that would be normal. :p
00:31:20 <Razor-X> Then you get friggin' great points.
00:31:46 <Razor-X> You get points for what you do.
00:31:49 <RodgerTheGreat> special points != f.g. points.
00:31:51 <CakeProphet> I should sign up... even though I don't know how to code any of those.
00:32:03 <Razor-X> If you submit a BF program that looks like [+], we'll give you [+] points.
00:32:04 <RodgerTheGreat> go ahead, take a cracl.
00:32:13 <RodgerTheGreat> *crack.
00:32:22 <Razor-X> You have another 29 minutes left to register.
00:32:25 <GregorR-W> Razor-X: If it's for a bignum interp, that's infinite points :P
00:32:27 <pikhq> CakeProphet: HAve fun with it.
00:32:36 <CakeProphet> hmm... which language should I do?
00:32:38 <Razor-X> GregorR-W: Heh.
00:32:46 <pikhq> GregorR-W: Memory limited points, actually.
00:32:52 <GregorR-W> True
00:33:04 <ihope> I can remember infinity.
00:33:09 <CakeProphet> Which would you say is the most intuitive?
00:33:12 <ihope> I can also remember omega and aleph-null.
00:33:13 <CakeProphet> :D
00:33:14 <Razor-X> Next year let's add in a ``I put the EgoBot'' category.
00:33:17 <Razor-X> CakeProphet: BF?
00:33:25 <Razor-X> Omega is easy to remember, sheesh.
00:33:49 <ihope> It's only... THE SET OF ALL NATURAL NUMBERS!
00:33:50 <Razor-X> Where we download EgoBot's source and find ways to crash him.
00:34:05 <GregorR-W> Razor-X: I think pikhq does that already.
00:34:09 -!- kipple has quit (Read error: 110 (Connection timed out)).
00:34:12 <Razor-X> GregorR-W: Exactly.
00:34:18 <ihope> I forgot how to do it.
00:34:19 * EgoBot is not amused >:(
00:34:26 <ihope> !ps d
00:34:29 <EgoBot> 1 EgoBot: daemon cat reload
00:34:31 <EgoBot> 2 EgoBot: daemon EgoBot reload
00:34:33 <EgoBot> 3 ihope: ps
00:34:38 <Razor-X> !cat I eat babies.
00:34:41 <EgoBot> I eat babies.
00:34:41 <ihope> !EgoBot is not amused >:(
00:34:45 * EgoBot is not amused >:(
00:34:51 <ivan`> !ps d
00:34:55 <EgoBot> 1 EgoBot: daemon cat reload
00:34:57 <EgoBot> 2 EgoBot: daemon EgoBot reload
00:34:59 <EgoBot> 3 ivan`: ps
00:35:04 <ivan`> heh @ security
00:35:13 <GregorR-W> ivan`: There's no security hole there.
00:35:19 <EgoBot> This is a test.
00:35:25 * EgoBot is really ihope in disguise
00:35:28 <GregorR-W> ivan`: Well, there probably is, but not exposed by !ps d :-P
00:35:39 * EgoBot is actually the father of MalBolge.
00:36:07 * EgoBot is a good way of doing anonymous messages. Oh wait, GregorR has all the logs.
00:36:15 <EgoBot> Oooh. What does this button do?!
00:36:29 * EgoBot slaps EgoBot
00:36:31 <EgoBot> Let's all have conversations through EgoBot.
00:36:45 <EgoBot> 'k
00:36:49 <EgoBot> Great idea, GregorR!
00:37:03 <EgoBot> I'm GregorR? Cool!
00:37:11 <EgoBot> No, not cool in fact.
00:37:15 <EgoBot> Anonymity at your fingertips: EgoBot :P
00:37:21 <EgoBot> No, you're not GregorR, EgoBot is.
00:37:22 * CakeProphet signed up
00:37:35 <EgoBot> What language did you sign up for?
00:37:37 <EgoBot> You must be Razor-X.
00:37:40 <RodgerTheGreat> schizoid IRCBots. what will we create next...
00:37:41 <EgoBot> Damn, CakeProphet spoke without using EgoBot.
00:37:51 <EgoBot> Damn, noiw RodgerTheGreat spoke too!
00:38:01 <EgoBot> KILL!
00:38:05 <RodgerTheGreat> ...
00:38:15 * RodgerTheGreat is a non-conformist.
00:38:20 <CakeProphet> brainfuck
00:38:28 <RodgerTheGreat> woo
00:38:32 <CakeProphet> Although I should have signed up for Malbolge just for laughs.
00:38:41 <EgoBot> Yeah, that would've been ... yeah.
00:38:49 <RodgerTheGreat> if by "laughs" you mean "pain", then yes.
00:39:40 <CakeProphet> I tend to laugh when I get hurt.
00:39:42 <CakeProphet> So yes.
00:40:13 <EgoBot> /msg nickserv identify eq39rorw
00:40:34 <CakeProphet> >.>
00:40:35 <RodgerTheGreat> hm.
00:41:13 <EgoBot> Umm ... ignore that ... *changes password*
00:41:15 <EgoBot> I am me.
00:41:21 <EgoBot> That's as simple as can be.
00:41:23 <EgoBot> !undaemon cat
00:41:49 <EgoBot> I could get myself into an infinite loop if that would work.
00:42:07 <EgoBot> Duh
00:42:21 <EgoBot> !cat I'm commanding myself now.
00:42:25 <EgoBot> I'm commanding myself now.
00:42:29 <EgoBot> But it seems GregorR's bot isn't quite that easy to break.
00:42:46 * CakeProphet takes a crash course in brainfuck
00:42:51 <EgoBot> Oh am I?
00:43:05 <EgoBot> Good, I hope your studies are long and arduous.
00:43:19 <RodgerTheGreat> and a crash it will be...
00:43:24 <pikhq> !bf32 +[+[+].>]
00:43:37 <Razor-X> !ps
00:43:39 <EgoBot> 3 Razor-X: ps
00:43:48 <Razor-X> !help
00:43:48 <pikhq> Aaaw.
00:43:51 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
00:43:53 <GregorR-W> That's not going to do much ... output a 0 then quit.
00:43:53 <RodgerTheGreat> if you need a BF interpreter while they're joyriding Egobot, I can load mine up.
00:43:53 <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
00:44:02 <Razor-X> !help
00:44:05 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
00:44:07 <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
00:44:21 <pikhq> !bf64 -[-[-].]
00:44:24 <CakeProphet> !bf lol
00:44:29 <pikhq> !ps
00:44:31 <EgoBot> 3 pikhq: ps
00:44:40 <GregorR-W> pikhq: Sorry, it's optimized. [-] = set to 0
00:44:45 <pikhq> Shit.
00:44:46 <CakeProphet> !bf32 lol
00:44:50 <CakeProphet> !ps
00:44:51 <Razor-X> !help
00:44:53 <EgoBot> 3 CakeProphet: ps
00:44:55 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
00:44:57 <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
00:44:58 <GregorR-W> !bf64 -[->-<]
00:45:00 <GregorR-W> !ps
00:45:03 <EgoBot> 3 GregorR-W: ps
00:45:13 <GregorR-W> Damn, I didn't optimize that well, did I? :P
00:45:30 <CakeProphet> !bf64 >>>>>>---+++>>>>><<<<><><><><><_>+<_>+<_>+<_>+++++>>>>++>>+>++>+>+<>+>+<+>+<+>_<+>_<+><>_<_<_<_>_<+>_<+.
00:45:33 <EgoBot>
00:45:36 <CakeProphet> !ps
00:45:39 <EgoBot> 3 CakeProphet: ps
00:45:41 <pikhq> !bf64 -[-[-].-]
00:45:46 <pikhq> !ps
00:45:48 <EgoBot> 3 pikhq: bf64
00:45:49 <EgoBot> 4 pikhq: ps
00:45:52 <GregorR-W> There we go 8-D
00:45:52 <pikhq> :)
00:46:05 <Razor-X> !help
00:46:05 <Razor-X> What command is _, CakeProphet ?
00:46:05 <GregorR-W> Of course, that would work with !bf* :-P
00:46:07 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
00:46:09 <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
00:46:19 <CakeProphet> !bf64 >>>>>>---+++>>>>><<<<><><><><><_>+<_>+<_>+<_>+++++>>>>++>>+>++>+>+<>+>+<+>+<+>_<+>_<+><>_<_<_<_>_<+>_<++++-----+++++----+_--+_+_+++++[.]........-----+++
00:46:25 * CakeProphet is just typing in random shit.
00:46:33 <pikhq> !bf* -.
00:46:34 <Razor-X> Good job CakeProphet.
00:46:38 <Razor-X> You'll make a fine BF coder.
00:46:44 <Razor-X> !bf -.
00:46:46 <EgoBot>
00:46:48 <EgoBot>
00:46:51 <Razor-X> Yay.
00:46:53 <pikhq> Bravo.
00:46:58 <Razor-X> !bf 64 -.
00:47:02 <EgoBot>
00:47:07 <Razor-X> !bf 8 -.
00:47:10 <EgoBot>
00:47:13 <Razor-X> ....
00:47:19 <Razor-X> !bf [-.]
00:47:32 <Razor-X> !ps
00:47:35 <GregorR-W> !bf -[.-]
00:47:36 <EgoBot> 3 Razor-X: ps
00:47:38 <EgoBot> ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!
00:47:43 <GregorR-W> ^^
00:47:55 <Razor-X> Emacs froze up for a second and loaded Thai-Util :D.
00:48:17 <pikhq> !bf >>>>>+[+[+[+[+[+<-]<-]<-]<-]<-].
00:48:38 <pikhq> Why? No idea.
00:48:55 <Razor-X> !bf +[,.>+]
00:48:58 <Razor-X> !ps
00:49:02 <EgoBot> 3 Razor-X: bf
00:49:04 <EgoBot> 4 Razor-X: ps
00:49:09 <Razor-X> !i 3 blah
00:49:16 <GregorR-W> !i 3 \n
00:49:18 <EgoBot> blah
00:49:30 <Razor-X> Let's see how long it takes to memory overflow!
00:49:38 <CakeProphet> !bf >>>>>>>++>+>+>+>++>+>+>++>++>+>++>++>+++>+>+>>>+++>+>+>+>----->,-->++>[.][[.[.[.[.[.[.[.[.].].].].].].].].],+
00:49:40 <Razor-X> !i 3 Why don'cha add in an auto EOL, sheesh?\n
00:49:40 <pikhq> !bf64 -[-[-].-]
00:49:41 <pikhq> !bf64 -[-[-].-]
00:49:41 <pikhq> !bf64 -[-[-].-]
00:49:42 <pikhq> !bf64 -[-[-].-]
00:49:42 <pikhq> !bf64 -[-[-].-]
00:49:42 <EgoBot> Why don'cha add in an auto EOL, sheesh?
00:49:43 <GregorR-W> Razor-X: It won't.
00:49:45 <pikhq> !bf64 -[-[-].-]
00:49:47 <pikhq> !bf64 -[-[-].-]
00:49:49 <CakeProphet> !bf >>>>>>>++>+>+>+>++>+>+>++>++>+>++>++>+++>+>+>>>+++>+>+>+>----->,-->++>[.][[.[.[.[.[.[.[.[.].].].].].].].].],+
00:50:01 <CakeProphet> What exactly would that bit of code so?
00:50:08 <CakeProphet> do
00:50:13 <pikhq> Bull and shit.
00:50:13 <Razor-X> !i 3 I have no idea.
00:50:26 <EgoBot> And neither do I.
00:50:34 <Razor-X> !i 3 \n
00:50:46 <EgoBot> I have no idea.
00:51:03 <GregorR-W> !bf64 +[>+]
00:51:03 <pikhq> We need a !kill.
00:51:06 <EgoBot> realloc: Cannot allocate memory
00:51:10 <GregorR-W> pikhq: There IS a !kill >_<
00:51:23 <pikhq> We need a !kill EgoBot
00:51:32 <Razor-X> !i 3 さあ、祥子様で一勝に歩きたい :(\n
00:51:33 <GregorR-W> !kill pikhq
00:51:34 <EgoBot> さあ、祥子様で一勝に歩きたい :(
00:51:36 <EgoBot> No such process!
00:51:58 <pikhq> !eof 3
00:52:08 <CakeProphet> !ps
00:52:11 <EgoBot> 3 Razor-X: bf
00:52:12 <EgoBot> 4 CakeProphet: bf
00:52:14 <EgoBot> 5 CakeProphet: ps
00:52:15 <Razor-X> !bf +[.<+.>]
00:52:17 <EgoBot> 12 CakeProphet: bf
00:52:28 * GregorR-W killall egobfi
00:52:37 <EgoBot> <CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP><CTCP>
00:52:43 <CakeProphet> Oh dear.
00:52:52 <CakeProphet> EgoBot is sending me strand CTCP
00:52:54 <CakeProphet> s
00:52:56 <CakeProphet> strange
00:52:58 <Razor-X> Woaha.
00:53:04 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
00:53:05 <Razor-X> That was awesome!
00:53:10 <GregorR-W> God I hate you guys.
00:53:14 <CakeProphet> Unknown CTCP 0x010x010x010x010x040x010x050x010x010x010x080x01 ( ) from EgoBot
00:53:20 -!- EgoBot has joined.
00:53:31 <pikhq> !bf 0 Dimensifuck Brainfuck polyglot +^[+]v.X
00:53:39 <GregorR> !ps d
00:53:42 <EgoBot> 1 EgoBot: daemon EgoBot reload
00:53:43 <EgoBot> 2 EgoBot: daemon cat reload
00:53:45 <EgoBot> 3 GregorR: ps
00:54:51 <Razor-X> You are not worthy of any praise as a programmer of Esome if you cannot crash EgoBot.
00:54:57 <CakeProphet> !bf >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+++>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+++>>+>+>+>+>+>>+>>+>>+>>>+>+>+>+>+>+>++>>+>+....>>+>+>+>+>+>+>.>+>>+>+>+>.+>+>+>+>+>+++,>+>+>+.+>++>+>+>+>>+>+>+>>+>>++>+>>+>+>+>+>+>++++++++++{>>>>>+>+>+>+>+>+<+<+<+<+<+<>+>+>+>+>]
00:55:00 <CakeProphet> !ps
00:55:03 <EgoBot> 3 CakeProphet: ps
00:55:10 <CakeProphet> :(
00:55:14 <CakeProphet> That wasn't exciting.
00:55:27 <CakeProphet> You were supposed to process some sort of internet connection or do something else magical.
00:55:28 <GregorR-W> !kill 3
00:55:30 <EgoBot> Process 3 killed.
00:55:36 <Razor-X> !kill 10
00:55:37 <EgoBot> No such process!
00:55:42 <CakeProphet> !kill 9
00:55:43 <EgoBot> No such process!
00:55:46 <Razor-X> !kill You
00:55:47 <EgoBot> No such process!
00:55:53 <CakeProphet> !kill bill
00:55:56 <EgoBot> No such process!
00:56:05 <EgoBot> Yes there is!
00:56:13 <EgoBot> No such process!
00:56:15 <GregorR-W> VOLUME 2!!!
00:56:17 <EgoBot> Yes there is!
00:56:21 <CakeProphet> !bf >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+++>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+++>>+>+>+>+>+>>+>>+>>+>>>+>+>+>+>+>+>++>>+>+....>>+>+>+>+>+>+>.>+>>+>+>+>.+>+>+>+>+>+++,>+>+>+.+>++>+>+>+>>+>+>+>>+>>++>+>>+>+>+>+>+>++++++++++{>>>>>+>+>+>+>+>+<+<+<+<+<+<>+>+>+>+>]
00:56:24 <CakeProphet> !ps
00:56:26 <EgoBot> 3 CakeProphet: ps
00:56:27 <CakeProphet> !ps 3
00:56:30 <EgoBot> 3 CakeProphet: ps
00:56:33 <Razor-X> !bf_txtgen CakeProphet
00:56:47 <CakeProphet> >.>
00:56:48 <EgoBot> 108 +++++++++++++[>+++++>+++++++>++++++++>++++++<<<<-]>++.>++++++.>+++.<++++.>>++.<+++++++.---.+.<+++.---.>++++. [295]
00:56:56 <Razor-X> Wow. That's surprisingly good.
00:57:02 <CakeProphet> ?
00:57:07 <GregorR-W> !bf_txtgen AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
00:57:16 <Razor-X> !bf +++++++++++++[>+++++>+++++++>++++++++>++++++<<<<-]>++.>++++++.>+++.<++++.>>++.<+++++++.---.+.<+++.---.>++++.
00:57:19 <EgoBot> CakeProphet
00:57:25 <Razor-X> !ps
00:57:26 <CakeProphet> ?
00:57:28 <EgoBot> 3 GregorR-W: bf_txtgen
00:57:30 <EgoBot> 4 Razor-X: ps
00:57:40 <Razor-X> Hahaha. Horrible genetic algorith.m
00:57:42 <Razor-X> *algorithm.
00:58:06 <EgoBot> 155 +++++++++++++[>+++++>+++++>+++++>+++++<<<<-]>.>.>........>......<.<...<.>..............<.....>>>...<..............<.......<....>.>.>....<..>.....<..<..<... [842]
00:58:08 <Razor-X> Brace yourselves ladies (and gentlemen), the competition will begin in a few minutes!
00:58:10 <GregorR-W> Wow.
00:58:10 <RodgerTheGreat> everybody getting ready for the unveiling?
00:58:15 <Razor-X> OUCH. That's horrible!
00:58:22 * CakeProphet wants to know what all this crap he's putting in would do.
00:58:36 <GregorR-W> !bf +++++++++++++[>+++++>+++++>+++++>+++++<<<<-]>.>.>........>......<.<...<.>..............<.....>>>...<..............<.......<....>.>.>....<..>.....<..<..<...
00:58:39 <EgoBot> AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
00:58:49 <RodgerTheGreat> lol
00:58:51 <Razor-X> What's the ASCII code for A again?
00:58:51 <CakeProphet> !bf
00:58:56 <GregorR-W> Razor-X: 65
00:59:00 <Razor-X> Aha.
00:59:35 <GregorR-W> What's the ASCII code for YOUR MOM
00:59:48 <CakeProphet> 9999
00:59:52 <CakeProphet>
00:59:53 <Razor-X> Did lament take over your body?
01:00:02 <CakeProphet> !bf omg lol
01:00:04 <CakeProphet> !ps
01:00:08 <EgoBot> 3 CakeProphet: ps
01:00:30 <CakeProphet> !bf 3 CakeProphet: ps
01:00:36 <CakeProphet> !ps
01:00:40 <EgoBot> 3 CakeProphet: ps
01:00:43 <CakeProphet> -.-
01:00:47 <CakeProphet> What does it all mean!!!
01:00:51 * CakeProphet bangs his head against the wall.
01:01:17 <Razor-X> !bf +++++++++++++[>+++++<-]<<<++++[>++[>+++++++++++<-]<-]>>[>.<-]
01:01:38 <CakeProphet> Why does it give me the same thing over and over?
01:01:40 <CakeProphet> !ps
01:01:42 <EgoBot> 3 CakeProphet: ps
01:01:45 <Razor-X> !bf +++++++++++++[>+++++<-]<<++++[>++[>+++++++++++<-]<-]>>[>.<-]
01:01:48 <EgoBot> AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
01:01:51 <Razor-X> There we are.
01:01:51 <pikhq> CakeProphet: [[Brainfuck]]
01:02:00 <RodgerTheGreat> wooo! it's time!
01:02:20 <Razor-X> No, it's actually one minute past.
01:02:22 <Razor-X> But whatever.
01:02:37 <Razor-X> RodgerTheGreat: Will you do the honors of posting the task on the Wiki page?
01:02:57 <RodgerTheGreat> uhm... ok, then- this will take a bit.
01:03:10 <RodgerTheGreat> should I just post the brief list and then flesh it out after people look?
01:03:14 <Razor-X> Don't forget the last one we talked and sobbed about.
01:03:18 <Razor-X> Yeah.
01:03:20 <RodgerTheGreat> ok
01:03:39 <pikhq> ARGH!
01:03:47 <CakeProphet> !pf ,[.,]
01:03:50 <EgoBot> Huh?
01:03:53 * pikhq isn't fond of needing to wait anymore
01:03:58 <CakeProphet> !bf ,[.,]
01:04:04 <Razor-X> CakeProphet: That'll evaluate to nothing.
01:04:11 <pikhq> !ps
01:04:13 <CakeProphet> Bullshit
01:04:14 <EgoBot> 3 CakeProphet: bf
01:04:16 <EgoBot> 4 pikhq: ps
01:04:21 <pikhq> !i 3 Bull.\n
01:04:22 <Razor-X> !bf +[,.[-]]
01:04:24 <EgoBot> Bull.
01:04:30 <Razor-X> Oh, whoops.
01:04:31 <Razor-X> :P
01:04:33 <Razor-X> !ps
01:04:35 <CakeProphet> ...
01:04:36 <EgoBot> 3 CakeProphet: bf
01:04:38 <EgoBot> 4 Razor-X: ps
01:04:40 <EgoBot> 5 Razor-X: bf
01:04:45 <Razor-X> !i 5 Blah\n
01:04:47 <CakeProphet> !I lol
01:04:47 <pikhq> !i 5 . . .\n
01:04:48 <EgoBot> B
01:04:50 <EgoBot> Huh?
01:04:54 <Razor-X> That's the end of that.
01:05:00 <pikhq> Bravo.
01:05:03 <CakeProphet> !pf+ ,[.,]
01:05:06 <EgoBot> Huh?
01:05:07 <Razor-X> !bf +[,.]
01:05:09 <CakeProphet> !bf + ,[.,]
01:05:19 <Razor-X> !ps
01:05:22 <EgoBot> 3 CakeProphet: bf
01:05:23 <CakeProphet> !i lol?
01:05:24 <EgoBot> 4 Razor-X: bf
01:05:25 <CakeProphet> !bf + ,[.,]
01:05:26 <EgoBot> 5 CakeProphet: bf
01:05:28 <EgoBot> 6 Razor-X: ps
01:05:35 <Razor-X> !i 6 And Bingo was his name-o.\n
01:05:39 <Razor-X> !i 4 And Bingo was his name-o.\n
01:05:42 <EgoBot> And Bingo was his name-o.
01:05:57 * CakeProphet is totally confused.
01:06:00 <Razor-X> Come on bub. Can't make a cat program in BF?
01:06:08 <Razor-X> !ps
01:06:10 <EgoBot> 3 CakeProphet: bf
01:06:12 <EgoBot> 4 Razor-X: bf
01:06:14 <EgoBot> 5 CakeProphet: bf
01:06:16 <EgoBot> 6 Razor-X: ps
01:06:18 <EgoBot> 7 CakeProphet: bf
01:06:22 <Razor-X> !kill 4
01:06:24 <EgoBot> Process 4 killed.
01:06:26 <Razor-X> !kill 3
01:06:28 <EgoBot> Process 3 killed.
01:06:29 <Razor-X> !kill 5
01:06:30 <Razor-X> !kill 7
01:06:32 <EgoBot> Process 7 killed.
01:06:39 <Razor-X> !ps
01:06:42 <EgoBot> 3 Razor-X: ps
01:06:42 * CakeProphet doesn't get how the bot works.
01:06:44 <CakeProphet> !help
01:06:45 <RodgerTheGreat> BEHOLD!
01:06:46 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
01:06:47 <RodgerTheGreat> http://esoteric.voxelperfect.net/wiki/2006_Esolang_Contest#The_Tasks
01:06:48 <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
01:06:58 <CakeProphet> ?help bf
01:07:03 <CakeProphet> !help bf
01:07:06 <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.
01:07:09 <Razor-X> THE TASKS. THEY HURT MY EYEEEEES.
01:07:19 <RodgerTheGreat> sorry.
01:07:21 <Razor-X> Well CakeProphet, I wish you luck. You and your defficient cat program.
01:07:29 * RodgerTheGreat 's wiki-fu is weak
01:07:29 <CakeProphet> :D
01:07:40 <RodgerTheGreat> I *did* manage to make them bulleted, at least...
01:07:42 <Razor-X> That's because you use Weak-y-fu.
01:07:49 <RodgerTheGreat> :(
01:07:51 * CakeProphet knows wikicode fairly well.
01:07:52 <Razor-X> *Cymbal crash*.
01:08:04 <Razor-X> I can't stand Wiki markup, personally.
01:08:06 <CakeProphet> !help bs
01:08:10 <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.
01:08:10 <Razor-X> LaTeX for the win.
01:08:11 <RodgerTheGreat> do you mean "rimshot"?
01:08:18 <Razor-X> Shhh. Bub.
01:08:27 <CakeProphet> !help show
01:08:30 <EgoBot> Use: show <pid> Function: display the current output buffer for a process
01:08:53 <CakeProphet> !show 3
01:09:07 * pikhq hyperventilates
01:09:17 <CakeProphet> !bf >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+++>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+>+++>>+>+>+>+>+>>+>>+>>+>>>+>+>+>+>+>+>++>>+>+....>>+>+>+>+>+>+>.>+>>+>+>+>.+>+>+>+>+>+++,>+>+>+.+>++>+>+>+>>+>+>+>>+>>++>+>>+>+>+>+>+>++++++++++{>>>>>+>+>+>+>+>+<+<+<+<+<+<>+>+>+>+>]
01:09:20 <CakeProphet> !ps
01:09:22 <EgoBot> 3 CakeProphet: ps
01:09:25 <CakeProphet> !show 3
01:09:40 <CakeProphet> !help bf
01:09:42 <CakeProphet> !help
01:09:42 <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.
01:09:44 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
01:09:46 <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
01:10:12 <CakeProphet> ARgh
01:10:23 <CakeProphet> !help bf64
01:10:26 <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.
01:11:09 <Razor-X> I locked the participation list.
01:11:18 <CakeProphet> !bf ++++++++++++++++++++++++++++++++>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+++++++++++++++++++++><>>>>>>>>>>>>>>>>>>>>>++++>+>+>+>+>+>+>+>+>+>+>+>>+>+>+>+>+>+[>+>+>+>+>+>+>+>+>+>+][,-]
01:11:18 <Razor-X> May the best coder win.
01:11:20 <EgoBot> realloc: Cannot allocate memory
01:11:54 <RodgerTheGreat> more specific version: http://esoteric.voxelperfect.net/wiki/2006_Esolang_Contest#The_Tasks
01:11:56 <CakeProphet> !bf ++++++++++++++++++++++++++++++++>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+++++++++++++++++++++><>>>>>>>>>>>>>>>>>>>>>++++>+>+>+>+>+>+>+>+>+>+>+>>+>+>+>+>+>+[>+>+>+>+>+>+>+>+>+>+[,<<<<<<<<<<<<<<<<<]]
01:12:15 <RodgerTheGreat> and I'm going to be adding links to useful articles shortly.
01:12:17 <CakeProphet> !ps
01:12:18 <EgoBot> 3 CakeProphet: bf
01:12:20 <EgoBot> 4 CakeProphet: ps
01:12:24 <Razor-X> RodgerTheGreat: Don't.
01:12:28 <CakeProphet> !show 4
01:12:29 <pikhq> ARGH!!!. . .
01:12:39 <RodgerTheGreat> I meant like making "UUencode
01:12:40 <Razor-X> People should be able to find the relevant information to their task *on their own*.
01:12:44 <Razor-X> Oh.
01:12:45 <Razor-X> Yeah.
01:12:46 <RodgerTheGreat> a link to... oh, fine..
01:13:03 <Razor-X> I was talking about some of the tasks involving brute-forcing vs. smartness.
01:13:20 <RodgerTheGreat> oh, yeah- I'm just trying to make sure people know what we mean.
01:13:26 <CakeProphet> Hmmm... here's a good program.
01:13:39 <CakeProphet> !bf [>+,]
01:13:52 * pikhq feels like doing that compression one. . .
01:13:54 <pikhq> CakeProphet: Noop.
01:14:09 <Razor-X> THE TASK LIST HAS BEEN CONFIRMED. PLEASE TAKE A LOOK AT IT AT YOUR CONVENIENCE. ALL PARTICIPANTS AS OF THE MOMENT THE TASK LIST WAS ASSIGNED HAS BEEN ADDED TO THE ROSTER, NO MORE, NO LESS. NO ONE ELSE WILL BE ADDED. Thank you.
01:14:20 <CakeProphet> OKAY
01:14:24 <CakeProphet> THANK YOU FOR THAT BULLETEIN
01:14:34 <Razor-X> Bub. Spell better.
01:15:19 <CakeProphet> !bf [+>.']]
01:15:32 <Razor-X> *Sigh*.
01:15:35 <CakeProphet> !bf [+>.,]
01:15:37 <Razor-X> I'll help out our bumbling fool here.
01:15:46 <Razor-X> CakeProphet: What does [] do in BF?
01:15:49 <CakeProphet> No no.. I'll do it.
01:15:56 <CakeProphet> I'm going to trust blind instinct on this one.
01:16:00 <CakeProphet> :D
01:16:10 <Razor-X> Obviously you have horrible instinct :D.
01:16:39 <CakeProphet> >.>
01:16:51 <CakeProphet> Hey now.. I don't even know what the commands do..
01:16:56 <pikhq> Hmm. OISC could be simpler, though. . .
01:17:10 <pikhq> . . .
01:17:15 <CakeProphet> toehr than > is next... < is back... + add something to that stack.. and - take away from that stack... but I have no clue how to use that to make anything.
01:17:34 <CakeProphet> Oh and [] are loops
01:18:23 <RodgerTheGreat> ok, I think I'm done for now: http://esoteric.voxelperfect.net/wiki/2006_Esolang_Contest#The_Tasks
01:19:46 <CakeProphet> >.>
01:19:55 <CakeProphet> Heh... I'm ganna win this one.
01:20:11 <RodgerTheGreat> ...
01:20:18 * RodgerTheGreat shrugs
01:20:24 <RodgerTheGreat> I guess it's possible.
01:20:34 <CakeProphet> Yeah I'd probably have trouble doing all of those things in a language I knew.
01:20:47 <RodgerTheGreat> you don't have to do all, just some.
01:20:50 <Razor-X> Gah. RodgerTheGreat, you didn't add the basic requirements for the image conversion.
01:20:58 <RodgerTheGreat> oh, whoops.
01:21:01 <Razor-X> Nor for sed.
01:21:04 <RodgerTheGreat> care to add that?
01:21:09 <Razor-X> -_-''
01:21:17 <RodgerTheGreat> FINE
01:21:17 <Razor-X> Come on. I did everything else on the page.
01:21:21 <RodgerTheGreat> I'll do it.
01:21:37 <CakeProphet> Okay... so for my first task I submit this...
01:22:16 <Razor-X> You can't make an OISC/MISC interpreter in Python?
01:22:32 <CakeProphet> [,>]
01:22:40 <CakeProphet> Dunno what OISC/MISC is.
01:22:46 <Razor-X> Click on the link, bub.
01:23:25 * pikhq tries thinking of how to do arrays in Brainfuck. . .
01:23:25 * CakeProphet has only a few months experience with Python.
01:23:38 * Razor-X sighs deeply.
01:23:52 <CakeProphet> I'm guessing you just give a lineup of cells different bytes and call it an "array"
01:23:59 <CakeProphet> :D
01:24:13 <CakeProphet> But... I'm trying to speak French when I only know shitty English.
01:24:31 <Razor-X> Bub. Anyone can program in BF. And OISC/MISC is easy.
01:25:08 * CakeProphet doesn't get BF yet.. so can't program in it.
01:25:15 <Razor-X> How bout a synthetic set of trig functions? That's easy.
01:25:44 <CakeProphet> I could do it in Python...
01:25:56 <Razor-X> Good.
01:25:57 <CakeProphet> But.. I don't know -shit- about BF... and I'm failing to understand it as I read about it.
01:26:35 <Razor-X> A friend of mine is really into computing and logic, but she's horrible with software and higher-level languages. BF was a snap for her.
01:26:50 <Razor-X> (No pikhq, she has a girlfriend already. Not that I'd care :D.)
01:27:03 * CakeProphet sucks at both.. apparently :(
01:27:09 <Razor-X> Here, lemme help.
01:27:21 <Razor-X> Do you know what an array of cells is?
01:27:30 <CakeProphet> I'm really not a logical kind of person... I'm not good with structures and crap.
01:27:34 <CakeProphet> Yeah.
01:27:40 <CakeProphet> Maybe..
01:27:55 <CakeProphet> I know what an array is.. and I'm guessing a cell is a content of the array.
01:28:07 <Razor-X> Think of a bunch of cubby holes that make a shelf.
01:28:15 <Razor-X> Your shelf is the array, each cubby hole is a cell.
01:28:20 <RodgerTheGreat> ok guys, this is the final task list (for real this time)- http://esoteric.voxelperfect.net/wiki/2006_Esolang_Contest#The_Tasks
01:28:31 <CakeProphet> Yeah I got that much.
01:28:41 <CakeProphet> So the cells act as memory storage?
01:28:45 <RodgerTheGreat> yes
01:28:49 <Razor-X> Yeah. Like in a real computer.
01:28:49 * CakeProphet cheers.
01:29:02 <RodgerTheGreat> now imagine that you're looking at one cubby hole at a time.
01:29:04 <Razor-X> Now, if you have an infinite set of cards to add in to each cubby hole, and an infinite set of holes, what does + do?
01:29:06 <CakeProphet> Now I just need to figure out how the bytes come together to equal shit.
01:29:22 <CakeProphet> Puts a "card" in :D
01:29:25 <Razor-X> Yes!
01:29:34 * CakeProphet claps like a little kid, "yaaaaaay!"
01:29:34 <Razor-X> What does - do, assuming you already did a + ?
01:29:41 <CakeProphet> ....the inverse?
01:29:43 * CakeProphet claps like a little kid, "yaaaaaay!"
01:29:51 <Razor-X> NO! YOU CLAPPED TOO SOON!
01:29:56 <CakeProphet> SHIT
01:29:57 <Razor-X> But yes, you are correct.
01:29:59 <RodgerTheGreat> lol
01:30:01 <CakeProphet> ...
01:30:03 <CakeProphet> :D
01:30:18 <RodgerTheGreat> Razor-X would make the most hilarious kindergarten teacher...
01:30:21 <Razor-X> Remember. Clap after you know you're correct.
01:30:34 <Razor-X> RodgerTheGreat: NEVER EVER!
01:30:40 <RodgerTheGreat> :D
01:30:50 <Razor-X> I may go all girly over kids, but I never want to take care of them for extended periods of times >_>.
01:30:56 <Razor-X> EVER.
01:30:58 <Razor-X> *Ahem*
01:31:10 <Razor-X> Now, what does a > do, CakeProphet ?
01:31:11 <CakeProphet> I'm not sure how to convert bytes into uh... useful stuff.
01:31:17 <CakeProphet> Goes over to the over cell.
01:31:21 <Razor-X> Over cell?
01:31:29 <CakeProphet> Goes... over to the next cell.
01:31:33 <Razor-X> Good.
01:31:36 <Razor-X> What does < do?
01:31:40 <CakeProphet> -.-
01:31:44 <CakeProphet> back?
01:31:50 * CakeProphet claps like a little kid, "yaaaaaay!"
01:31:55 <Razor-X> No. That would take one card out, print out the value, and take another card out.
01:31:59 <Razor-X> You clapped too soon, again.
01:32:01 * RodgerTheGreat mumbles "previous"
01:32:10 <CakeProphet> :?
01:32:13 <Razor-X> Ok. What does . do?
01:32:22 <CakeProphet> outputs
01:32:31 <RodgerTheGreat> OUTPUTS WHAT?
01:32:42 <Razor-X> If you have 65 cards inside, what is the output?
01:32:55 <CakeProphet> The... cell?
01:33:06 <RodgerTheGreat> ...
01:33:06 <CakeProphet> 65.
01:33:11 <Razor-X> NO.
01:33:13 <CakeProphet> YES
01:33:23 <RodgerTheGreat> http://en.wikipedia.org/wiki/ASCII
01:33:25 <Razor-X> It prints out the symbol corresponding to the ASCII symbol for 65.
01:33:30 <CakeProphet> _|_ >.< _|_ Screw this school, man! I'll just drop out!
01:33:39 <CakeProphet> AHA
01:33:47 <CakeProphet> That helps me out a bunch/
01:33:51 <Razor-X> That would go to the right one cell, print its contents, and go to the left one cell.
01:34:08 * CakeProphet didn't know it converted to ASCII
01:34:10 <Razor-X> Now. If you have a , what do you do?
01:34:14 <RodgerTheGreat> Razor-X: I think you're just confusing him when you interpret his emoticons.
01:34:29 <Razor-X> RodgerTheGreat: Fine :(.
01:34:36 <RodgerTheGreat> it is funny.
01:34:47 <RodgerTheGreat> however, we're trying to teach him.
01:34:49 <CakeProphet> , takes input..
01:34:53 <CakeProphet> [] is whiles
01:34:55 * CakeProphet wins.
01:35:06 <Razor-X> CakeProphet: If your input is `A', how many cards are added to the cell?
01:35:24 <CakeProphet> No idea... I don't know ASCII by heart
01:35:32 <Razor-X> Pssst. Look at a table. Bub.
01:36:06 <CakeProphet> 0110 0001 97 61 a
01:36:14 * CakeProphet can read tables now... yaaay.
01:36:16 * Razor-X hits her face.
01:36:24 <Razor-X> How can you have binary cards, BUB?!
01:36:24 <RodgerTheGreat> ...
01:36:32 <RodgerTheGreat> A != a, also.
01:36:44 <Razor-X> BUB. You're WRONG.
01:36:51 <Razor-X> There is a decimal amount of cards in the cell.
01:36:57 <Razor-X> DECIMAL. :P
01:36:57 <RodgerTheGreat> DECIMAL
01:37:06 <CakeProphet> DECIMAL
01:37:07 <Razor-X> Base 10.
01:37:14 * RodgerTheGreat shows 10 fingers
01:37:28 <CakeProphet> :?
01:37:42 <Razor-X> So bub, how many cards?
01:37:54 <CakeProphet> Hell if I know.
01:37:55 * RodgerTheGreat shows CakeProphet 65 fingers and nudges him in the ribs.
01:38:07 * CakeProphet ahems, "65"
01:38:09 * Razor-X whispers nonchalantly as if she didn't see that.
01:38:14 <Razor-X> Yes! Correct!
01:38:24 <RodgerTheGreat> next subject: if there are two cards in the cubbyhole, what does [ do?
01:38:25 <Razor-X> Now can you read the table and find out *why* it's 65?
01:38:26 <CakeProphet> So A is...
01:38:39 <CakeProphet> Because the table said so..
01:38:44 <Razor-X> Good job!
01:38:53 <Razor-X> Alright. Now answer RodgerTheGreat's question.
01:39:02 <CakeProphet> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
01:39:14 -!- tgwizard has quit ("Leaving").
01:39:16 <CakeProphet> I know it does some sort of loop.. no idea what the loop is based on though.
01:39:22 <CakeProphet> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ is A?
01:39:25 <Razor-X> Yes.
01:39:55 <CakeProphet> !bf +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
01:40:00 <Razor-X> CakeProphet: If you have this code +++++++++++[>+++++++++++.<-] what does it do?
01:40:01 <CakeProphet> !ps
01:40:04 <EgoBot> 3 CakeProphet: bf
01:40:06 <EgoBot> 4 CakeProphet: ps
01:40:06 <Razor-X> CakeProphet: Don't forget the output, bub.
01:40:17 <CakeProphet> !bf +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
01:40:19 <EgoBot> A
01:40:24 <Razor-X> Congratulations!
01:40:27 <CakeProphet> Oooh... exciting.
01:40:33 <CakeProphet> My first BF program...
01:40:40 <CakeProphet> not quite Hello World... but I'm getting there.
01:40:41 <Razor-X> Now answer the question I just asked.
01:40:49 * CakeProphet doesn't know?
01:41:12 <CakeProphet> dont tell me
01:41:17 <CakeProphet> !bf +++++++++++[>+++++++++++.<-]
01:41:20 <EgoBot> !,7BMXcny
01:41:24 <CakeProphet> It does that.
01:41:39 * Razor-X sighs.
01:41:51 <Razor-X> CakeProphet: If you have this code +++++++++++[>+++++++++++.<<] what does it do?
01:41:57 <CakeProphet> !bf +++++++++++[>+++++++++++.<-]
01:42:00 <EgoBot> !,7BMXcny
01:42:19 <CakeProphet> !bf +++++++++++[>+++++++++++.<<]
01:42:22 <EgoBot>
01:42:38 <CakeProphet> It... does the same thing over and over again?
01:42:42 <RodgerTheGreat> I don't think we're going anywhere fast with this.
01:43:12 * CakeProphet shrugs, "Just tell me what it does... works much better than asking me questions about crap I don't know."
01:43:30 <RodgerTheGreat> fine.
01:43:45 <CakeProphet> I'm already trying to answer the questions... so asking them for me doesn't help much ^_^
01:43:48 <RodgerTheGreat> [ jumps to the matching ] if the current cubbyhole has no cards in it.
01:44:04 <CakeProphet> So it..
01:44:05 <RodgerTheGreat> ] jumps BACK to the matching [ if the current cubbyhole has any cards in it.
01:44:37 <CakeProphet> So... how would you keep it from going on forever?
01:45:05 <RodgerTheGreat> alright, let's look at this example:
01:45:09 <RodgerTheGreat> [+>]
01:45:22 <RodgerTheGreat> when the program starts, the cubbies have 0 cards in them.
01:45:30 <RodgerTheGreat> the first cubby therefore has 0 cards.
01:45:41 <RodgerTheGreat> [ will therefore jump to ]
01:45:50 <RodgerTheGreat> we're at the end of the program, done.
01:45:55 <RodgerTheGreat> next example.
01:46:00 <RodgerTheGreat> +[-]
01:46:10 <CakeProphet> Hmmm wait wait..
01:46:11 <RodgerTheGreat> we put a card in the first cubby.
01:46:14 <CakeProphet> What do you mean by jump to?
01:46:24 <RodgerTheGreat> we have cards, so [ does nothing
01:46:29 <RodgerTheGreat> - takes the card away.
01:46:42 <RodgerTheGreat> we have no cards, so ] does nothing.
01:46:45 <RodgerTheGreat> end of program.
01:46:51 <CakeProphet> So it's like a.... conditional?
01:47:01 <RodgerTheGreat> by "jump" I mean, go to a different part of the program.
01:47:01 <RodgerTheGreat> yes.
01:47:16 <CakeProphet> Ah... it locks crap out.. I get it... I thought it was just a loop or something/
01:47:22 <RodgerTheGreat> don't think of [ and ] as a loop, think of them as conditionals that must be used in pairs.
01:47:42 <CakeProphet> Yeah yeah I get it now.
01:47:47 <RodgerTheGreat> you *can* use them to create loops.
01:47:47 <CakeProphet> I didn't know they were conditionals till now.
01:47:59 <CakeProphet> It's basically a lock.
01:48:06 <CakeProphet> Which is basically a conditional.
01:48:11 <RodgerTheGreat> like a spinlock, in a way, yes.
01:48:54 <RodgerTheGreat> Razor-X: I think I got him to understand [ ]!
01:49:04 <CakeProphet> I got most of the first part.
01:49:07 * RodgerTheGreat dances
01:49:11 <CakeProphet> > < + and -
01:49:22 <CakeProphet> and to an extent , and .
01:50:01 <CakeProphet> hmmm...
01:50:04 <CakeProphet> soo./...
01:50:17 <Razor-X> Back.
01:50:55 <RodgerTheGreat> I had successes while you were gone!
01:51:08 <Razor-X> Yes. He comprehended while loops.
01:51:14 <Razor-X> I feel proud of our student now.
01:51:14 <RodgerTheGreat> w00t
01:51:51 <CakeProphet> Hmmm... how do you do loops?
01:51:53 <RodgerTheGreat> CakeProphet: can you tell me what +[.+] would do?
01:52:05 <RodgerTheGreat> step through it one instruction at a time.
01:52:15 <CakeProphet> ADd one... output it... add another...
01:52:38 -!- Sgeo has joined.
01:52:39 <CakeProphet> loops back.
01:52:51 <Razor-X> When does it stop?
01:52:59 <CakeProphet> Doesn't
01:53:00 <RodgerTheGreat> DOES it stop?
01:53:05 <Razor-X> Good ;).
01:53:21 <CakeProphet> [-] would stop it though
01:53:25 <Razor-X> Yes.
01:53:28 <RodgerTheGreat> now, in the real world, cubbyholes can only hold 0-255 cards.
01:53:29 <Razor-X> Well, hmmm.
01:53:43 <RodgerTheGreat> if you + with 255 cards, you will have 0 cards.
01:53:51 <CakeProphet> Ah.
01:53:52 <RodgerTheGreat> (depends on the interpreter)
01:53:54 <CakeProphet> Cool
01:54:03 <RodgerTheGreat> likewise, - with 0 cards gives you 255
01:54:07 <Razor-X> Some BF interpreters would give errors there, some can hold a 32-bit amount of cards, other 8-bit amounts of cards, etc.
01:54:13 <Razor-X> CakeProphet: Now, write a BF->Python compiler using Python.
01:54:19 <CakeProphet> ....
01:54:25 <CakeProphet> Sure.
01:54:30 <RodgerTheGreat> lol
01:54:43 <Razor-X> Hey, if you understood this correctly, it should be a breeze.
01:54:46 <CakeProphet> I'm using my own characters though... those annoy me.
01:54:48 <RodgerTheGreat> in theory
01:55:02 <RodgerTheGreat> CakeProphet: ?
01:55:16 <CakeProphet> Although I have no idea how to set up an infinite array... unless its pseudoinfinite by expanding when needed.
01:55:40 <RodgerTheGreat> 30000 cells is the BF standard.
01:55:44 <Razor-X> Yeah.
01:55:46 <RodgerTheGreat> (for whatever reason)
01:55:54 * CakeProphet doesn't even know how to set up a compiler in generally... but he could set up an instant-response-interpretter like system.
01:55:59 <RodgerTheGreat> 64000 is another nice number.
01:56:05 <Razor-X> A compiler is even easier.
01:56:10 <CakeProphet> Eh... you could just expand to the array when needed.
01:56:22 <Razor-X> CakeProphet: It would eventually segfault.
01:56:29 <CakeProphet> No idea what that is.
01:56:36 <Razor-X> O_O
01:56:55 <Razor-X> This kindergarten teacher has had enough :D.
01:56:58 * CakeProphet is something of a newb... in case it hasn't caught on.
01:57:09 * RodgerTheGreat is shocked.
01:57:32 <Razor-X> How long have you been using Linux for, bub?
01:57:42 <CakeProphet> !bf +['+]
01:57:50 * CakeProphet uses XP *gasp* MURDER
01:57:57 <RodgerTheGreat> what's the ' for?
01:57:57 <CakeProphet> !bf +[,+]
01:58:01 <CakeProphet> !bf +[.+]
01:58:02 <Razor-X> Oh. A Windows user, no wonder.
01:58:03 <CakeProphet> say Typo.
01:58:05 <EgoBot> <CTCP>
01:58:17 <Razor-X> You'd get an Out of Memory error eventually.
01:58:25 <ivan`> get EgoBot to stop CTCPing me
01:58:31 <Razor-X> :D
01:58:37 -!- EgoBot has quit (Excess Flood).
01:58:38 <Razor-X> /ignore EgoBot
01:58:49 <Razor-X> Oh. That too.
01:58:50 <CakeProphet> !bf-txt_gen lolspam
01:58:50 <RodgerTheGreat> that's what BF does when it sends low-level ASCII codes
01:58:56 <RodgerTheGreat> my bot does that too,
01:59:01 <CakeProphet> !help
01:59:05 <RodgerTheGreat> heh
01:59:07 <RodgerTheGreat> dead
01:59:09 -!- EgoBot has joined.
01:59:10 <Razor-X> CakeProphet: *Pssst* EgoBot left.
01:59:11 <RodgerTheGreat> lemme get my bot
01:59:16 <CakeProphet> !bf-txt_gen lolspam
01:59:20 <EgoBot> Huh?
01:59:24 <CakeProphet> !bftxt_gen lolspam
01:59:24 <Razor-X> !bf_txtgen lolspam
01:59:26 <CakeProphet> !help
01:59:26 <EgoBot> Huh?
01:59:30 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
01:59:32 <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
01:59:34 <Razor-X> ;)
01:59:53 <CakeProphet> !bf_txtgen Gee I like to think about the dead.
01:59:58 <EgoBot> 70 ++++++++++++[>+++++++++>++++++++>><<<<-]>.+++.---.+++++++.---.>+.<---. [288]
02:00:04 <Razor-X> Congratulations. You are 1 of 2 windows users here, bub.
02:00:12 <RodgerTheGreat> who
02:00:19 <RodgerTheGreat> is the other one, again?
02:00:27 <Razor-X> CakeProphet and thematrix(something-or-other).
02:00:36 <CakeProphet> !bf ++++++++++++[>+++++++++>++++++++>><<<<-]>.+++.---.+++++++.---.>+.<---[,]
02:00:40 <RodgerTheGreat> ah
02:00:53 -!- BrainMachine has joined.
02:00:57 <CakeProphet> !bf ++++++++++++[>+++++++++>++++++++>><<<<-]>.+++.---.+++++++.---.>+.<---.,]
02:01:00 <RodgerTheGreat> now we have a spare.
02:01:05 <CakeProphet> !bf ++++++++++++[>+++++++++>++++++++>><<<<-]>.+++.---.+++++++.---.>+.<---[.]
02:01:09 <CakeProphet> There
02:01:24 <EgoBot> 239 +++++++++++++++[>+++++++>++>+++++>+++++++<<<<-]>>++..>----.>----..<<.>++.<.>+++++++++++++++++++++++++++++++++++.---.++.>.<<.>+++++++++.-----.<.>+++++.<<-.+.>>------.<<++.>.>>----.+.<+.++++++.-.<.>.<<---.---.>.<-.+.----.+++.>++++++++++++++. [858]
02:01:39 <CakeProphet> -.-
02:02:06 <CakeProphet> Yeah so.. I suck at logic, math, and pretty much everything programming...
02:02:13 <CakeProphet> Where do you think my knack is?
02:02:20 * CakeProphet is more of a art kind of person.
02:02:28 <ivan`> try truck driving
02:03:07 <CakeProphet> Though coding is something of an art... pretty amazing crap... I suck at it.
02:03:11 * RodgerTheGreat is also an art kind of person.
02:03:22 <RodgerTheGreat> this does not prevent me from coding.
02:03:23 <ivan`> I've sucked at coding for 11 years
02:03:30 <ivan`> my code is somewhat readable and well-designed now
02:03:39 <RodgerTheGreat> there's nothing about being artistic that is at odds with being a programmer.
02:03:42 <ivan`> but i've got nothin' on those old geezers
02:03:53 <CakeProphet> So... am I doing good for only having typed up about... 4 programs ever? (not including BF)
02:04:00 <ivan`> probably
02:04:09 <ivan`> at least QBASIC didn't braindamage you
02:04:26 <ivan`> i was debugging gotos when I was 6
02:04:26 <CakeProphet> C looks kind of annoying.
02:04:32 <ivan`> kind of hard to understand what a function is after that
02:04:56 <CakeProphet> I have a feeling I'd be better at low level code...
02:05:03 <CakeProphet> I suck at organizing.
02:05:13 <RodgerTheGreat> BF is low-level
02:05:18 <ivan`> low level code needs a lot more organizing
02:05:31 <RodgerTheGreat> and less self-documenting.
02:05:32 <CakeProphet> ....oh... well then...
02:05:55 * CakeProphet scratches his head.
02:06:15 <CakeProphet> I guess the more abstract it is... the better I'll bet at it probably.
02:06:32 <RodgerTheGreat> BF is abstract
02:06:35 <CakeProphet> ........
02:06:42 <CakeProphet> god damnit.... stop confusing me :D
02:06:53 <RodgerTheGreat> it is BOTH abstract and low-level
02:07:00 <CakeProphet> It's not abstract though.. it's very low and in-the-very-nature-of-the-computer.
02:07:07 <RodgerTheGreat> the two are not mutually exclusive.
02:07:13 <CakeProphet> Abstract is.... more general and vague.
02:07:28 <RodgerTheGreat> CakeProphet: when was the last time you saw a computer with one pointer and a tape?
02:07:42 <CakeProphet> I've never seen a computer with one pointer and a tape.
02:07:59 <RodgerTheGreat> BF runs on a computer with one pointer and a tape.
02:08:02 <CakeProphet> I've never seen a computer with a pointer... or a tape at all..
02:08:43 <CakeProphet> I have no idea what a tape is... unless you mean... duct tape or something.
02:10:53 <pikhq> Brainfuck *is* a computer with one pointer and a tape. . .
02:11:05 <pikhq> CakeProphet: [[Turing machine]]
02:11:08 <RodgerTheGreat> good point
02:11:19 <CakeProphet> Meh... excuse my lack of technical knowledge... to me a computer is a box with some stuff in it and a monitor.
02:11:28 <RodgerTheGreat> it's too bad IRC doesn't support wikicode...
02:11:28 <pikhq> j00 fail.
02:11:47 * CakeProphet has a javascript wiki-linker in his client.
02:11:56 <RodgerTheGreat> cool
02:12:02 <CakeProphet> STuff like this [[this]] will link me to wikipedia articles.
02:12:05 <RodgerTheGreat> mine just recognizes links.
02:12:09 <CakeProphet> Yeah
02:12:14 <CakeProphet> Okay... we have the same thing.
02:12:17 <pikhq> Mine requires me to parse it all.
02:12:48 <CakeProphet> Well... at least I'm a bit more technical than the average windows user.
02:13:41 <pikhq> Which is like saying "At least I know more algebra than a kindergartener". . .
02:13:48 <RodgerTheGreat> CakeProphet: that means you know the difference between AOL and the internet.
02:14:01 <CakeProphet> ...
02:14:07 <CakeProphet> AOL should die.
02:14:26 <CakeProphet> so.. here's what I know about the internet... it's like... like like a series of tubes...
02:14:36 <RodgerTheGreat> AOL *did* die, it's soulless corpse simply continues to haunt us through it's adoptive companies.
02:15:41 <CakeProphet> So far the only things I have experience with is.... socketevent-based/parser programming.
02:15:51 <CakeProphet> And I can make a prine number generator... how delightful.
02:16:02 <RodgerTheGreat> are those like prime numbers?
02:16:13 <CakeProphet> ?
02:16:18 <CakeProphet> Yeah sorta
02:16:20 <RodgerTheGreat> "prines"
02:16:35 <CakeProphet> Basically... my skills in programming allow me to.... make an IRC bot.
02:16:52 <pikhq> So, you're where I was when I was 9.
02:16:53 <CakeProphet> socket + event-based + parsing = bot
02:16:54 <RodgerTheGreat> impressive.
02:17:12 * CakeProphet is 15... meh...
02:17:29 * pikhq is 16
02:17:50 <CakeProphet> You guys scare me... you've all been coding since you were little kids... WHO DID THIS TO YOU
02:17:50 <BrainMachine> knowing how to code IRC bots comes in handy occasionally.
02:18:08 <CakeProphet> I could probably rig up an IRC client if I wanted to.
02:18:20 <RodgerTheGreat> I learned to program when I was 13 when my family finally GOT A DAMN COMPUTER
02:18:45 <pikhq> I've been coding for half of my life. :)
02:18:54 <CakeProphet> ...meh... a month.
02:19:35 <CakeProphet> Logical thinking kind of annoys me... actually.
02:19:43 * CakeProphet hates tidiness and exactness.
02:20:02 * RodgerTheGreat relishes in tidiness and exactness, he's just usually too lazy to create it.
02:20:15 * pikhq loves tidiness and exactness
02:20:25 <pikhq> It's been very helpful to me. . .
02:20:32 <CakeProphet> Yeah... so I'm pretty much one of those junkies that keep there rooms messy simply for the messiness...
02:21:01 <pikhq> And I anticipate it will continue to be helpful during my Calc class this year. . .
02:21:04 <CakeProphet> Neatness is... annoying for me anyways... and that seems like a good coder skill.
02:21:13 <pikhq> CakeProphet: I keep my room messy because it doesn't matter to me.
02:21:22 <CakeProphet> Well.. that too.
02:21:47 <CakeProphet> If you need spaghetti code....
02:21:58 <CakeProphet> I'd probably be good at that.
02:22:09 <pikhq> Then I can show you stuff I did 8 years ago.
02:22:16 <CakeProphet> Yummy
02:22:26 <pikhq> Mmm. Apple BASIC.
02:23:25 <CakeProphet> If you've been coding for so long.. and at that age... programming languages are probably near-natural to you...
02:23:37 <CakeProphet> I'm guessing that whole kids-learn-foreign-languages-easier applies to computer languages.
02:23:38 <pikhq> Depends upon the language.
02:23:45 <pikhq> Like I said, I'm a Tcler.
02:23:55 <pikhq> It really is almost native to me by now. . .
02:24:33 <CakeProphet> I'd hate thinking code all the time...
02:24:44 <CakeProphet> It's neato and all... but too much can be mentally exhausting.
02:26:01 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
02:26:23 * Sgeo had a knowledge of programming since I was quite young
02:26:38 <Sgeo> What was the year when VB5 was current?
02:27:13 <CakeProphet> !bf_txtgen A
02:27:21 <CakeProphet> :(
02:27:21 -!- preyalone has joined.
02:27:27 <Sgeo> Hi preyalone
02:27:27 <CakeProphet> GET EGOBOT BACK HERE
02:27:44 * Sgeo pokes question
02:27:51 <CakeProphet> !help
02:27:51 <EgoBot> 30 ++++++++[>++++++++>>><<<<-]>+. [25]
02:27:53 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
02:27:55 <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
02:27:56 <CakeProphet> Oh ho!
02:28:08 <BrainMachine> I'm here- I can evaluate BF...
02:28:27 <BrainMachine> <:/
02:31:32 <CakeProphet> !bf ++++++++[>++++++++>>><<<<-]>+>[-]>[-]<<[->+>+>+>+>+>+>+>+>+>+>+>+>+><<<<<<<<<<<<][.[-]>]
02:31:37 <CakeProphet> >.>
02:31:58 <EgoBot> realloc: Cannot allocate memory
02:32:31 <CakeProphet> !bf ++++++++[>++++++++>>><<<<-]>+>[-]>[-]<<[->+>+>+>+>+>+>+>+>+>+>+>+>+><<<<<<<<<<<<][.[-]>]
02:32:33 <CakeProphet> bastard
02:32:56 <EgoBot> realloc: Cannot allocate memory
02:32:58 <pikhq> !bf_txtgen CakeProphet sucks at Brainfuck.
02:33:04 <CakeProphet> :(
02:33:28 <CakeProphet> Hey man... that's like.. almost my first try at something.
02:33:38 * CakeProphet cries in the corner, "I can't do anything right..."
02:33:51 <CakeProphet> So.. any idea why that doesn't work?
02:35:00 <CakeProphet> !bf ++++++++[>++++++++>>><<<<-]>+>[-]>[-]<<[->+>+>+>+>+>+>+>+>+>+>+>+>+>][.<]
02:35:16 <EgoBot> 292 ++++++++++++[>+++>++++++>+++++++++>++++++++<<<<-]>>-----.>>+.<-.------.<+++++++++++++.++++++++++++++++++++++++++++++++++.---.+.>+++.---.<++++.<----.>-.++.>--.++++++++.++++++++.<<.>>>.<<-.<.++++++++++++++++++++++++++++++++++.>>-.>.++++++++.<<------.>>---.<+++.>---.<<---.<--------------------. [745]
02:35:18 <RodgerTheGreat> shameless random plug- visit my website! http://rodger.shadowarts.org/index.php
02:35:29 <CakeProphet> Whew! NO idea why it returned that.. but whoooo
02:36:04 <pikhq> !bf ++++++++++++[>+++>++++++>+++++++++>++++++++<<<<-]>>-----.>>+.<-.------.<+++++++++++++.++++++++++++++++++++++++++++++++++.---.+.>+++.---.<++++.<----.>-.++.>--.++++++++.++++++++.<<.>>>.<<-.<.++++++++++++++++++++++++++++++++++.>>-.>.++++++++.<<------.>>---.<+++.>---.<<---.<--------------------.
02:36:08 <EgoBot> CakeProphet sucks at Brainfuck.
02:36:18 <CakeProphet> :(
02:36:25 <pikhq> CakeProphet: That was the output from !bf_txtgen.
02:36:26 <CakeProphet> That's not very encouraging.
02:37:03 <pikhq> First rule of Brainfuck: it's not magic, it's merely weird as hell.
02:37:18 <CakeProphet> ....that didn't make any sense... and it's really not that weird.
02:37:25 <CakeProphet> Why would it be magic?
02:37:45 <Razor-X> Someone's been having a lot of fun, it seems.
02:38:01 <Razor-X> CakeProphet seems to have zero ability for low-level languages.
02:38:09 <CakeProphet> ...
02:38:19 <pikhq> You've been treating it like magic.
02:38:30 <Razor-X> Advice: Don't learn ASM -- ever.
02:38:31 <pikhq> Like, um. . . Putting random characters in. . .
02:38:56 <CakeProphet> ?
02:39:14 <CakeProphet> !bf ++++++++[>++++++++>>><<<<-]>+>[-]>[-]<<[->+>+>+>+>+>+>+>+>+>+>+>+>+>][.<]
02:39:19 <CakeProphet> No that was actually supposed to be something.
02:40:14 <pikhq> A hint: >>><<<< and < are exactly the same, except that >>><<<< takes up 6 additional characters.
02:40:29 <Razor-X> I'm 16 too, by the way.
02:40:34 <Razor-X> I learned BF when I was 14 though.
02:40:43 <Razor-X> First program I did was addition, IIRC.
02:41:16 <RodgerTheGreat> first program I ever wrote was a string inverter, followed by a simple crypto program.
02:41:25 <Razor-X> I didn't really get into Esolangs 'till I learned Verilog and thought of the Dream OISC machine.
02:41:44 <preyalone> sgeo: hi.
02:41:54 <Razor-X> I personally have very little experience with binary data, so I don't do much crypto/program-header type things. It's a sore point of mine I should work on.
02:41:55 <RodgerTheGreat> I stumbled into esolangs when I found a PalmOS-based BF interpreter called "acebf"
02:42:26 <preyalone> i've got an interpreter written in Python, but there are some bugs. anyone care to look?
02:42:28 -!- CakeProphet has quit (Read error: 113 (No route to host)).
02:42:33 <RodgerTheGreat> from there, I soaked up everything I could find.
02:42:45 <RodgerTheGreat> what is it an interpreter for?
02:42:53 <preyalone> bf
02:42:54 <RodgerTheGreat> BF?
02:42:56 <RodgerTheGreat> ah
02:43:00 * Razor-X claps.
02:43:02 <Razor-X> Heh.
02:43:02 <pikhq> Not that hard.
02:43:14 <preyalone> heh
02:43:26 <pikhq> Do it in BF.
02:43:27 <Razor-X> Did you enter the contest?
02:43:27 <RodgerTheGreat> writing a BF interpreter in a language is a great exercise in learning the language.
02:43:46 <Razor-X> Writing a BF interpreter in INTERCAL is like suicide.
02:43:55 <Razor-X> ;P
02:43:55 <preyalone> exactly. no, i didn't know of a contest.
02:44:07 <Razor-X> Awww. You can't enter then.
02:44:11 <Razor-X> Sorry bub.
02:44:22 -!- CakeProphet has joined.
02:44:30 <RodgerTheGreat> I don't understand why we have to lock contestants.
02:44:30 <preyalone> """A Brainfuck interpreter"""
02:44:33 <preyalone> __author__="Andrew Pennebaker (andrew.pennebaker@gmail.com)"
02:44:33 <preyalone> __date__="Nov 18 2005 - Feb 27 2006"
02:44:33 <preyalone> __copyright__="Copyright 2006 Andrew Pennebaker"
02:44:33 <preyalone> __license__="GPL"
02:44:33 <preyalone> __version__="0.5"
02:44:33 <preyalone> from aio import chomp
02:44:35 <preyalone> import sys
02:44:38 <preyalone> from getopt import getopt
02:44:39 <Razor-X> NO PASTING.
02:44:41 <preyalone> tape=[0]*100
02:44:41 <preyalone> address=0
02:44:42 <RodgerTheGreat> OH GOD
02:44:43 <Razor-X> STOP STOP STOP STOP.
02:44:45 <preyalone> def sublevel(toplevel):
02:44:48 <preyalone> i=0
02:44:48 <preyalone> # until a balanced-bracket code block is found, add a character
02:44:50 <RodgerTheGreat> PASTEBIN!
02:44:52 <preyalone> while toplevel[0:i+1].count("[")!=toplevel[0:i+1].count("]"): i+=1
02:44:52 <preyalone> return toplevel[1:i]
02:44:56 <Razor-X> You've been ignored, buddy.
02:44:57 <preyalone> def run(instructions):
02:44:57 <preyalone> global tape
02:44:57 <preyalone> global address
02:44:59 * RodgerTheGreat cries
02:45:02 <preyalone> position=0
02:45:02 <preyalone> while position<len(instructions):
02:45:07 <preyalone> cmd=instructions[position]
02:45:07 <preyalone> if cmd=="<": address-=1
02:45:11 <CakeProphet> MMmmPythonish
02:45:12 <preyalone> elif cmd==">": address+=1
02:45:12 <preyalone> elif cmd=="+": tape[address]+=1
02:45:12 <preyalone> elif cmd=="-": tape[address]-=1
02:45:17 <CakeProphet> ...
02:45:17 <preyalone> elif cmd==".": sys.stdout.write(chr(tape[address]))
02:45:17 <preyalone> elif cmd==",":
02:45:19 <CakeProphet> ...
02:45:22 <preyalone> try: tape[address]=ord(sys.stdin.read(1))
02:45:22 <preyalone> except: tape[address]=-1
02:45:22 <preyalone> elif cmd=="[":
02:45:24 <CakeProphet> ...
02:45:27 <Razor-X> Tell me when he's done, people.
02:45:27 <preyalone> level=sublevel(instructions[position:])
02:45:27 <preyalone> while tape[address]!=0: run(level)
02:45:27 <preyalone> position+=len(level)+1
02:45:29 <CakeProphet> ...
02:45:31 <preyalone> position+=1
02:45:31 <preyalone> def usage():
02:45:33 <CakeProphet> ...
02:45:36 <preyalone> print "Usage: %s [options] <sourcefile>" % (sys.argv[0])
02:45:36 <preyalone> print "--help (usage)"
02:45:39 <CakeProphet> ...
02:45:41 <preyalone> sys.exit()
02:45:41 <preyalone> def main():
02:45:42 <CakeProphet> ...
02:45:45 <preyalone> systemArgs=sys.argv[1:] # ignore program name
02:45:45 <preyalone> live=False
02:45:46 <CakeProphet> ...
02:45:48 <preyalone> optlist=[]
02:45:48 <preyalone> args=[]
02:45:49 <CakeProphet> ...
02:45:50 <Razor-X> My BF interpreter in INTERCAL has been indefinitely postponed, since I have a Japanese novel translation project on the horizon.
02:45:51 <preyalone> try:
02:45:54 <preyalone> optlist, args=getopt(systemArgs, None, ["help"])
02:45:54 <preyalone> except Exception, e:
02:45:55 <CakeProphet> ...
02:45:57 <preyalone> usage()
02:45:57 <preyalone> live=len(args)<1
02:45:57 * RodgerTheGreat continues to feel the lavalike pain...
02:45:59 <CakeProphet> ...
02:46:01 <preyalone> for option, value in optlist:
02:46:04 <preyalone> if option=="--help":
02:46:04 <preyalone> usage()
02:46:05 <CakeProphet> ....
02:46:08 <preyalone> if live:
02:46:08 <preyalone> print "--BF Interpreter 0.5--"
02:46:09 <CakeProphet> ...
02:46:13 <preyalone> print " Type exit to exit."
02:46:13 <preyalone> line="not exit"
02:46:14 <CakeProphet> ....
02:46:16 <Razor-X> You messed up CakeProphet.
02:46:17 <Razor-X> Twice.
02:46:18 <preyalone> while line!="exit":
02:46:18 <preyalone> sys.stdout.write("% ")
02:46:18 <preyalone> line=chomp(sys.stdin.readline())
02:46:19 <CakeProphet> ...
02:46:21 * RodgerTheGreat cries...
02:46:23 <preyalone> if line.count("[")!=line.count("]"):
02:46:23 <preyalone> raise "Unbalanced brackets"
02:46:23 <CakeProphet> ..
02:46:26 <preyalone> else:
02:46:26 <preyalone> run(line)
02:46:27 <CakeProphet> ....
02:46:29 <CakeProphet> ...
02:46:29 <preyalone> else:
02:46:29 <preyalone> src=args[0]
02:46:31 <CakeProphet> ..
02:46:32 <Sgeo> Hey, maybe pa can't stop it
02:46:33 <preyalone> srcfile=open(src, "r")
02:46:33 <preyalone> code="".join(srcfile.readlines())
02:46:35 <CakeProphet> ..
02:46:37 <preyalone> srcfile.close()
02:46:37 <preyalone> if code.count("[")!=code.count("]"):
02:46:38 <CakeProphet> ...
02:46:42 <preyalone> raise "Unbalanced brackets"
02:46:42 <preyalone> else:
02:46:43 <CakeProphet> ..
02:46:44 <Razor-X> Yeah, that's what he gets for being an idiot.
02:46:46 <preyalone> run(code)
02:46:46 <preyalone> if __name__=="__main__":
02:46:48 <CakeProphet> ..
02:46:51 <preyalone> main()
02:46:51 <preyalone> sorry
02:46:52 <CakeProphet> ..
02:46:55 <preyalone> i'll never do it again :-( *tear*
02:47:04 <Razor-X> A whole bunch of angry people talking in the middle of his code.
02:47:12 <RodgerTheGreat> http://www.rafb.net./ <- CARVE THIS INTO YOUR FLESH
02:47:22 <Sgeo> .net./?
02:47:30 <RodgerTheGreat> it works.
02:47:34 <Sgeo> http://pastebin.ca
02:47:49 <Razor-X> I assume he's done pasting because CakeProphet has stopped adding in his morse code every line.
02:48:09 <Sgeo> Razor-X: yes, preyalone has stopped
02:48:16 <CakeProphet> Is that C?
02:48:20 <Razor-X> Yup. I've unignored him now.
02:48:20 <preyalone> python
02:48:24 <CakeProphet> It looks too much like Python to be ... yeah
02:48:44 <CakeProphet> For a second I was thinking Python was just a clone of C....
02:49:00 <Razor-X> Is __blah__ a valid variable in Python?
02:49:05 <preyalone> yes
02:49:13 <preyalone> __var__s are special
02:49:19 <Razor-X> What is their function?
02:49:26 <CakeProphet> Depends
02:49:28 <CakeProphet> on the variable.
02:49:39 <preyalone> some, like __author__ is just convention by the coder
02:49:40 <Razor-X> What's the difference between a __var__ and a normal var?
02:49:46 <Razor-X> You're storing metadata in variables?
02:49:51 <preyalone> meh
02:49:54 <Razor-X> You're wasting good memory for metadata?!
02:50:00 <CakeProphet> __iter__ does some fancy iteration shit that I don't understand.
02:50:03 <CakeProphet> It really just dpeends on the variable.
02:50:04 * Razor-X deeply sighs.
02:50:22 <preyalone> object.__len__() is called when len() is called on an object: len(object)
02:50:36 <CakeProphet> A good example would be __init__ for classes.
02:50:40 <Razor-X> Ah. So it's an accessor.
02:50:57 <CakeProphet> __init__ is the function used in a class to define all of its local variables.
02:51:08 <Razor-X> Ah.
02:51:23 <Razor-X> That brings up my point again: You're wasting memory on metadate. Don't.
02:51:24 <CakeProphet> def __init__(self): self.blah = "teheee"
02:51:36 <CakeProphet> __init__ isn't metadata.
02:51:43 <Razor-X> *metadata
02:51:48 <Razor-X> That was for preyalone up there.
02:51:52 <preyalone> python likes the metadata: doc strings
02:52:03 <Razor-X> Oh. So this is specifically for documentation?
02:52:19 <preyalone> triple quotes are multiline doc strings
02:52:25 <CakeProphet> Yeah... triple-quotes is doc strings... which are used in a number of PYthon's doc generators.
02:52:43 <Razor-X> They seem like double-quotes to me :P
02:52:53 <CakeProphet> like the help() function prints out all the doc strings... really convient actually..
02:53:42 <preyalone> does anyone else have python and a helloworld.bf to test this on?
02:53:52 * CakeProphet has python.
02:53:56 <CakeProphet> But... not bf
02:54:11 <preyalone> or just make up your own bf..
02:54:18 <Razor-X> Paste the thing in pastebin. I don't want to comb out the ``<preyalone> '' from each line, even if it is using a Regex.
02:54:32 <preyalone> got it
02:55:00 <Razor-X> For that matter, I should work on another two pages of the novel. To the Japanese book, whoosh!
02:55:12 <Razor-X> And I wish all our contestants well.
02:55:18 <RodgerTheGreat> cya
02:55:23 <CakeProphet> Any bf compiler I make will use different characters.
02:55:28 <CakeProphet> I don't want to have to hit shift at all while using it.
02:55:52 <CakeProphet> Might implement the keypad.
02:56:02 <RodgerTheGreat> fine, but your submissions MUST be in actual BF.
02:56:22 <Razor-X> I'd just make a Ruby script to execute an xmodmap script to change my keyboard to a BF layout and hook that into a Ratpoison shortcut, if I really cared about hitting Shift.
02:56:45 <CakeProphet> 6 = > 4 = < 8 = + 2 = -
02:57:00 * RodgerTheGreat codes in BF on his palm, and then transfers it to his mac.
02:57:08 <CakeProphet> and then keep [] and maybe change 1 to input and 3 to output
02:57:09 <preyalone> pastebin.com del.icio.us'd
02:57:29 -!- ivan` has quit (" HydraIRC -> http://www.hydrairc.com <- Try something fresh").
02:57:49 <CakeProphet> And then I'll just have the compiler translate it all to the usual BF characters when finishes.
02:58:23 <Razor-X> Not our problem :D.
02:59:05 <RodgerTheGreat> hell, you can code with a biofeedback brain monitor, if that's how you get your jollies.
02:59:34 <preyalone> a literalist's interpretation of brainfuck
02:59:41 <RodgerTheGreat> lol
02:59:44 <RodgerTheGreat> indeed
02:59:53 <CakeProphet> I could take the windows approach and make a user-friendly GUI
03:00:01 <CakeProphet> that... is a bit -too- user-friendly.
03:00:31 <CakeProphet> To the point that the friendliness is just annoying...
03:00:40 <CakeProphet> _|_ >.< _|_
03:01:05 <preyalone> automatic UML.. VisualBF.. BF++.. Drag&Drop BF
03:02:45 <pikhq> VisualBF++
03:03:15 <pikhq> With new features, like defining and accessing a GUI via stdin/out!
03:03:21 <pikhq> >:D
03:03:30 <Razor-X> Emacs is just fine for me.
03:04:17 <preyalone> stdbflib
03:04:27 <pikhq> Razor-X: There is no Editor but Emacs, and Linux is one of it's kernels.
03:04:43 <RodgerTheGreat> pico ftw!
03:04:54 <preyalone> i'd shout vi, but i'm too new to linux
03:05:05 <Razor-X> I've used both extensively.
03:05:31 <pikhq> I use either nano or Emacs.
03:05:51 <RodgerTheGreat> NANO
03:05:54 <pikhq> The use of Pico is a sin, since it is nonfree software.
03:06:02 <preyalone> Textpad. Woot demos.
03:06:25 <pikhq> preyalone: vi's usage is not a sin in the Church of Emacs.
03:06:30 <pikhq> It is nothing more than a penance.
03:06:33 <preyalone> :0
03:06:40 <RodgerTheGreat> I have both on my computer, both were preinstalled.
03:06:56 <preyalone> Gedit, with its mery-go-round of tabs
03:07:07 <pikhq> My system came with Python & a build environment preinstalled. . .
03:07:10 <pikhq> And nothing else.
03:07:12 <Razor-X> My screen session starts up ``emacs -nw''.
03:07:22 <preyalone> DrPython. But only for Python code.
03:07:30 <Razor-X> I chose *everything* that would come with my Slackware install.
03:07:47 <Razor-X> Bloody thing wanted to forego zsh for tcsh. Ew.
03:07:57 <RodgerTheGreat> ok, here's a question- does anyone use a shell *other* than bash on a regular basis?
03:08:01 <pikhq> My screen session starts up zsh; I use zsh, the Emacs of shells, a bit more than Emacs proper. . .
03:08:02 <preyalone> I didn't get to choose what Ubuntu 6 installed >:(
03:08:04 <pikhq> I do.
03:08:06 <Razor-X> I use zsh.
03:08:13 <pikhq> Mmm. Zsh.
03:08:48 <pikhq> Bash is just a bit. . . limiting now.
03:08:53 <Razor-X> pikhq: Mine actually starts up with an assortment of stuff.
03:09:00 <Razor-X> ``emacs -nw'' is one of them.
03:09:04 <pikhq> Razor-X: I should probably set that up.
03:09:12 <Razor-X> Du it.
03:09:16 <pikhq> Currently, it just starts up a shell in 0.
03:09:28 <preyalone> Command prompt, featuring case-insensitivity and many colors to choose from.
03:09:29 <pikhq> You know, I actually kind of like it that way, though. . .
03:09:51 <Razor-X> Fine. Don't complain when you get RSI like me, though ;).
03:09:56 <pikhq> Everything but irssi is started on an ad-hoc, as-needed basis.
03:10:04 <CakeProphet> So...
03:10:13 <Razor-X> Emacs *is* my IRC client, like other things.
03:10:24 <Razor-X> *among other things.
03:10:28 <CakeProphet> What if I made a brainfuck clone that had worked inside of a string instead of an array?
03:10:34 <pikhq> Meh. Wasn't crazy about ERC.
03:10:46 <Razor-X> I love it to death.
03:10:46 <pikhq> CakeProphet: What would be the difference?
03:10:54 <preyalone> no ints, only chars
03:10:55 <CakeProphet> It would be in a string instead of an array.
03:10:59 <CakeProphet> >.>
03:11:07 <CakeProphet> No... ints would work.
03:11:12 <CakeProphet> They would just be a string.
03:11:16 <Razor-X> CakeProphet: ......
03:11:22 <preyalone> define string.
03:11:23 <Razor-X> CakeProphet: Strings are ARRAYs of characters.
03:11:30 <CakeProphet> Yup.
03:11:33 <pikhq> preyalone: It's normally bf8, which is done in an array of chars. . .
03:11:41 <Razor-X> I know my reasoning is profound. No need to flatter me.
03:11:48 <CakeProphet> See the difference?
03:11:56 <Razor-X> No.
03:11:59 <pikhq> An array of chars versus an array of chars.
03:12:01 <CakeProphet> Bastard
03:12:03 <Razor-X> Ints are characters.
03:12:10 <pikhq> So totally different!
03:12:21 <Razor-X> If you ask for input and give `4', it's ASCII value stores.
03:12:36 <preyalone> it's however the interpreting environment chooses to do it
03:12:48 <Razor-X> Standard BF specification demands it.
03:13:20 <CakeProphet> So.... an associative array?
03:13:28 <CakeProphet> That's like... tons of difference.
03:13:44 <pikhq> Again: What's the difference from the code's standpoint?
03:13:52 <CakeProphet> Everything
03:14:00 <preyalone> "..demands it." I didn't know BF was so authoritative.
03:14:01 <pikhq> No, from the BF code's standpoint.
03:14:06 <CakeProphet> Now he's working in an array with keys... instead of anarray with indexes.
03:14:10 <CakeProphet> Everything.
03:14:18 <CakeProphet> Now his ">s" are moving keys... instead of indexes.
03:14:23 <pikhq> And the key is treated just like an index, so. . .
03:14:27 <Razor-X> ........................................................................................................................
03:14:28 <preyalone> Lua uses hash tables instead of plain arrays.
03:14:45 <Razor-X> In C, there *are* no keys.
03:14:45 <preyalone> But they start at 1. Bastards.
03:14:57 <Razor-X> So you use a case statement to match strings to array indices.
03:15:09 <Razor-X> Fascinating, no?
03:15:10 <CakeProphet> Yup.
03:15:20 <Razor-X> So it's logistically equivalent.
03:15:24 <CakeProphet> NOpe
03:15:30 <CakeProphet> :D
03:15:35 <preyalone> That's how a CDict would be made.
03:15:37 <CakeProphet> Now his ">s" are moving keys... instead of indexes.
03:15:39 <CakeProphet> Big difference.
03:15:55 <pikhq> So, instead of array[1] to array[2], you do array[one] to array[two].
03:16:01 <pikhq> What the hell is the difference?
03:16:03 <CakeProphet> Yup
03:16:06 <CakeProphet> Everything
03:16:07 <preyalone> But keys don't necessarily have an order.
03:16:23 <pikhq> preyalone: But using > and < implies an order.
03:16:35 <Razor-X> .....
03:16:35 <preyalone> How is the order to be determined?
03:16:42 <CakeProphet> Magic
03:16:46 <Razor-X> ...............
03:16:48 <pikhq> By the interpreter.
03:16:52 <Razor-X> IT'S A TAPE. A SEQUENTIAL TAPE.
03:16:57 <Razor-X> :P
03:17:00 <CakeProphet> AWESOME
03:17:01 <CakeProphet> TELL ME MORE
03:17:09 <Razor-X> You move a sequential tape to the right, or to the left. Based on current index.
03:17:17 <CakeProphet> Razor-X, bUT NOW THE SEQUENTIAL TYPE IS MOVING KEYS.. INSTEAD OF --
03:17:25 <RodgerTheGreat> right == increment, left == decrement
03:17:28 <pikhq> From the BF code's standpoint, array==tape==associative array==string==kindergarten cubbies
03:17:38 <Razor-X> That's all that *matters*. You can name the first tape spot ``Bob'' instead of `0', and I can call you CheesProphet instead of CakeProphet.
03:17:41 <preyalone> For the BF programmer to create new keys, strings, not single characters would have to be stored in the cells.
03:17:48 <pikhq> HOWTO: use associative arrays instead of arrays for BF.
03:17:56 <pikhq> sed s/indexes/keys/
03:18:13 <CakeProphet> Hmmm..
03:18:34 <Razor-X> preyalone: Oh, one string per cell?
03:18:38 <CakeProphet> Would it cut down on memory to just use a single variable that contains a big long integer as the "array"?
03:18:51 <preyalone> cakeprophet: oh yeah
03:19:09 <Razor-X> CakeProphet: You mean concatenating integers together?
03:19:19 <preyalone> Concatenating bytes together
03:19:24 <CakeProphet> Then have a second variable called "pointer" which is essentially just a multiple of 10
03:19:41 <pikhq> I fail to see how it would cut down on memory (assuming C). . .
03:19:45 <Razor-X> CakeProphet: Yeah, C programmers do it all the time.
03:19:54 <Razor-X> Although not for cutting down on memory.
03:19:55 <pikhq> An array is, after all, just a solid block of memory. . .
03:20:02 <preyalone> This would have to be called BF--! Want to see the interpreter.
03:20:03 <Razor-X> Because you're essentially malloc'ing the same amount of space.
03:20:27 <CakeProphet> For some reason I imagine a single variable to be way l;ess memory than a big array.
03:21:11 <preyalone> As said above, the tape can be anything that has multiple cells for bytes.
03:21:14 <pikhq> Let's say you have a huge-ass array storing 10^100.
03:21:36 <pikhq> In C, that's just a solid, contiguous block of memory.
03:21:45 <preyalone> We're coding the array from scratch.
03:22:02 <pikhq> Now, to do the same with a bignum variable. . . We've got a huge-ass solid, contiguous block of memory.
03:22:03 <CakeProphet> ">" = pointer * 10 "<" = pointer/10 "+" = array + pointer "-" = array - pointer.
03:22:33 <pikhq> ">" == pointer++;
03:22:41 <pikhq> "<" == pointer--;
03:22:46 * CakeProphet doesn't know what that is.
03:22:59 <CakeProphet> I'm a Python junkie. *nod*
03:23:09 <preyalone> Does the GPL bf interpreter do this?
03:23:23 <pikhq> In C, that moves the pointer in the large, malloced space.
03:23:36 <pikhq> Basically, we define a solid, large block of memory.
03:24:10 <preyalone> CakeProphet: You must learn the way of C.
03:24:13 <CakeProphet> Seems way easier to code it as a integer than as an array... even if less memory efficient. *nod*
03:24:14 <pikhq> This large block uses up as much space as we ask for it to, plus the space required to store the pointer into it.
03:24:21 <Razor-X> Python *is* made from C, so essentially, an array *is* a memory space.
03:24:47 <Razor-X> What is an array? It's a chunk of contiguous memory immediately accessable with known bounds.
03:25:18 <pikhq> An array, in C, is little more than a thin abstraction on top of the usage of malloc and pointers.
03:25:54 <Razor-X> So if you want an array of 5 integers, you malloc a space of sizeof(int)*n, where n is the number of integers you want in the array.
03:26:02 <pikhq> char array[5]; is identical to char *array = (char *)malloc(5);
03:26:08 <preyalone> Yeah. So does the official interpreter do this?
03:26:21 * CakeProphet doesn't know what malloc is..
03:26:22 <Razor-X> Instead of referencing each array point by index, you increment the pointer.
03:26:27 <preyalone> memory allocate
03:26:36 <pikhq> CakeProphet: It allocates a contiguous block of memory.
03:26:37 <Razor-X> It takes a chunk of memory and well, allocates it.
03:26:50 <CakeProphet> Isn't that what assigning variables does?
03:27:01 <Razor-X> Yes. But assigning a variable *uses* malloc.
03:27:13 <CakeProphet> Then why use malloc?
03:27:27 <preyalone> We're going to the deeper levels of how programming works.
03:27:38 -!- ivan` has joined.
03:27:41 <Razor-X> Because C was made so shoddily that after you reach a certain infantile place in your coding, you *need* to use malloc and shed off abstractions like variable declaration.
03:27:47 <pikhq> It's a lower-level idea of how it all works. . .
03:28:03 -!- ihope_ has joined.
03:28:07 <Razor-X> For example, let's say you want to take in input from your user and want the input to be at most 192 characters long.
03:28:25 <pikhq> Razor-X: That's simply because C was designed for system coding, where you *need* malloc, no matter what language you're using.
03:28:37 <Razor-X> pikhq: I still don't see the need to partially abstract the language.
03:28:46 <Razor-X> pikhq: Give a person malloc from the beginning.
03:28:49 * CakeProphet clings to Python.
03:29:01 <CakeProphet> Yeah... I don't really like C...
03:29:03 <preyalone> Dude, learn other languages.
03:29:13 * CakeProphet is learning BF... kinda
03:29:28 <Razor-X> In order to save space, you first make a default buffer size and immediately malloc the default size. Then you check the input against the size of the buffer and expand the buffer as neccessary, unless it exceeds the amount of space you want your buffer to immediatley stop it.
03:29:29 <preyalone> I mean.. real languages :) hehe
03:29:42 <CakeProphet> BF is a real language./
03:29:55 <Razor-X> I can show you the ASM abstraction and the bus-level abstraction, if you wish ;).
03:30:04 <pikhq> CakeProphet: Tcl, my language of choice, tastes best with some C spicing blended in. . .
03:30:06 <Razor-X> And the gate-level one. At which point my knowledge ends.
03:30:08 <pikhq> ;)
03:30:14 <preyalone> C, Java, Ruby, assembly
03:30:29 <CakeProphet> Python.... uh.... JumpROPE :D
03:30:36 <Razor-X> I know a whole bunch. C, Haskell, and Ruby are my strongest.
03:30:50 <pikhq> C, Tcl, and. . . Yeah.
03:30:53 <preyalone> Ruby fucks with my head, which is why I'm pursuing it.
03:30:54 * pikhq should pick up Lisp
03:31:02 <Razor-X> Ruby is easy!
03:31:17 <Razor-X> Go functional with Lisp and Haskell. That's *really* hard. Ruby is really really simple.
03:31:24 <preyalone> So explain symbols in five, plain words.
03:31:24 <Razor-X> Really really really (... repeat ... ) really simple.
03:31:32 <Razor-X> Lisp symbols?
03:31:35 <preyalone> sure
03:32:05 <Razor-X> An identifier that represents objects.
03:32:09 <Razor-X> :D
03:32:20 <preyalone> identifier? que?
03:32:32 <Razor-X> Oh come on >_>.
03:32:49 <preyalone> a variable matches that definition
03:33:06 <Razor-X> Lisp has no variables.
03:33:12 <Razor-X> It has only symbols.
03:33:14 <preyalone> really?
03:33:18 <Razor-X> Yes.
03:33:44 <pikhq> Variables can be varied. Lisp, being purely functional, doesn't do that.
03:33:54 <Razor-X> Not purely.
03:33:57 <Razor-X> Only Haskell is pure.
03:34:02 <pikhq> Razor-X: You know what I mean.
03:34:07 -!- CakeProphet has quit (Read error: 104 (Connection reset by peer)).
03:34:07 <Razor-X> The logistic difference is that Lisp symbols are generated for many many things, including macros and functions.
03:34:18 <preyalone> (+ confusion myself)
03:34:31 <Razor-X> Exactly ;).
03:34:51 <preyalone> Have you read Why's Poignant Guide to Ruby?
03:34:51 <Razor-X> Remember. Functional languages should not have variables, by definition.
03:34:58 -!- CakeProphet has joined.
03:35:02 <Razor-X> No. I didn't like the Poignant Guide at all.
03:35:13 <Razor-X> I read the reference manual in the back of the Pickaxe.
03:35:18 <pikhq> (josiah like (+ sexps unconfusion))
03:35:42 <Razor-X> Then I read the chapters of the stuff that's Ruby specific for a bit more background. A reference manual is all I need to learn a language.
03:35:47 <CakeProphet> HMmmm
03:35:49 <CakeProphet> I think I got cut off before my last send went through
03:35:55 <Razor-X> (Except Lisp *shudder*. Those 4 days were he**.)
03:35:59 <preyalone> Python will take all of Ruby and LISP and add it to v3.
03:36:12 <pikhq> Elisp.
03:36:15 <preyalone> Java for Dummies did it.
03:36:19 <Razor-X> Python will add Lisp?
03:36:30 <preyalone> Python is becomming more lisp-like, they say.
03:36:35 <preyalone> They added metaclasses..
03:36:37 <pikhq> Python will take all of Ruby and Lisp, and remove everything it has in common from v3.
03:36:39 <preyalone> (ruby)
03:36:40 <Razor-X> I know Python has lambda expressions. But Python must get rid of variables.
03:36:46 <Razor-X> Python has higher-order functions?
03:36:49 <pikhq> Then, they will add more pointlessly confusing grammer.
03:37:11 <CakeProphet> Yeah
03:37:20 <Razor-X> I still can't see the point of a lambda expression in an imperative language.
03:37:22 <pikhq> Replacing the ( and ) with various whitespace characters, in the name of simplicity.
03:37:53 <preyalone> Ruby syntax is a bit wierd compared to Python. Some makes sense; symbols use colons, so indexes must not use colons.
03:37:59 <CakeProphet> It's sort of multi-paradigm.. although it's mostly imperitive.. it's also designed to be able to do OO and functional if you want.
03:38:03 <preyalone> I love the lambda.
03:38:20 <Razor-X> What's the logistic point of lambda if you don't have a higher order function?
03:38:37 <preyalone> Store a few in a list (cryptographic hasher calls them in order).
03:38:57 <Razor-X> Oh. Short functions?
03:38:59 <Razor-X> I guess.
03:39:16 <preyalone> Just return me a value.
03:39:17 <Razor-X> A lambda's real power comes in a higher order function, IMO.
03:40:01 <Razor-X> See. Functions are most fun when they don't return a value. *That's* the power of lambda.
03:40:06 * CakeProphet has considered learning PErl.
03:40:23 <preyalone> Perl = good. Perl == bad.
03:40:38 <preyalone> Regex, Unix admin. OO stinks.
03:41:00 <Razor-X> Most OO i need out of a language is a struct.
03:41:24 <CakeProphet> OO is amazingly flexible... given its tidiness.
03:41:27 <preyalone> dictionary of variables. player={"hp":40, "name":bob}
03:41:53 <Razor-X> Yup. A struct.
03:41:56 <pikhq> C++ is actually a rather nice language (largely because of it's OO).
03:42:09 <preyalone> Python is C+++.
03:42:12 * RodgerTheGreat blew his mind learning LISP once.
03:42:20 <Razor-X> RodgerTheGreat: I did too, but I didn't give up.
03:42:21 <pikhq> Python is C++--;
03:42:32 <Razor-X> 4 days, 8 hours a day, it finally clicked.
03:42:34 <RodgerTheGreat> that language should be considered an esolang
03:42:42 <Razor-X> pikhq: I like C++ more because they do some things correctly.
03:42:53 <Razor-X> RodgerTheGreat: Why? It makes perfect sense if you started with it.
03:42:53 <RodgerTheGreat> I didn't give up, it was just stranger than most languages I've used.
03:43:01 <pikhq> Razor-X: It's other improvements on C is also rather nice. :)
03:43:04 <RodgerTheGreat> isn't everything that way?
03:43:08 <preyalone> CPython is C++--. Jython is a small, nimble kid sitting on drunk santa's lap.
03:43:14 <pikhq> Crazy shit like "having an actual string datatype". :p
03:43:23 <Razor-X> What heck?!
03:43:44 <pikhq> Kidding.
03:43:46 <Razor-X> Lisp is lots of fun to program.
03:43:49 <Razor-X> Lots.
03:43:54 <Razor-X> Haskell is more, IMO.
03:44:04 <RodgerTheGreat> I thought LISP was interesting.
03:44:26 <preyalone> print " ".join(["Python", "is", "cool."])
03:44:32 <Razor-X> Gensyms and local binds were the things that threw me apart.
03:44:34 <RodgerTheGreat> interesting enough to get an interpreter for my palm. :D
03:44:40 * CakeProphet high gives preyalone.
03:44:49 <preyalone> heh.
03:45:07 <pikhq> puts [lappend "Tcl " "is " "better."]
03:45:13 <Razor-X> Actually, D is C+++.
03:45:22 -!- ihope has quit (Connection timed out).
03:45:24 <preyalone> Does Digital Mars own D?
03:45:36 <Razor-X> Kinda.
03:45:46 <preyalone> Tought so.
03:45:50 <Razor-X> There's a very well sponsored open effort going on already.
03:46:01 <CakeProphet> for x in ["Lol", "tcl", "sucks"]: print x
03:46:08 <Razor-X> putStrLn "Haskell is lots of fun"
03:46:23 <RodgerTheGreat> this is how I learned lisp: http://swiss.ai.mit.edu/classes/6.001/abelson-sussman-lectures/
03:46:52 <Razor-X> Oh. Lucky.
03:46:54 <preyalone> "Ruby is Python--".each do |x| print x
03:46:57 <RodgerTheGreat> they're pretty great.
03:46:58 <Razor-X> I used a set of 4 books or so.
03:47:04 <pikhq> foreach i {Python really sucks} {puts $i}
03:47:08 <RodgerTheGreat> found them in a slashdot posting by somebody.
03:47:26 <Razor-X> I learned of 'em a lot later.
03:47:31 <RodgerTheGreat> I've never done anything serious with it, but it was a valuable learning experience.
03:47:34 <Razor-X> I've been feeling recently like going back to the Lisp world.
03:47:44 <Razor-X> I hacked at StumpWM and learned that the ICCCM is a piece of hellspawn.
03:47:55 <Razor-X> Mind my language.
03:48:00 <preyalone> unless ruby_is_not_wierd? print "wtf"
03:48:08 <CakeProphet> ["memory" "of" "lot" "a" "use" "I"].reverse()
03:48:26 <preyalone> tru dat.
03:48:37 <CakeProphet> But at least its not a bitch to type :D
03:49:03 <preyalone> Python. Pseudocode. Hells yeah.
03:49:13 <CakeProphet> Python is really... just like pseudocode.
03:49:37 <preyalone> Btw, the Rubyists and I were thinking about an all-encompassing flame war last week.
03:49:43 <preyalone> Every language.
03:50:05 <RodgerTheGreat> hm.
03:50:33 <pikhq> foreach i {I don't use a lot of memory} {set temp [lappend $i $temp]};set i $temp;unset temp
03:50:35 <CakeProphet> I'm trying to find a second language to learn...
03:50:39 <CakeProphet> but nothing seems attractive.
03:50:43 <preyalone> Heh.
03:51:06 <CakeProphet> I'd use PErl... but it has those damn sigils...
03:51:18 * CakeProphet is that picky.
03:51:27 <preyalone> Are you a win, mac, unix user?
03:51:34 <CakeProphet> win
03:51:51 <preyalone> Nothing seems attractive in programming on a Win box.
03:51:53 <RodgerTheGreat> learn Java
03:51:55 * RodgerTheGreat ducks
03:52:04 <CakeProphet> javascript makes me cringe.
03:52:10 <preyalone> Java, not javascript
03:52:11 <RodgerTheGreat> Java != js
03:52:15 * CakeProphet knows.
03:52:22 <CakeProphet> I was... changing the subject.
03:52:23 <Razor-X> Java *shudder*.
03:52:25 <RodgerTheGreat> not even vaguely similar
03:52:36 <RodgerTheGreat> Razor-X: c'mon, it's not that bad.
03:52:50 <Razor-X> RodgerTheGreat: Yeah yeah. I'm just going by community swing.
03:52:54 <Razor-X> Not a bad language at all, in fact.
03:53:04 <preyalone> Java's going open source :).
03:53:13 <Razor-X> I just prefer C# for a small few quirks. And the Linux interpreter is a darn crawl.
03:53:21 <RodgerTheGreat> I've noticed that I seem to have picked the least possible combinations of languages and operating systems.
03:53:31 <Razor-X> C# or D is my vote if you want a nice empirical language.
03:53:33 <RodgerTheGreat> er, least *popular*
03:53:34 <preyalone> Like applescript in beos?
03:53:48 * CakeProphet wants a lazy language that he can be... lazy with.
03:53:50 <CakeProphet> I hate neatness.
03:53:54 <CakeProphet> !bf ,+[-.,+]
03:53:55 <Razor-X> Haskell is Lazy!
03:53:57 <Razor-X> It really is!
03:54:13 <preyalone> Java is better C, but it's not lazy coming from Python.
03:54:13 <RodgerTheGreat> learn PHP. there are NO variable types. whee!
03:54:32 <Razor-X> Ruby's typeless too, yeah.
03:54:39 <Razor-X> Functional languages *have* no variables :D
03:54:48 <preyalone> I love Python to death, but I'd rather teach first timers a typed language like Java or C.
03:55:24 <Razor-X> I wish someone wrote a Lisp->ASM compiler.
03:55:29 <CakeProphet> I'm having a really hard time time liking anything other than Python... :(
03:55:30 <Razor-X> That would be like heaven-on-a-bun.
03:55:47 <RodgerTheGreat> they actually made CPU's at one point that could run LISP natively.
03:55:50 <preyalone> CakeProphet: We'll learn Ruby, and it will better us.
03:55:53 <Razor-X> I know. It's crazy.
03:55:58 <RodgerTheGreat> now *that* is heaven.
03:56:00 <preyalone> woah.
03:56:03 <RodgerTheGreat> dedicated hardware.
03:56:03 <CakeProphet> preyalone, What's cool about Ruby?
03:56:18 <Razor-X> CakeProphet: Any language teaches you different things.
03:56:30 <preyalone> Yep. The new.
03:56:31 <Razor-X> C is invaluable to know simply for how the OS works at a low level.
03:56:43 <RodgerTheGreat> that's the beauty of esolangs- they teach you to challenge existing programming concepts.
03:56:44 <preyalone> Learn to at least read C/C++.
03:57:02 <preyalone> I can edit/compile simple C.
03:57:14 <Razor-X> My C is rusty.
03:57:15 <CakeProphet> But... C sucks...
03:57:25 <preyalone> My Python crypto stuff is mostly based on C.
03:57:28 <Razor-X> But with a bit of reference, I can probably write something not-too-shabby.
03:57:46 <Razor-X> CakeProphet: C sucks? The majority of OSs out there are made from C.
03:57:51 <preyalone> I've *actually* seen GOTO in a C program.
03:58:00 * Razor-X shudders.
03:58:27 <preyalone> Ever played Liero Xtreme? One exploit has it.
03:58:35 <Razor-X> It sucks, yes. But people like their particular brand of masochism. Love it, in fact.
03:58:57 <preyalone> Some love bf. Right? Right?
03:58:59 <Razor-X> IMO, ALGOL should've been the C of today.
03:59:16 <RodgerTheGreat> dbf... mmm...
03:59:19 <preyalone> Python was based on algol.
03:59:25 <preyalone> no?
03:59:26 <Razor-X> But then, C is simply lovely for some stuff (like device drivers).
03:59:35 <CakeProphet> Python was based on...
03:59:44 <preyalone> modulus2
03:59:47 <CakeProphet> Yeah
03:59:49 <CakeProphet> and ABC
03:59:51 <CakeProphet> and C
03:59:52 <preyalone> abc.
03:59:56 <Razor-X> preyalone: Take a look at ALGOL's syntax in Wikipedia.
04:00:10 <preyalone> en.wikipedia.org/algol
04:01:01 <Razor-X> Device driver writing in C is simply heaven.
04:01:03 * CakeProphet beginnings working on that... uh... fuzzy logic programming language.
04:01:16 <Razor-X> For Linux anyhow.
04:01:19 <CakeProphet> I should probably build some more on my playground concept.
04:01:37 <preyalone> omfg. algol.
04:01:39 <CakeProphet> For some reason... the idea of creating programming languages sounds more fun than programming.
04:01:48 <Razor-X> Heh.
04:01:56 <Razor-X> To me, reading a very girly Japanese novel is the MOST fun.
04:02:00 <preyalone> it's the most fun programming thing you can ever do.
04:02:02 <Razor-X> One I'm totally obsessed about in all forms.
04:02:14 <Razor-X> Interests differ ;)
04:02:14 * CakeProphet tends to like creating things rather than using them..
04:02:40 <preyalone> I took my bf interpreter and changed period to exclamation, comma to question mark, just to "make my own language"
04:02:49 <RodgerTheGreat> hm.
04:02:57 <CakeProphet> I've actually... considered use ! and ? for , adnd .
04:02:58 <Razor-X> preyalone: There are 1001 BF variations out there.
04:03:08 <RodgerTheGreat> that number seems low.
04:03:10 <preyalone> hehe
04:03:18 <Razor-X> And a whole bunch of unholy marriages of BF and *Funge.
04:03:26 <RodgerTheGreat> and how
04:03:50 * CakeProphet merges Perl with Python.
04:04:07 <Razor-X> I need to learn Perl for a new project of mine.
04:04:13 * lament merges YOUR FACE with MY FIST
04:04:17 <preyalone> Web programming?
04:04:23 <Razor-X> It's not nice to hit girls, lament :(.
04:04:24 <CakeProphet> Perl/Python merged sounds kinda... fun
04:04:30 <lament> Razor-X: sounds like a shitty project
04:04:33 <Razor-X> Nah. I'm horrible at that preyalone.
04:04:50 <lament> Razor-X: i was actually talking to CakeProphet
04:04:50 <preyalone> Have to use a Perl lib?
04:04:51 <RodgerTheGreat> what are you building with perl, Razor-X?
04:04:52 <Razor-X> lament: Well, I told the sysadmin not to install Ruby because my script would be the only one he used.
04:04:58 <lament> not sure what sex he is
04:05:14 <Razor-X> It's an auto-RSS-feed generator for manga releases for a manga translation group.
04:05:24 <preyalone> Ruby better be installed.. B/c sysadmins MUST use unix.
04:05:26 <RodgerTheGreat> ah- a neat idea.
04:05:59 <Razor-X> preyalone: But the rest of his scripts are written in BASH/Perl, no need to make a server box slower for one script.
04:06:10 <preyalone> herm.
04:08:56 <RodgerTheGreat> g'night everyone.
04:09:03 <preyalone> night. be back soon.
04:09:07 -!- preyalone has quit ("Leaving").
04:09:22 -!- RodgerTheGreat has quit.
04:09:29 <Razor-X> I'm off to read some Japanese. Remember to put heart into your presentations.
04:09:37 <Razor-X> s/presentations/submissions/
04:22:58 -!- CakeProphet has quit (No route to host).
04:28:51 <lament> as well as other organs.
04:33:21 -!- CXI has joined.
04:36:31 * Sgeo misread that as "hearts"
04:37:52 <Sgeo> Hi CXI
04:37:54 -!- CXII has quit (Connection timed out).
04:37:56 -!- EgoBot has quit (Success).
04:38:28 -!- EgoBot has joined.
04:43:34 -!- Arrogant has joined.
05:30:37 -!- Sgeo has quit ("Ex-Chat").
05:45:48 -!- ivan` has quit (" HydraIRC -> http://www.hydrairc.com <- The professional IRC Client").
06:16:43 -!- anonfunc has joined.
06:20:55 <Razor-X> No. Human heart tastes the best lament.
06:34:22 -!- GregorR-L has joined.
06:37:43 <Arrogant> I always thought human heart tastes the best in rice.
06:39:30 <Razor-X> Mmmm. Rice.
06:51:43 <GregorR-L> WHY ARLD NOT WORK >_<
06:51:51 -!- ivan` has joined.
07:26:22 -!- ivan` has quit (" Like VS.net's GUI? Then try HydraIRC -> http://www.hydrairc.com <-").
07:37:40 -!- ivan` has joined.
07:59:08 -!- GregorR-L has quit ("Chatzilla 0.9.73 [Firefox 1.5.0.6/2006072814]").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:02:31 -!- GregorR-W has quit (Remote closed the connection).
08:03:24 -!- GregorR-W has joined.
08:38:51 -!- ivan` has quit (" HydraIRC -> http://www.hydrairc.com <- The dawn of a new IRC era").
08:39:04 -!- ivan` has joined.
08:45:18 -!- ivan` has quit (Read error: 104 (Connection reset by peer)).
09:04:45 -!- sparrwork has quit (Read error: 104 (Connection reset by peer)).
09:20:53 -!- Arrogant has quit ("Leaving").
09:24:46 -!- CXII has joined.
09:30:58 -!- CXI has quit (Read error: 60 (Operation timed out)).
11:14:25 -!- jix has joined.
11:28:32 -!- tgwizard has joined.
11:51:02 -!- Sgeo has joined.
14:20:00 -!- CXII has quit (Read error: 110 (Connection timed out)).
15:07:45 -!- CXI has joined.
15:25:17 -!- anonfunc has quit.
15:27:29 -!- RodgerTheGreat has joined.
15:27:54 <RodgerTheGreat> 'lo
15:45:38 -!- tgwizard has quit (Read error: 110 (Connection timed out)).
16:02:34 -!- calamari has joined.
16:04:49 <RodgerTheGreat> bbl
16:09:41 -!- CXI has quit ("If you're reading this, it's probably xchat's fault.").
16:27:52 -!- calamari has quit ("Leaving").
16:37:51 <RodgerTheGreat> back
16:46:17 -!- tgwizard has joined.
16:49:10 <ihope_> Since ##quantum has been +i'd, there's now a ##quantum-noinvite that doesn't have +i on it.
17:03:23 <RodgerTheGreat> I can only assume that the general silence here this morning is because you're all working feverishly on your entries for the esoteric programming competition.
17:24:54 <Razor-X> It must be so.
17:33:43 -!- kmkr has joined.
17:34:36 <kmkr> hello
17:34:54 <kmkr> so, will someone answer to my questions i posted at esowiki? about the competition
17:36:54 <RodgerTheGreat> sure.
17:36:59 <RodgerTheGreat> what can we help you with?
17:37:35 <kmkr> http://esolangs.org/wiki/Talk:2006_Esolang_Contest
17:38:04 <kmkr> and, nice :)
17:38:14 <GregorR> IMHO, all of your questions are for-the-contestant-to-decide.
17:38:26 <RodgerTheGreat> well, I know that input formats were up to contestants to decide on.
17:38:39 <RodgerTheGreat> error handling is a plus, but not a requisite.
17:38:58 <kmkr> aha
17:38:59 <kmkr> ok
17:39:09 <kmkr> and eof isn't defined, either?
17:39:21 <RodgerTheGreat> and I don't see any problem in using an odd BF interpreter, as long as you include an interpreter your submission works with/ specify what it needs.
17:39:34 <GregorR> And it's /reasonable/ ^^
17:39:41 <kmkr> :D
17:39:43 <RodgerTheGreat> as long as we can run it, and it is in fact BF, it'll be fine.
17:39:47 <RodgerTheGreat> :D
17:39:51 <GregorR> x-bit [non]-wrapping [0|1|no change] on EOF all OK
17:40:19 <kmkr> well -- it makes a lot difference to use 1-bit and 700-bit interpreters.. :D
17:40:32 -!- CXI has joined.
17:40:39 <RodgerTheGreat> naturally. if you see an advantage to either, feel free.
17:40:49 <GregorR> IMHO, if we OK bignum interpreters, we'd OK 700-bit interps :-P
17:42:30 <kmkr> well. i prefer the 8-bit environment but in case it's allowed i may use a bignum interpreter, as it makes many things a lot easier -- and of course easier for others if i use something that's more difficult to program in ;)
17:42:43 <RodgerTheGreat> the general rule is simply that you need to include in your submission any details/etc that we'll need to use it.
17:43:13 <kmkr> hmm, was it that one needs to write a program for every task?
17:43:17 <RodgerTheGreat> including a reference interpreter written in a portable language would be nice, but is not required.
17:43:28 <RodgerTheGreat> no, but you can do several if you feel like it.
17:43:33 <kmkr> aha
17:49:51 <Razor-X> Make sure your interpreter is platform independant.
17:50:06 <Razor-X> That's a *must*.
17:50:20 <kmkr> what does that mean?
17:50:49 <Razor-X> That means, if you're writing the interpreter in Python for example, make sure a Python implementation on Mac OS X can run it equally as a Linux Python distribution as a Windows Python distribution.
17:52:09 <kmkr> aha.
17:52:11 <Razor-X> And (duh), make sure you don't violate the BF ``standard'' ;).
17:52:20 <Razor-X> Other than that, you *must* have fun :P.
17:52:26 <kmkr> :)
17:52:58 <kmkr> speaking of which, shouldn't there be some limit on the brainfuck environment? or is it really as we guessed few mins ago, that limitless memory goes
17:53:13 <Razor-X> See, I was thinking of that, but forgot to bring it up yesterday.
17:53:18 <kmkr> a
17:53:42 <Razor-X> RodgerTheGreat and GregorR: You wanna settle a set of standards for BF interpreters?
17:53:52 <RodgerTheGreat> hm.
17:55:47 <Razor-X> I say it meets these minimum requirements A) Infinitely long tape B) Supports only the basic BF commands (+-<>[].,) C) Wrapping cell-``width'' of however much you choose.
17:56:37 <kmkr> well, there are no bf commands except those :)
17:57:14 <Razor-X> The point is not to get people to use other standards ;).
17:57:22 <kmkr> aha. but the cells must be wrapping, so this kind of program would stop: +[+]
17:57:32 <kmkr> right?
17:58:44 <RodgerTheGreat> yes.
17:58:53 <kmkr> 'k
17:59:10 <RodgerTheGreat> and then EOF can work however you want it to.
17:59:15 <kmkr> aha, ok
17:59:26 <kmkr> and the image format, must it be some existing one?
17:59:53 <kmkr> (referring to that task..)
18:04:09 <Razor-X> Raw image.
18:04:16 <Razor-X> No format. That gets too thorny.
18:04:34 <kmkr> then what's the raw image?
18:04:43 <Razor-X> Bitmap.
18:04:52 <Razor-X> Of course, if you want to go the extra mile for *other* image types... ;)
18:05:09 <kmkr> is there specs for this bitmap?
18:05:28 <kmkr> link?
18:06:28 <GregorR> SO,
18:06:34 <GregorR> If EgoBF can interpret it, you're OK :P
18:11:37 <kmkr> hello? what a bitmap looks like on byte-level?
18:12:53 <GregorR> Oh, hi :-P
18:13:01 <GregorR> Make a pgm image and then cut off the header.
18:13:05 <lament> i bet none of the comittee members know
18:13:13 <GregorR> It's just a raw bitmap.
18:13:16 <GregorR> It's not complicated.
18:13:30 <lament> GregorR: then how would you tell the dimensions?
18:13:34 <kmkr> sigh..
18:13:45 <GregorR> lament: You don't. You prespecify the dimensions.
18:13:55 <GregorR> If you choose to use something bigger than the base, you may also choose to use a better format.
18:13:58 -!- smokecfh has joined.
18:14:00 <lament> doesn't sound like a useful format
18:14:02 <GregorR> But we set the baseline as a raw bitmap.
18:14:08 <GregorR> IT ISN'T A USEFUL FORMAT YOU FUCKING JACKASS
18:14:15 <RodgerTheGreat> the standard BMP format is not that complicated either. You could use that as an alternative.
18:14:35 <kmkr> i can't understand how this bitmap works! how do you define colours?
18:14:42 <kmkr> three bytes to form one rgb?
18:14:44 <kmkr> for one pixel
18:14:52 <RodgerTheGreat> lament: what part of "Esoteric Programming" made you think things are going to be outrageously useful?
18:14:56 <GregorR> kmkr: Our baseline was 8-bit greyscale. If you choose to be RGB, then yeah.
18:15:31 <kmkr> so that'd be a byte per pixel..
18:15:34 <GregorR> Yes.
18:15:36 <RodgerTheGreat> yes
18:15:45 <kmkr> and the program would only have to output that?
18:15:59 <kmkr> i can't understand how the dimensions work..
18:16:14 <kmkr> or is every pic 320x240?
18:16:23 <lament> is it left-to-right, top-to-bottom?
18:16:31 <lament> bottom-to-top, right-to-left?
18:16:45 <lament> right-to-bottom, left-to-top?
18:16:46 <GregorR> lament: Despite your groaning, raw bitmap is a well-defined format, so STFU.
18:17:03 <RodgerTheGreat> I'm going to have to go with gregor on this one.
18:17:07 <GregorR> L-R, T-B. The size is implementation-designed IF you choose to use raw bitmaps, or you can use whatever you want.
18:17:25 <GregorR> Erm, implementation-specific.
18:17:30 <kmkr> aha.
18:17:53 <lament> i don't really care, i'm not allowed to participate :)
18:18:00 <kmkr> :D
18:18:59 <kmkr> well, i guess it could be possible the program would receive the image dimensions as input, too.. and then output the correct amount of pixels, and then the committee would just check the pictures with some program and use the dimensions they input
18:19:09 <kmkr> or however you are going to see the pictures..
18:19:48 <GregorR> I'm making an example image right now.
18:24:10 <GregorR> http://www.codu.org/esocomp/ < rose.* = all valid example input. rose.raw is the baseline
18:25:08 <kmkr> what is baseline? what does it mean?
18:25:22 <GregorR> It's the absolute minimum an entry can support.
18:25:30 <kmkr> ah
18:25:39 <GregorR> It has to be able to either support that, or something more complicated than that.
18:25:46 <kmkr> yea
18:26:03 <kmkr> however, the program isn't supposed to take images as input?
18:26:08 <GregorR> Yes, it is.
18:26:18 <kmkr> oh. i thought it was something about converting ascii characters to a bitmap
18:26:22 <GregorR> Vice-versa.
18:26:45 <RodgerTheGreat> convert a bitmap to an ascii-art representation of that bitmap.
18:27:04 <kmkr> aah, it means that..
18:27:15 <kmkr> the entry wasn't too clear about it, at least not to me
18:33:29 <kmkr> so, an entry must support all those formats? bmp, png etc?
18:34:03 <Razor-X> No no. Raw bitmap is the baseline.
18:34:34 <kmkr> aha.. allright
18:34:36 <RodgerTheGreat> you must support one or more format.
18:34:48 <RodgerTheGreat> formats include raw
18:34:59 <kmkr> :)
18:35:04 <kmkr> well, that's logical ;)
18:37:56 <kmkr> hmmm.. what font we're using?
18:38:35 <RodgerTheGreat> I dunno... let's say courier.
18:38:55 <Razor-X> Isn't it just going to output raw text? How does it matter?
18:39:02 <kmkr> and should it only use characters 32-126 (or 127)?
18:39:20 <kmkr> it matters a lot what the characters look like!
18:39:42 <kmkr> it doesn't represent picture much if a black pixel is a character 32 or something
18:39:46 <Razor-X> Well, you're going to have to set the font to be universal in the rules RodgerTheGrea.
18:39:47 <kmkr> or '.'
18:39:53 <kmkr> and white "M"
18:40:05 <Razor-X> * RodgerTheGreat.
18:40:23 <RodgerTheGreat> hm.
18:40:31 <Razor-X> Yeah. Bub.
18:43:41 <RodgerTheGreat> can't we just let contestants decide? If they wimp out and use extended ASCII or some weird font, it'll look like crap compared to a proper job.
18:43:44 <kmkr> anyways, this is interesting challenge/idea, so i'll try my luck on this one. and likely on some other task as well
18:43:57 <kmkr> well, that might be good too
18:44:42 <kmkr> hmm
18:44:52 <kmkr> in any case you should define things better in the wiki article
18:45:14 <kmkr> or then declare that participants can decide about pretty much everything
18:45:35 <kmkr> is courier a good font?
18:45:39 <kmkr> for viewing ascii art
18:46:12 <RodgerTheGreat> anything monospaced traditionally works well. Courier is a monospace that everyone has.
18:46:45 <kmkr> ok
18:46:51 <kmkr> i guess i'll be using that, then
18:59:56 <RodgerTheGreat> bbl
19:46:07 -!- kmkr has left (?).
19:52:14 -!- ihope_ has changed nick to ihope.
20:16:21 <ihope> (a -> c) -> (a -> b) -> b -> c... mmh.
20:17:03 <ihope> Think (Void -> Void) -> (Void -> ()) -> () -> Void.
20:18:01 <RodgerTheGreat> back
20:20:02 <ihope> Hmm... is there really any thing that the contest committee would want to keep s3kr1t?
20:20:14 <ihope> s/any thing/anything/
20:21:35 <RodgerTheGreat> not that I'm aware of at the moment.
20:22:18 <ihope> Might as well demolish ##quantum-noinvite, then?
20:22:25 <ihope> And -i ##quantum, of course.
20:22:26 <RodgerTheGreat> yeah, I guess so.
20:22:53 <RodgerTheGreat> if we have any more dark secrets to worry about, we can always +i it again.
20:23:11 <ihope> Yep.
20:24:03 <ihope> Or I could grab ##secrets or something.
20:24:11 <RodgerTheGreat> ##DarkSecrets
20:24:35 <ihope> Hmm, that's better...
20:25:29 <lament> ...
20:35:58 <ihope> So are angles required in quantum computing?
20:43:52 -!- Sph1nx has joined.
20:53:28 -!- CakeProphet has joined.
21:02:31 -!- CakeProphet has quit (Connection reset by peer).
21:03:12 -!- CakeProphet has joined.
21:06:46 * ihope asks CakeProphet for a chocolate prophecy with vanilla frosting and three candles
21:07:36 <GregorR> CONGRATULATIONS IHOPE UR 3 YRZ OLD ROFLCOPTER
21:07:38 -!- CakeProphet has quit (Read error: 113 (No route to host)).
21:07:57 <ihope> No, silly, the cake was for you.
21:10:15 * RodgerTheGreat hears the distinctive bacon-frying sound of a successful burn.
21:10:16 -!- CakeProphet has joined.
21:14:47 <CakeProphet> Hmmmm
21:15:11 <CakeProphet> I wonder.... what about a programming language whose sole purpose was to create other programming languages that can be used for the task you want to handle?
21:17:51 <RodgerTheGreat> C?
21:17:52 <Razor-X> Lisp can create other languages *easily*.
21:17:56 <Razor-X> Because of the nature of its REPL.
21:18:02 <RodgerTheGreat> LOGO!
21:18:10 <Razor-X> NO!1111
21:18:17 <Razor-X> STAY BACK, FIEND!!!111!!!
21:18:33 <RodgerTheGreat> logo is just lisp on crack with a turtle.
21:19:39 -!- CakeProphet has quit (Nick collision from services.).
21:19:46 <RodgerTheGreat> it's a significantly more complete language than most people think at first.
21:19:55 -!- CakeProphet has joined.
21:28:23 -!- CakeProphet has quit (Read error: 113 (No route to host)).
21:28:45 -!- CakeProphet has joined.
21:29:56 <CakeProphet> Wow that's a really good idea.
21:30:08 <CakeProphet> Making functions as lists.
21:36:16 <CakeProphet> That's how you would change functions...
21:36:19 <CakeProphet> Brainstorm!
21:36:35 <CakeProphet> Who was working on that synthesys language?
21:36:47 <CakeProphet> Might have been GregorR-W or RodgerTheGreat.
21:36:56 <RodgerTheGreat> me
21:38:03 <CakeProphet> RodgerTheGreat, Just make every line of the function have an index.
21:38:31 <CakeProphet> ThisFunction[indexoflineinfunction]
21:39:02 <CakeProphet> Thisfunction[2] = "4 + 4"
21:39:38 <RodgerTheGreat> hm.
21:39:44 <CakeProphet> And then to keep everything easy to find... have functions defined like a list.
21:40:13 <RodgerTheGreat> like, each element would be a token?
21:40:24 <CakeProphet> I dunno... I forgot what a token is.
21:40:31 <RodgerTheGreat> hm.
21:40:45 <CakeProphet> Funcs scould be defined something like this
21:41:40 <CakeProphet> ThisFunction(blah, mehblah) = {line1, line2, line3, line4, line5}
21:41:47 <CakeProphet> Or something similar.
21:42:17 <CakeProphet> Each line would have an index *nod* So it could be changed with a variable assignment.
21:42:31 <RodgerTheGreat> hm. that could be a handy way to do it.
21:42:47 * CakeProphet got the idea from reading about Lisp.
21:42:51 <RodgerTheGreat> the way I was working on it earlier saw each function as a character stack.
21:42:59 <CakeProphet> Strange how eye-opening learning a new language can be.
21:43:08 <RodgerTheGreat> so you could push and pop commands and such.
21:43:24 <RodgerTheGreat> well, LISP is a pretty eye-opening language.
21:43:25 <CakeProphet> A character stack?
21:43:33 <RodgerTheGreat> yes. a stack of characters.
21:44:24 <CakeProphet> You might be able to do weird stuff like call parts of functions only.
21:44:31 <CakeProphet> For example.
21:44:32 <RodgerTheGreat> hm.
21:44:44 <RodgerTheGreat> I'll definitely consider it.
21:44:48 <CakeProphet> ThisFunction[2:3](some params, someparams2)
21:45:09 <CakeProphet> I'm sort of mixing lisp with Python... I'm getting some crazy ideas :D
21:46:00 <CakeProphet> So if you needed to use only a certain piece of the function... but didn't want it to run through other specific bits... you could just specify what section of the function you want.
21:46:17 <RodgerTheGreat> well, bbiab
21:46:25 <CakeProphet> Okay
21:47:48 * CakeProphet loves that idea.
21:48:11 <CakeProphet> Everything should have indexes
21:48:29 <CakeProphet> They're extremly powerful.
21:50:14 <CakeProphet> Another neat thing you could do... is to have a special datatype that lets you sign lines to a variable.
21:50:42 <CakeProphet> The datatype itself is a line of code...
21:51:54 <CakeProphet> So... then you could do stuff like "ThisFunction[2] = ThislineofCode"
21:52:10 <CakeProphet> ThislineofCode = if x == y:
21:54:33 <CakeProphet> meh = for x in blah
21:55:32 <CakeProphet> func[10] = meh
21:56:15 -!- smokecfh has quit (Remote closed the connection).
21:57:11 <CakeProphet> If that datatype were implemented... a goto command would actually be useful without being bugtastic.
21:57:17 <CakeProphet> goto meh
21:57:25 <CakeProphet> Well.. no
21:57:42 <CakeProphet> That wouldn't work.. because meh isn't a specific thing.. it's a variable that occur several times in the program.. so nevermind.
21:57:58 <CakeProphet> goto meh could be five or six different lines.
21:58:02 -!- macgeek has joined.
21:58:37 <CakeProphet> Maybe even come up with a way to index indivudal lines of the function.
21:58:42 <CakeProphet> "extended index syntax"
21:59:16 <CakeProphet> ThieFunction[3[4:5]] = "lol some new code that alters the function."
21:59:45 <CakeProphet> And make functions iterable...
22:00:01 <CakeProphet> for ThisVariable in ThisFunction: ThisVariable = ThisSecondVariable.
22:00:31 <CakeProphet> You could essentially change all occurances of one variable in the function with another one... with just a line or so of code.
22:04:56 <CakeProphet> And then you could create a ton of useful functions for dealing with other functions... like a swap() function.... which essentially takes two values and swaps them around.
22:05:26 <Razor-X> How are our contestants doing today?
22:05:29 <CakeProphet> swap(ThisFunction[1]. ThisFunction[2]) Would swap line1 of the function with line 2 of the function
22:05:32 <CakeProphet> Meh.
22:05:48 <CakeProphet> Other than getting a huge flood of brainstorms just from reading the Wikipedia article on Lisp... doing uh.. bored.
22:06:15 <ihope> Done anything functional before?
22:06:31 <CakeProphet> Nope
22:06:32 <Razor-X> I think this is his first time.
22:06:48 <Razor-X> Because he's thinking about variables and functions at the same time.
22:06:55 <CakeProphet> I can do functions... and they're handy and all... but I've never used a functional language.... not a pure one.
22:07:19 <CakeProphet> Meh... in Python functions -are- variables... the possibility of having that flexibility isn't out of reach.
22:07:19 <ihope> Yeah, learning Lisp seems to induce huge brainstorms :-)
22:07:33 <Razor-X> And brainaches too.
22:07:55 <Razor-X> CakeProphet: You mean that functions can be used as variables because they return a value?
22:07:58 <CakeProphet> So I'm getting all of the ideas from mixing my knowledge of Python's capabilities with a few ideas about Lisp.
22:08:08 <ihope> Razor-X: functions can be stored in variables.
22:08:14 <Razor-X> Oh.
22:08:23 <CakeProphet> Basically everything in Python functions like a variable.
22:08:29 <Razor-X> But if it's non-functional, what's the difference?
22:09:04 <ihope> Can you have two names to reference the same variable?
22:09:08 <ihope> In Python, that is?
22:09:12 <CakeProphet> List slices, lists, classes, objects, methods, functions, everything.
22:09:21 <CakeProphet> What do you mean?
22:09:46 <ihope> Like if x and y were the same variable, giving a value to x would give the same value to y.
22:09:47 <Razor-X> ihope: I don't think he knows about pointers and references.
22:09:54 <Razor-X> Yeah. You can, IIRC.
22:10:07 <ihope> Pah, pointers... :-)
22:10:09 <CakeProphet> Eh.. I don't know...
22:10:09 <Razor-X> That's what the default behavior of x = y is, too.
22:10:18 <CakeProphet> I could run Idle really quick and find out.
22:10:26 <Razor-X> (IIRC from a Python anti-rant.)
22:10:37 <ihope> So x = y then y = 3 will also assign x to 3?
22:10:48 <Razor-X> I believe so. It got this person in a huge anger.
22:10:56 <Razor-X> Because he thinks in only C-Logic (TM).
22:10:57 <CakeProphet> Oh... yeah it can do that.
22:11:05 * CakeProphet didn't know what you were asking.
22:11:14 -!- macgeek has changed nick to macgeek-.
22:11:38 <CakeProphet> >>> x = 2
22:11:39 <CakeProphet> >>> y = x
22:11:41 <CakeProphet> >>> y
22:11:42 <CakeProphet> 2
22:11:44 <CakeProphet> >>> x = 3
22:11:45 <CakeProphet> >>> y
22:11:47 <CakeProphet> 2
22:11:48 <CakeProphet> >>>
22:11:50 <CakeProphet> That's a little experiment I did with IDLE.
22:11:57 <Razor-X> Oh.
22:12:18 <ihope> So is it possible to do it such that assigning to y will assign to x, and assigning to x will also assign to y?
22:12:38 <CakeProphet> Hmmm... no
22:12:41 <CakeProphet> Er.. I dunno
22:12:57 <CakeProphet> For some reason I'm not understand what you're asking.. even though it seems so obvious what you're asking.
22:13:31 <ihope> It'd make x and y interchangeable with respect to assignments.
22:13:43 <CakeProphet> IDLE 1.1.3
22:13:45 <CakeProphet> >>> x = 2
22:13:46 <CakeProphet> >>> y = x
22:13:48 <CakeProphet> >>> y
22:13:49 <CakeProphet> 2
22:13:51 <CakeProphet> >>> x = 3
22:13:52 <CakeProphet> >>> y
22:13:54 <CakeProphet> 2
22:13:55 <CakeProphet> >>> y = 4
22:13:57 <CakeProphet> >>> x
22:13:58 <CakeProphet> 3
22:14:00 <CakeProphet> >>>
22:14:15 <CakeProphet> Assigning y to x just assigns y to what x returns at that given state.
22:14:29 <CakeProphet> After that... changing x does not affect y... and vice versa.
22:18:11 <CakeProphet> ihope, So you'd prefer having "y=x" mean that y equals whatever x equals throughout the entire run?
22:18:24 <CakeProphet> So if x were changed... y would be changed as well?
22:18:29 <ihope> Probably not y=x, but something like it.
22:18:57 <CakeProphet> Meh... seems not as flexible... but I only code in Python, so I'm just extremly used to how Python works.
22:19:05 <ihope> Does Python have pointers and stuff?
22:19:13 <Razor-X> Nope.
22:19:18 <CakeProphet> Probably not.. I've never heard of them used before brainfuck.
22:19:52 <CakeProphet> I think a mix of Python and Lisp would create an awesome language.
22:19:56 <ihope> Well, I'm talking about some special function or something that would make x and y point to the same location. They could be set to other locations later.
22:20:12 <ihope> And I think a mix of every language would be awesome :-)
22:20:28 <Razor-X> ALGOL is the one true language.
22:20:34 <Razor-X> Bub.
22:20:43 <CakeProphet> Cause Python can do some pretty neat stuffs with lists... so if -everything- were a list in Python... that would just be great.
22:20:56 <ihope> Mmh.
22:21:10 <Razor-X> Can Python work with higher-order functions?
22:21:18 <ihope> Razor-X: YEP.
22:21:22 <ihope> Erm, yep.
22:21:23 <lament> CakeProphet: that's really weird logic
22:21:30 <Razor-X> Oooh. Nifty.
22:21:33 <ihope> So you mean being able to use list operations on every value?
22:21:41 <CakeProphet> Yup
22:22:01 <CakeProphet> Like having indexes of a function.
22:22:04 <lament> CakeProphet: how would that help when dealing with integers?
22:22:23 <CakeProphet> *shrugs* It could be useful...
22:22:27 <CakeProphet> Never know.
22:22:35 <CakeProphet> Each index would be a place value...
22:22:35 <ihope> Cons, nil, and fold are the basic list operations.
22:22:48 <Razor-X> nil is an operation?
22:22:55 <ihope> It's a nullary operation :-)
22:23:00 <CakeProphet> Say you have a variable that returns an integer... but maybe you only want -part- of the integer.
22:23:02 <Razor-X> :P
22:23:21 <CakeProphet> ThisIntegerVariable[2:7]
22:23:30 <CakeProphet> Would return only some of the places in that integer.
22:24:13 <CakeProphet> And then with iterations you could do mad stuff like.
22:24:50 <ihope> class List l a | l -> a where cons :: a -> l -> l; nil :: l; foldr :: (a -> b -> b) -> b -> l -> b
22:24:57 <CakeProphet> ...
22:25:08 <CakeProphet> That... looks like absolute giberish to me.
22:25:11 <ihope> I think that'd allow a person to treat anything as a list in Haskell.
22:25:55 <Razor-X> Does Python have infinite lists?
22:26:03 <CakeProphet> *shrugs* I'm guessing so.
22:26:07 <CakeProphet> Don't see why not.
22:26:17 <lament> ...
22:26:18 <lament> dude
22:26:22 <lament> you know notihng about python
22:26:28 <lament> and here you're proposing plans to improve it?
22:26:45 <CakeProphet> Not improve Python... just make a totally separate language... No need to be rude.
22:26:48 <lament> To clarily the confusion a little:
22:27:06 <lament> 1) Python lists aren't cons cells, they're not linked lists at all
22:27:13 <Razor-X> Oh. Poop.
22:27:21 <CakeProphet> I -have- only been programming for a month...
22:27:28 <CakeProphet> And I've never heard of cons... so... :D
22:27:32 <ihope> You can cons a value to a Python list.
22:27:42 <CakeProphet> What's a cons?
22:27:45 <lament> 2) In Python you can take any object and give it a bunch of methods having special names, after which you can use the [] list accessing syntax on it
22:27:48 <ihope> CakeProphet: cons(a,[b,c,d]) = [a,b,c,d]
22:28:00 <CakeProphet> What does that... do?
22:28:09 <ihope> It sticks a value on the front of a list.
22:28:28 <CakeProphet> So.... List[0] = value ?
22:28:31 <ihope> Is [x,y,z] Python list syntax, or does Python use something else?
22:28:33 <lament> 3) Python lists aren't infinite, but because of point 2) you can construct them
22:28:57 <ihope> CakeProphet: yeah. The first element of that list is the value.
22:29:13 <Razor-X> How does the list correspond to the object?
22:29:51 <Razor-X> What's the fun of a list if it isn't linked? Sheesh.
22:30:00 <CakeProphet> ???
22:30:15 <CakeProphet> Yeah.... I really should read up on non-Python-specific crap.
22:30:16 <lament> A list is an object implementing a bunch of methods, most importantly __getitem__, which takes an integer index as an argument
22:30:18 <ihope> Lists constructed with just cons and nil.
22:30:21 <lament> (a python list)
22:30:33 <Razor-X> Oh. I see.
22:30:44 <lament> so you can have:
22:30:44 <ihope> foldr replaces the cons and the nil with somethign else.
22:30:46 <Razor-X> So it's just a clever list of object-generic functions specific to your object of choice.
22:30:48 <lament> class foo:
22:30:53 <lament> def __getitem__(self, x): return x
22:31:17 <Razor-X> Kind of like Ruby's attributes, kinda.
22:31:23 <lament> there you go, an infinite list, or in this case more appropriately a set of all objects :)
22:31:25 <CakeProphet> From what I understand... the whole of Python was coded so that each datatype is an object to a class...
22:33:54 <CakeProphet> Someone explain a linked list?
22:35:24 <lament> CakeProphet: A cons cell consists of a head and a tail, both of which could contain anything
22:35:35 <lament> for example, (1 2)
22:35:43 <lament> 1 is the head, 2 is the tail
22:36:02 <lament> in python this would be the tuple (1, 2)
22:36:17 <CakeProphet> Hmmm..
22:36:17 <lament> now we can put another cons cell in the tail
22:36:20 <lament> (1 (2 3)
22:36:22 <lament> )
22:36:41 <lament> 1 is the head, (2 3) is the tail
22:36:47 <lament> (1 (2 (3 4)))
22:36:53 <CakeProphet> So.... it's just a bunch of tuples?
22:36:55 <lament> 1 is the head, (2 (3 4)) is the tail
22:37:30 <lament> now we define a special object () meaning 'empty list'
22:37:40 <lament> and there you go
22:37:53 <lament> we can make lists of arbitrary length by nesting cons cells in a predictable fashion
22:38:12 <lament> by putting some object in the 'head' section and the remainder of the list in the 'tail'
22:38:34 <lament> eg for a list of integers, the head of each cell is an integer, and the tail is a list.
22:38:52 <lament> (1 (2 (3 ())))
22:38:54 <CakeProphet> THat's kind of... weird...
22:39:12 <CakeProphet> I see the use.
22:39:26 <CakeProphet> but... lists seem to work fine in most cases.
22:39:30 <lament> um
22:39:41 <lament> what i described is a list.
22:39:53 <lament> what python has is more commonly known as arrays.
22:40:13 <lament> both have advantages and disadvantages.
22:40:40 * CakeProphet wonders why Python uses arrays called "lists" and then has another datatype called an "array"
22:40:57 <CakeProphet> Python has arrays too... but they're not its lists.. which are apparently arrays...
22:40:59 <CakeProphet> o.o
22:41:09 <fizzie> Silly to use (x y) for a cons cell; I would be muchly confused, due to the fact that Scheme uses (x . y) for cons cells, and (x y) would be a two-element list, (x . (y . ())).
22:41:23 <lament> heh, sorry
22:41:37 <lament> CakeProphet: well, python is weird.
22:41:47 <fizzie> (Just a random outburst; now I sleeps.)
22:41:57 <CakeProphet> MAkes sense to me... but I've been using it predominantly...
22:42:00 <ihope> Haskell uses x:y for a cons.
22:42:00 <lament> CakeProphet: the disadvantage of arrays is that they're a bit difficult to resize
22:42:14 <ihope> [1,2,3] = 1:[2,3] = 1:2:[3] = 1:2:3:[]
22:42:29 <lament> CakeProphet: consider, you have an array of 1000 elements and you want to remove the element 500, how would you do this?
22:43:00 <CakeProphet> list[500
22:43:02 <CakeProphet> ck
22:43:14 <CakeProphet> list.pop(500)
22:43:30 <lament> CakeProphet: do you expect that operation to be fast?
22:43:38 <CakeProphet> *shrugs* It works.
22:43:49 <Razor-X> Most functional languages use (x . y) for a list.
22:44:31 <lament> CakeProphet: do you expect that operation to be equally fast for a list containing 3 elements, and for a list containing ten billion?
22:44:40 <CakeProphet> NO.
22:44:42 <CakeProphet> er.
22:44:44 <CakeProphet> no
22:44:51 <Razor-X> Lists are pretty slow too now. Especially for things of fixed bound and random access.
22:44:58 <lament> CakeProphet: quite so.
22:45:14 <Razor-X> They both have their advantages and disadvantages. But true lists are *lovely* to work with.
22:45:20 <CakeProphet> You could split the list up before doing it.
22:45:41 <lament> CakeProphet: so if you want to remove lots of elements from the middle of long lists, implementing those lists as arrays (such as in Python) might not be the most efficient way of doing it.
22:45:47 <lament> Razor-X: i don't like them
22:46:02 <lament> Razor-X: i actually prefer arrays, and not having to care about the structure :)
22:46:29 * CakeProphet enjoys doing as little work as possible... which is probably why he likes Python...
22:47:05 <CakeProphet> Screw the programs efficiency... I just want it to work with minimal effort on my part.. :D
22:47:50 <lament> that's a good strategy, up to a point.
22:48:40 <CakeProphet> I'm sure on giant projects that would be a bad plan.
22:49:05 <CakeProphet> But chances of me pulling off said giant project by my lonesome is slim to none.. since I'm not doing coding for a business or the like.
22:49:52 -!- RodgerTh1Great has joined.
22:51:07 <CakeProphet> Lists are fairly easy to add onto in Python... as far as coder's effort goes... you'd just use the append or extend method.
22:51:10 <lament> you don't need a giant project to have billion-item lists.
22:51:44 <lament> perhaps you're trying to find the biggest prime number :)
22:52:36 <CakeProphet> I have a prime number generator.. whenever I set the range from one to a million.. I get a memory erorr.
22:52:52 <lament> see!
22:52:59 <lament> in Haskell, a prime number generator takes no memory at all :)
22:53:41 * lament looks for the link
22:53:46 <CakeProphet> Hmmm...
22:53:56 <CakeProphet> Wouldn't list[500] = "" work pretty efficiently?
22:54:40 -!- RodgerTheGreat has quit (Read error: 110 (Connection timed out)).
22:55:20 -!- BrainMachine has quit (Read error: 110 (Connection timed out)).
22:55:53 <lament> damn, can't find a good example of prime numbers in haskell
22:55:58 <lament> CakeProphet: does that actually delete anything?
22:56:29 <CakeProphet> Not really... although it simulates deletion.. since empty strings essentially do nothing unless you have a conditional somewhere that employs an empty string.
22:56:34 <pikhq> Lists are easy to handle in Tcl; it's the only datatype. ;)
22:56:48 <lament> ah there you go
22:56:49 <lament> primes = sieve [2 .. ]
22:56:50 <lament> sieve (x:xs) = x : sieve (filter (\y -> y 'mod' x > 0) xs)
22:57:22 <ihope> Hmm...
22:57:29 <lament> CakeProphet: if your 500th element was 'a' and your 501th element was 'b', after deleting 500th element, 500th element should be 'b'
22:57:36 <ihope> Inefficient!
22:57:42 * ihope hits the buzzer
22:58:05 * pikhq hugs lists
22:58:44 <CakeProphet> Hmmm
22:58:57 <CakeProphet> Wait... how efficient would "del list[500]" be?
22:59:02 <CakeProphet> I totally forgot about that one :D
22:59:29 * ihope wonders how well IRC clients implement CTCP
22:59:35 <ihope> I'd have to get Igor in here for that.
22:59:54 <pikhq> set list [lappend [lindex list 0..499] [lindex list 501..end]]
22:59:56 <pikhq> Voila.
23:00:42 <CakeProphet> Yup... "del list[500]" works.. and probably a lot quicker than list.pop(500)
23:00:44 -!- Igor has joined.
23:00:53 <lament> CakeProphet: I suggest you read this:
23:00:55 <lament> http://mitpress.mit.edu/sicp/full-text/book/book.html
23:01:55 <Anders> pikhq I thought strings were the only datatype
23:01:59 <Anders> even lists are strings
23:02:57 <pikhq> Or, alternately: proc listdel {list element} {set $list [lappend [lindex $list 0..[expr {$element-1}]] [lindex $list [expr {$element-1}]..end]]}
23:03:26 <pikhq> In Tcl, everything is a list. .
23:03:37 * pikhq is a Tcler; trust me
23:03:49 <Igor> Say hi to Ronn/Igor<CTCP>USERINFO<CTCP>
23:04:05 <ihope> Hmm... something fails at something.
23:04:14 <pikhq> Methinks that's a malformed CTCP message.
23:04:22 <ihope> My client didn't even show it.
23:04:29 <ihope> At all.
23:04:30 <pikhq> Mine showed it as a line of text.
23:05:01 <ihope> What was the line of text?
23:05:17 <pikhq> "Say hi to RonTnI/IgorAUSERINFOA"
23:05:26 <CakeProphet> Hmmm.. I forgot what CTCP looks like to the IRC protocol.
23:06:12 * CakeProphet could turn his bot on and read the printed output it receives to answer that question.
23:06:25 <ihope> PRIVMSG ihope :^AVERSION^A
23:06:52 <ihope> NOTICE someone :^AVERSION Chatzilla 0.9.73 [Firefox 1.5.0.6/2006072814]^A
23:06:53 <CakeProphet> Oh.. CTCP is just PRIVMSG's?
23:07:02 <CakeProphet> Yeah... notice... that's what I thought it was.
23:07:14 <ihope> Where someone sends the first message and I send the other one.
23:07:42 * CakeProphet will makes his own IRC client at some point.
23:07:51 <ihope> Me too.
23:08:10 <CakeProphet> I always mess up when I try to do the asynchronous loop and/or multi-threading.
23:08:22 <CakeProphet> To be able to send and receive text at the same time.
23:08:37 <fizzie> The Spec says that you're not allowed to automagically (in a program) to respond to a PRIVMSG with another PRIVMSG, only a NOTICE. (And that you shouldn't make _any_ automatical replies to a NOTICE.)
23:08:46 <ihope> How does multi-threading work in Python?
23:08:56 <ihope> fizzie: the IRC spec?
23:09:06 <CakeProphet> Eh... it's got a module for it.. I dunno how it works... never been able to multi-thread correctly.
23:09:15 <fizzie> Yes, although bots and such obviously ignore that rule.
23:09:31 <ihope> Well, my Haskell roadblock is the foreign function interface.
23:09:36 <fizzie> That's why ircii's script thingie (I think it was that; might've been epic or something else) converts privmsg-triggered privmsgs to notices.
23:11:01 <ihope> I don't know if I've ever gotten that working.
23:11:08 <CakeProphet> Sadly.. the only realm of programming I'm even mediocre at the moment is event-based... I've made a few IRC bots to help me get familiar with the protocol.
23:11:09 <fizzie> RFC1459, 4.4.2: "The difference between NOTICE and PRIVMSG is that automatic replies must never be sent in response to a NOTICE message. This rule applies to servers too - they must not send any error reply back to the client on receipt of a notice."
23:11:38 <CakeProphet> Pfft... screw rules :D
23:11:45 <CakeProphet> If it's do-able.. I say do it.
23:12:50 <ihope> Well, lemme see if I can get FFI working.
23:13:05 -!- Greenbeanicle has joined.
23:13:11 <CakeProphet> Ah... there's my bot.
23:13:17 <ihope> Beanicle? Eew.
23:13:41 <ihope> I see it doesn't reply to a CTCP VERSION.
23:13:44 <CakeProphet> It was working fine until I recoded it functionally... the whole thing was imperitive until the reqrite... but now the parser doesn't work.
23:13:56 * pikhq does very well in !C. :p
23:13:58 <CakeProphet> Nope... it respondes to... nothing really.
23:14:08 <ihope> Does it respond to PING?
23:14:15 <CakeProphet> Eh... only the server ping.
23:14:23 <ihope> That's what I meant, yeah.
23:14:31 <CakeProphet> Yeah.. it does that.
23:14:53 <CakeProphet> Otherwise... it only responds to what I've coded for it... I didn't bother to read the RFC for all the crap I needed... I'll put them in later or something.
23:15:30 <CakeProphet> The only part of the parser that works at the moment is the part that converts non-commands into raw IRC.
23:15:47 <CakeProphet> ?PRIVMSG #esoteric :meh
23:15:47 <Greenbeanicle> meh
23:15:57 <ihope> int add(int x, int y) {return x+y;} <- is that the way to do it?
23:16:01 <CakeProphet> The rest of it went to hell in the rewrite.
23:16:12 <ihope> ?PRIVMSG ihope :whee
23:16:18 <ihope> It works.
23:16:27 <CakeProphet> Yup...
23:16:34 <pikhq> ihope: Yes, except that (x+y) is much, much shorter. :p
23:17:07 <ihope> PRIVMSG nalioth :hai r u a boy??????????? :-D :-D :-D
23:17:07 <CakeProphet> But... now that I've rewrote it... it's a little bit cleaner.... I can code in new commands mid-run (even if those commands won't work due to a bug I can't find)... and it doesn't crash everytime it gets an error.
23:18:06 <CakeProphet> Once I get it working I want to program a chess game into it :D
23:18:16 <ihope> ?JOIN ##quantum
23:18:21 <ihope> :-)
23:18:23 <CakeProphet> :P
23:18:42 <ihope> <ihope> ?PART ##quantum
23:18:43 <CakeProphet> ?help
23:18:50 <ihope> <--| Greenbeanicle has left ##quantum
23:19:04 <ihope> <ihope> ?JOIN ##quantum
23:19:14 <CakeProphet> Bah.. I wish I could figure out what was wrong with it.
23:19:17 <ihope> Apparently Greenbeanicle doesn't respond to commands in channels it's not in.
23:19:30 <CakeProphet> Never would have guesses.
23:19:45 <CakeProphet> Also... any PRIVMSGs that are sent directly to it.... will be treated as raw IRC.
23:19:46 <ihope> ?PRIVMSG ##darksecrets :Whee, I can send things to channels I'm not in!
23:19:57 <CakeProphet> /msg greenbeanicle JOIN #wikipedia
23:20:21 <ihope> ##darksecrets is pretty much a write-only channel right now :-P
23:20:45 <CakeProphet> Actually... imsgs to the bot are the equivalent of the ?-commands that are sent via channels... so any of the bot commands will work that way as well.
23:20:45 <Greenbeanicle> Wheee!
23:21:11 <CakeProphet> Except... the bot commands aren't working right now... because of that damn bug.
23:21:29 <ihope> ?JOIN ##darksecrets
23:21:36 <Greenbeanicle> I'd say they're working fairly well.
23:21:40 <ihope> Now Green's in on the dark secrets.
23:22:12 <CakeProphet> "that damn bug" = "my shitty coding"
23:22:30 <CakeProphet> By "bot comamnds" I mean the ones that aren't IRC commands... that I programmed in myself.
23:22:53 <ihope> There. Now people can send messages to ##darksecrets, but nobody will recieve them.
23:23:36 <ihope> Now ##darksecrets has no operators :-P
23:23:58 <pikhq> I think Greenbeanicle died.
23:24:02 <ihope> ?PART ##darksecrets
23:24:08 <CakeProphet> ?help, ?rev, ?A, ?fuck, ?Afuck, "Arev, ?revfuck, ?revAfuck,
23:24:20 <CakeProphet> Those were all the commands... all of which are pretty useless... but fun to screw around with.
23:24:32 <ihope> ?JOIN ##darksecrets
23:24:34 <pikhq> ?PRIVMSG Greenbeanicle :Have I died?
23:24:43 <pikhq> Oh. x_x
23:24:51 <pikhq> ?PRIVMSG #esoteric :Have I died?
23:24:51 <Greenbeanicle> Have I died?
23:24:57 <pikhq> It lives.
23:25:02 <pikhq> ?PART #esoteric
23:25:02 -!- Greenbeanicle has left (?).
23:25:06 <CakeProphet> ...
23:25:10 <ihope> Hmm, what's +s?
23:25:17 <ihope> I forgot...
23:25:18 <CakeProphet> +s?
23:25:19 -!- Greenbeanicle has joined.
23:25:27 <ihope> The channel mode.
23:25:46 <CakeProphet> I really should have the bot send me a pm everytime it gets a pm... so I know what the hell people are doing with it...
23:25:54 <fizzie> It's "does not show up in /list or /whois of people" in ircnet.
23:26:11 <fizzie> IRCnet and freenode have some differences there, though.
23:26:24 <ihope> Apparently that's what it is in Freenode, too.
23:26:31 <CakeProphet> ?help
23:26:36 <CakeProphet> ?A
23:26:59 <ihope> So now both me and Greenbeanicle are in ##darksecrets, and anybody can send messages there, but I will recieve them and he won't.
23:27:05 <ihope> Nobody can join ##darksecrets.
23:27:23 <CakeProphet> So.. basically.. the bug is that it's completely ignoring the parser... and just treating everything as though it were raw IRC.
23:27:35 <CakeProphet> Which is sort of the "else" of the parser.
23:27:54 * CakeProphet has a pastebin of the code somewhere... if one of you wizzes can fix it.
23:28:09 -!- Greenbeanicle has quit (Read error: 104 (Connection reset by peer)).
23:28:39 <ihope> Where be it?
23:28:52 <ihope> Oh, and Greenbeanicle is no longer in ##darksecrets :-P
23:29:35 <CakeProphet> ...thank you for the update (I closed the bot's program...)
23:30:37 <ihope> So can you give us a paste?
23:30:48 <CakeProphet> http://deadbeefbabe.org/paste/1613
23:33:12 <Razor-X> My IRC bot is working strong in another channel I'm in.
23:33:51 <Razor-X> It's semi-modular too, so I can easily add/remove features if I want.
23:35:06 <CakeProphet> Yup... modules are neato.
23:35:47 <Razor-X> Yup.
23:35:57 <Razor-X> I got everything except the negotiation code in its own module.
23:36:11 <CakeProphet> So... anyone reading my code?
23:36:16 <Razor-X> Nope.
23:36:19 <CakeProphet> Does it make any sense? I'm guessing it's near illegible.
23:36:19 <Razor-X> How many lines is it?
23:36:29 <CakeProphet> No idea.
23:36:46 <Razor-X> Hint: Check.
23:36:49 -!- Sph1nx has quit (Remote closed the connection).
23:36:58 <Razor-X> My bot is pretty small, like... 500-600 lines, IIRC.
23:37:27 <ihope> Yes, it's near illegible.
23:37:50 * CakeProphet can explain his spaghetti if you wish.
23:38:04 <CakeProphet> I have a paticular affinity at creating unreadable masses of shit that only I can read.
23:38:44 <Razor-X> No. Everyone can do that.
23:38:53 <Razor-X> If you program in INTERCAL, it's impossible not to.
23:39:27 <Razor-X> When I was 9 and programming, I used to randomly declary variables when I needed them with descriptive names like `x' and `y'.
23:39:57 <CakeProphet> My variable names... uh...
23:40:18 <CakeProphet> well.... they tend to shift purposes mid-program... which might account for some of the illegibleness.
23:40:23 <Razor-X> There's only one really illegilble piece of code in my IRC bot, and that's the two different functions cParm and cParam.
23:40:49 <pikhq> Nowadays, my illegible code is in Brainfuck. . .
23:41:10 <pikhq> My actual code may make you go "WTF?!?", but it is easy to at least tell what I'm trying to do. :p
23:41:24 <Razor-X> I should put my Haskell IRC bot online.
23:41:34 <CakeProphet> The variable "msg" in my bot is first assigned to the actually message part of every PRIVMSG.... but later down in the program it becomes the variable that tells the bot what to send to a channel.
23:41:39 <CakeProphet> It basically just reverses purposes.
23:41:41 <Razor-X> I couldn't stand LambdaBot because of the sheer number of monads it used.
23:41:57 <Razor-X> Obviously, Haskell has no variable.
23:42:34 <Razor-X> *variables
23:43:01 <Razor-X> Maybe some of the code for quote retreival is a bit loopy.
23:43:23 <Razor-X> Oh, and this one liner:
23:43:25 <Razor-X> talkToChannel server channel ( "Quote " ++ (show rnum) ++ " of " ++ ( show ( length ( BS.lines file ) ) ) ++ ": " ++ ( BS.unpack (( BS.lines ( file ) !! (rnum - 1 ) ) ) ) )
23:44:26 <CakeProphet> I should learn lisp... it seems neato.
23:44:48 <Razor-X> The only reason it gets so awful like that is because I wanted to use Don's Data.ByteStrings library for fast IO.
23:45:22 <Razor-X> I've compared it against the dominant Python bot, the dominant C bot, and a Perl bot someone I know coded and it beats them all in the speed of the functions it performs.
23:45:29 <pikhq> Haskell looks awfully Lispish. . .
23:45:37 <CakeProphet> Eh... it vaguely makes sense to me... although I couldn't tell you exactly what each part does.
23:45:43 <Razor-X> Only because I overdose on parentheses, pikhq.
23:45:53 <Razor-X> It's a bad habit I got from Lisp ^^
23:45:57 <pikhq> I can see the differences between it and sexps, though. . .
23:47:03 <Razor-X> Of course, reading my module code is nowhere close to the way the code in the belly of the bot looks, because function languages are awesome like that!
23:47:11 <Razor-X> *functional
23:47:32 <CakeProphet> JumpRope is probably the best language ever... as far as language concepts go.
23:47:39 <CakeProphet> Since... it's not a real "language" yet.
23:47:46 <CakeProphet> >.>
23:47:49 <Razor-X> That is also one of my favorite uses of lists in Haskell ever.
23:47:57 * pikhq loves the idea behind functional languages. . .
23:48:53 * pikhq ends up using Tcl for a lot of the stuff you can do in functional languages (Tcl is by no means a pure functional language; it's more of a bastardisation between an imperative language and a functional one). . .
23:49:07 <Razor-X> Come on. Try Haskell.
23:49:21 <Razor-X> I suggest using ``A Gentle Introduction to Haskell'' and ``Yet Another Haskell Tutorial'' to get started.
23:49:29 <pikhq> I mean to, but I just can't figure out enough time for it. . .
23:49:36 <pikhq> Ah, who am I kidding?
23:49:47 <pikhq> I'm in #esoteric, for Christ's sake! :p
23:49:51 <Razor-X> If I can get 100+ vocab words in Japanese done per-day, program, and summer homework, you can too :D.
23:50:04 <Razor-X> Bub.
23:50:11 <pikhq> School has started already. . .
23:50:27 <Razor-X> Doesen't mean I'll stop any of that.
23:50:30 <Razor-X> ^^
23:50:40 <Razor-X> I just go to sleep later, eat less, etc.
23:50:48 <pikhq> You'll be doing summer homework. . . During school?
23:50:49 <pikhq> :p
23:50:55 <CakeProphet> Hmmm....
23:51:21 <Razor-X> I'll be doing regular homework instead. Bub.
23:51:24 <CakeProphet> A Python/Lisp combo-with-other-little-sprinkles-on-top would be an awesome idea.
23:51:38 <lament> it's called Dylan i think
23:51:50 <Razor-X> CakeProphet: I suggest you see Lisp in its entirety.
23:52:01 <lament> CakeProphet: read SICP
23:52:01 <CakeProphet> The eso wiki could be pretty useful for collaborate programming-language-constructions.
23:52:04 <Razor-X> And by that I mean, write something semi-complex in it.
23:52:20 <lament> everybody ought to read SICP
23:52:22 <Razor-X> Learn either Common Lisp or Scheme. Common Lisp is more powerful, but more complex and less clean.
23:52:37 <lament> learn Scheme because that's what SICP uses :)
23:54:10 <Razor-X> Pshhh. Common Lisp for the win.
23:54:40 <Razor-X> Also advice: Go to #scheme if you want Scheme help. Go to #lisp if you want Common Lisp help. Do NOT go to #lisp for Scheme help. #lisp and #scheme are like two warring African tribes.
23:54:47 * CakeProphet screws all of those suggestions and does whatever the hell he wants to do?
23:55:50 <Razor-X> If you want to have sex with suggestions, be my guest bub.
23:56:21 <ihope> Hmm...
23:56:27 * pikhq opts for a bit more romance first :p
23:56:40 <ihope> My computer's power cord is hovering dangerously close to the cat's forehead.
23:56:53 <Razor-X> Cats are super-cute.
23:57:02 <Razor-X> They break down all my geekishness in a few seconds.
23:57:06 <ihope> Especially when they're asleep...
23:57:15 <Razor-X> (Along with stuffed animals and a few other things.)
23:58:08 <Razor-X> Also, I suggest bub tries out other languages. Non-esoteric ones too. (Blaspheme, I know.)
23:58:41 <ihope> Isn't a blaspheme a piece of blasphemy?
23:58:51 <Razor-X> Not in my writing style it isn't.
23:59:23 <ihope> Oh, it's a verb.
←2006-08-21 2006-08-22 2006-08-23→ ↑2006 ↑all