←2007-01-16 2007-01-17 2007-01-18β†’ ↑2007 ↑all
00:33:05 * bsmntbombdood has ran out of ideas for bsmnt_bot
00:47:42 <CakeProphet> hmmm..
00:47:48 <CakeProphet> what computation class would this be?
00:48:32 <CakeProphet> http://esolangs.org/wiki/Dupdog
00:49:11 -!- pikhq has joined.
00:55:06 * CakeProphet coughs.
00:55:12 <CakeProphet> what computational class would this be?
00:55:23 <CakeProphet> http://esolangs.org/wiki/Dupdog
00:55:28 -!- ShadowHntr has joined.
00:55:33 * CakeProphet repeats for Pikhq :D
00:55:42 * CakeProphet coughs.
00:55:44 <CakeProphet> what computational class would this be?
00:55:46 <CakeProphet> http://esolangs.org/wiki/Dupdog
00:55:46 * pikhq sees it
00:55:53 <CakeProphet> :P
00:55:57 <CakeProphet> I'm just being annoying.
00:56:41 <pikhq> Hmm. . .
00:56:53 <CakeProphet> It can't be terribly useful.
00:57:07 <CakeProphet> I'm not even sure how to go about Hello, World!
00:57:09 <pikhq> I'm not sure of the computational class. . .
00:57:20 <pikhq> Maybe a finite state automaton?
00:59:44 <CakeProphet> hmm..
01:00:28 <CakeProphet> the self-modifying-ness of it makes it more computationally powerful than any finite state automaton I'd imagine in my head.
01:00:37 <CakeProphet> an FSA is like... a like switch.
01:00:39 <CakeProphet> er...
01:00:41 <CakeProphet> light switch.
01:09:51 -!- ihope_ has joined.
01:24:47 <pikhq> CakeProphet: It transorms from state foo to state bar.
01:24:55 <pikhq> That seems to me to be a finite state automaton.
01:25:11 <CakeProphet> no
01:25:14 <CakeProphet> that's the interpreter.
01:25:17 <CakeProphet> the interpreter flips state.
01:25:32 <CakeProphet> the data is encoded in the source code itself
01:25:38 <CakeProphet> as its length.
01:25:53 <pikhq> And the difference matters. . . how?
01:27:48 -!- ihope has quit (Read error: 110 (Connection timed out)).
01:28:25 <CakeProphet> pikhq, because the "state" of the program is its value(s) in memory.
01:28:33 <CakeProphet> the interpreter... is not its value in memory.
01:28:38 <CakeProphet> its the... interpreter.
01:28:48 <CakeProphet> of the symbols.
01:28:54 <pikhq> The interpreter performs the modifications of the state.
01:29:02 <pikhq> This difference doesn't matter.
01:29:03 <pikhq> At.
01:29:04 <pikhq> All.
01:29:28 <CakeProphet> hmmm...
01:29:36 * CakeProphet tries to understand... but still doesn't see the connection.
01:30:18 <CakeProphet> If your interpreter oscillated between a Perl and Python interpreter... you wouldn't call that a finite state automaton.
01:31:24 <CakeProphet> The memory is finite however.
01:31:32 <CakeProphet> there's only one variable... the length of the source code.
01:31:42 <CakeProphet> which can be any number... but ultimate has 256 states.
01:32:00 <CakeProphet> so that would probably make it a finite state automaton.
01:32:02 <CakeProphet> but not for that reason.
01:33:14 <pikhq> What makes it a FSA is the transition between a finite amount of states.
01:33:53 <CakeProphet> yes... 256 of them.
01:34:07 <pikhq> Exactly.
01:34:23 <CakeProphet> not the two interpreters... which isn't even a state... just a means to an end.
01:34:33 <pikhq> Exactly!
01:35:05 <CakeProphet> if both your interpreters could manipulate and perform any computation... the existence of two interchanging interpreters does NOT make it finite state.
01:35:46 <CakeProphet> I'm just saying the transitioning interpreters has nothing to do with the finite number of states.
01:36:18 <pikhq> Exactly.
01:38:57 <bsmntbombdood> The c preproccesor is nice
01:39:10 <bsmntbombdood> #define NOTE(args...) if(debug) {char m[1024]; snprintf(m, 1023, args); fprintf(stderr, "%s:%d, %s: %s\n", __FILE__, __LINE__, __func__, m); }
01:39:46 -!- ryanakca has joined.
01:40:23 <ryanakca> where can I find the interpreter for Glass? the link on the wiki is down...
01:45:20 -!- calamari has joined.
01:45:55 <CakeProphet> ryanakca, There's one right here. :D
01:46:22 <ryanakca> lol
01:46:26 <CakeProphet> !glass {M[m(_o}O! "Hello World!"(_o)o.]}
01:46:31 <CakeProphet> oh...
01:46:34 <CakeProphet> !glass {M[m(_o}O! "Hello World!"(_o)o.?]}
01:46:38 <CakeProphet> ...
01:46:41 <CakeProphet> !help
01:46:46 <CakeProphet> no wait..
01:46:50 <CakeProphet> EgoBot isn't here.
01:46:55 <ryanakca> lol
01:47:05 <CakeProphet> WHO TOOK EGOBOT
01:47:19 <pikhq> I think the wiki link is just old. . .
01:47:28 * pikhq tries finding Gregor's current version
01:47:34 * CakeProphet likes Glass. :D
01:47:44 <CakeProphet> and ORK... both Gregor's creations.
01:47:52 <pikhq> Same for EgoBot.
01:48:18 <pikhq> http://esoteric.voxelperfect.net/files/glass/ Ahah!
01:48:55 <ryanakca> thanks
01:51:02 <ihope_> EgoBot gone?
01:51:24 <ihope_> They don't call him eGoBot for nothing.
01:51:25 * ihope_ runs
01:51:47 <pikhq> Heheh.
01:51:54 <pikhq> Gregor's down, tooo. Go figure.
01:52:04 <bsmntbombdood> heh
01:53:38 -!- ihope_ has changed nick to GregorR.
01:53:44 <GregorR> RAAAR
01:53:50 <GregorR> >_O
01:53:52 <ryanakca> heh, he included his bot in with glass :)
01:53:56 <ryanakca> @.@
01:54:33 <GregorR> >_<
01:54:42 <pikhq> I. . . Think that's the wrong source?
01:54:52 <GregorR> Yeah :-P
01:54:54 -!- GregorR has changed nick to ihope.
01:55:10 <ihope> I seem to know remarkably little about imitating GregorR, actually.
01:56:25 <bsmntbombdood> heh
01:56:41 <ryanakca> hmm... he even seems to have included instructions on running the bot :) nc -e ./glassIRC.sh irc.freenode.net 6667 ... glassIRC.sh contains: ./glass cache GlassBot GregorR esoteric > GLASSOUT
01:57:47 * ryanakca pets the README
01:59:00 <pikhq> Oh. . .
01:59:18 <pikhq> That's just a script for running Glass via IRC.
01:59:24 -!- calamari has left (?).
01:59:34 -!- EgoBot has joined.
01:59:59 <pikhq> I think he was trying to make an IRC bot in IRC.
02:00:03 <ryanakca> ah
02:00:24 <pikhq> Glass, I mean.
02:01:44 -!- EgoBot has changed nick to calamari.
02:02:09 <calamari> bah.. no fun.. hehe
02:03:24 <CakeProphet> ..
02:03:31 * CakeProphet hates you.
02:03:35 <ryanakca> lol
02:03:46 <CakeProphet> you'll serve as our egobot for now.
02:03:56 <CakeProphet> !bf ++++++++++>+++++++<[>.
02:04:02 <ryanakca> !glass {M[m(_o}O! "Hello World!"(_o)o.?]}
02:04:03 <calamari> I can bring in EsoBot.. but it won't run glass ;)
02:05:33 -!- EsoBot has joined.
02:05:39 <calamari> E!help
02:05:39 <CakeProphet> yay
02:05:41 <EsoBot> Commands: bf, cat, help, kill, ls, ps, quit, unnecessary.
02:05:56 <CakeProphet> eh... we can write Glass in BF
02:05:59 <CakeProphet> ...
02:06:04 <calamari> be my guest
02:06:15 <CakeProphet> ...yeah
02:06:21 <pikhq> Your own bot, I take it?
02:06:30 <pikhq> CakeProphet: In theory, sure.
02:06:34 <calamari> yeah.. it inspired the creation of EgoBot
02:06:36 <pikhq> Doesn't mean I'd want to.
02:06:39 <pikhq> calamari: Cool.
02:06:54 <CakeProphet> you'd need an organized way to partition variables and reference them by name.
02:06:59 <CakeProphet> which... is a headache to be sure.
02:07:13 <CakeProphet> not to mention... scopin
02:07:15 <CakeProphet> g
02:07:23 <calamari> unless variable names were limited to a single character
02:07:26 <pikhq> But, since BF is Turing complete, it's possible.
02:07:34 <pikhq> Not necessarily easy, but possible.
02:07:37 <CakeProphet> OH
02:07:41 <CakeProphet> that makes it much easier
02:07:53 <CakeProphet> but it would make the memory finite
02:08:03 <CakeProphet> you jsut have a range for each possible class name...
02:08:06 <pikhq> CakeProphet: Actually, "memory" is in the stack.
02:08:23 <pikhq> The issue is that you'd only have a limited amount of objects out there at a time.
02:08:24 <CakeProphet> oh yeah..
02:08:31 <CakeProphet> limited variable names.
02:08:33 <CakeProphet> but not limited stack
02:09:00 <calamari> E!bf help
02:09:12 <calamari> I don't remember how to run it.. hehe
02:09:21 <calamari> E!bf +.
02:09:24 <CakeProphet> I could see it being much more feasible if each class, variable, string, and integer were limited to a byte in size.
02:09:31 <CakeProphet> byte-sized glass. :D
02:09:33 <pikhq> E!help bf
02:09:34 <EsoBot> Commands: bf, cat, help, kill, ls, ps, quit, unnecessary.
02:10:10 <pikhq> E!bf Mismatched [.
02:10:11 <EsoBot> Killed 1: : .
02:10:22 <pikhq> It's a quine in some interpreters. ;)
02:10:23 <calamari> E!bf 1 +++.
02:10:40 <calamari> E!bf abc +++.
02:10:42 <calamari> hmm
02:11:39 <CakeProphet> hahaha
02:11:44 <CakeProphet> I didn't think of doing that.
02:11:53 <CakeProphet> just spitting out an error message that triggers an error message.
02:12:28 <calamari> E!ps
02:12:30 <EsoBot> No processes.
02:12:50 <calamari> E!bf +++++++++++++++++++++++++++++++++++++++++++++++++++++++.
02:12:52 <EsoBot> 7
02:12:57 <calamari> okay so it does work
02:15:14 <calamari> E!bf http://rafb.net/p/PR5bhv59.txt
02:15:17 <EsoBot> Hangman started! Type `/msg EsoBot <pid> <word>\n' to start a game!
02:15:40 <calamari> pid is probably 1
02:15:42 <calamari> E!ps
02:15:44 <EsoBot> 1:calamari
02:17:11 <EsoBot> ______ ___!______ ___! | Type `E!<pid> <guess>\n' to guess a letter!
02:17:15 <calamari> oops
02:17:16 <calamari> hehe
02:17:37 <calamari> guess you really do need to put the text '\n'
02:17:38 * pikhq laughs at calamari's inefficient high-level language that compiles to Brainfuck. . .
02:17:53 * pikhq gently hugs BFM, as well. . .
02:19:08 <calamari> E!1 E\n
02:19:25 <EsoBot> E_____ ___!E_____ ___! | []
02:20:03 <calamari> E!1 S\n
02:20:20 <EsoBot> Es____ ___!Es____ ___! | []
02:20:42 <calamari> pikhq: running on top of java no less ;)
02:20:51 <calamari> and no optimizations going on
02:21:17 <CakeProphet> where can I get a list of all the IRC commands.
02:21:20 <CakeProphet> the "real" ones.
02:21:35 <CakeProphet> like PRIVMSG, etc
02:21:39 <pikhq> I should count myself lucky that I do optimization.
02:21:43 <calamari> rfc1459 or whatever it is
02:21:44 <pikhq> CakeProphet: The IRC RFC.
02:21:54 <CakeProphet> oh... duh
02:21:59 <CakeProphet> is it up to date?
02:22:59 <calamari> how close was I to the actual number?
02:23:03 <pikhq> Hell yes.
02:23:05 <pikhq> calamari: I dunno.
02:23:45 <calamari> woohoo, got it exactly
02:24:03 <pikhq> Nice.
02:24:14 <calamari> CakeProphet: going to write a bot?
02:25:16 <CakeProphet> pretty much.
02:25:23 <CakeProphet> In glorious Python of course. :P
02:25:38 <CakeProphet> C++ is too intimidating as of right now.
02:26:01 <pikhq> I find the best way to learn a language is to write something useful in it. . .
02:26:02 <CakeProphet> and Python has the advantage of being way more dynamic.
02:26:14 <CakeProphet> yeah well... fuck you and your "learning by doing"
02:26:16 <pikhq> Although yeah, Python would be better for an IRC bot.
02:26:31 <CakeProphet> it would be way quicker.
02:26:33 <CakeProphet> to write.
02:26:38 * pikhq would use Tcl, but mostly just because I know Tcl, and know of a premade IRC parser for Tcl.
02:27:01 <CakeProphet> they could have shortened all the IRC commands to single bit values.
02:27:04 <CakeProphet> er... byte values
02:27:06 <CakeProphet> like telnet
02:27:34 <pikhq> That's great and all, but telnet doesn't have "commands" per se. . .
02:28:01 <CakeProphet> well... you know what I mean.
02:28:23 <CakeProphet> PRIVMSG could be like... byte value 1, etc
02:28:23 <pikhq> And the idea behind most RFC protocols is to be human-grokable.
02:28:43 <CakeProphet> PRIVMSG = chr(1)
02:28:47 <CakeProphet> a human can now grock that.
02:29:05 <pikhq> Could a human run IRC via telnet?
02:29:11 <pikhq> If no, it's not human-grokable.
02:29:21 <pikhq> And the word is "grok", not "grock".
02:29:25 <CakeProphet> aaah.
02:29:35 <CakeProphet> I'm not sure WHY you would want to run IRC raw...
02:29:36 <CakeProphet> but..
02:29:45 <CakeProphet> I see what you mean.
02:29:52 <pikhq> It's one of the driving ideas behind most of the RFC protocols.
02:33:59 <CakeProphet> ...I forgot my newline names.
02:34:04 <CakeProphet> LF is \n right?
02:34:11 <CakeProphet> CR is \r I'm pretty sure
02:34:38 <CakeProphet> yeah... sounds right
02:36:58 -!- ShadowHntr has left (?).
02:41:57 <pikhq> I think so.
02:45:21 <CakeProphet> so...
02:45:43 <CakeProphet> I'm assuming freenode is nice and buffers its output until it gets a newline?
02:45:53 <CakeProphet> if not... oh well... I guess I'll find out. :P
02:46:23 <pikhq> I'm pretty certain it does. . . But I'm not sure.
02:46:31 <CakeProphet> it kinda would have to.
02:46:36 <CakeProphet> because all clients send at newlines.
02:46:48 <CakeProphet> so... there's really no way not to.
02:46:54 <CakeProphet> unless you do it intentionally.
02:47:13 -!- Sgeo has quit ("Leaving").
03:05:56 <bsmntbombdood> foo
03:08:15 <bsmntbombdood> C++ is so uglish
03:08:43 <pikhq> It's purdy.
03:08:47 <bsmntbombdood> no
03:09:02 <bsmntbombdood> I'm purdy
03:09:11 <bsmntbombdood> C++ is uglish
03:19:30 <calamari> E!1 o\n
03:19:50 <EsoBot> Eso_o_ ___!Eso_o_ ___! | []
03:20:09 <calamari> E!1 x\n
03:20:15 <bsmntbombdood> \as3ff
03:20:23 <pikhq> E!1 b\n
03:20:29 <EsoBot> Eso_o_ ___!Eso_o_ ___! |- [x]
03:20:39 <pikhq> That interpreter is slow.
03:20:48 <calamari> a bit.. yeah
03:20:49 <EsoBot> EsoBo_ ___!EsoBo_ ___! |- [x]
03:20:58 <pikhq> E!t\n
03:20:59 <EsoBot> Invalid command `t\n'.
03:21:02 <bsmntbombdood> Someone right a brainfuck interpreter for bsmnt_bot
03:21:04 <pikhq> E!1 t\n
03:21:15 <pikhq> bsmntbombdood: Call egobfi.
03:21:23 <bsmntbombdood> I don't wanna
03:21:27 <EsoBot> EsoBot _T_!EsoBot _T_! |- [x]
03:21:31 <bsmntbombdood> And what's egobfi?
03:22:09 <pikhq> It's Gregor's Brainfuck interpreter.
03:22:19 <pikhq> Used in Egobot. . . Really fast, rather good.
03:22:41 <pikhq> E!1
03:22:53 <bsmntbombdood> it's like 100 files long
03:23:08 <calamari> E!1 \n
03:23:10 <pikhq> Egobfi is small. . .
03:23:26 <bsmntbombdood> 520k
03:23:43 <calamari> E!1 q\n
03:24:08 <EsoBot> EsoBot _T_!EsoBot _T_! |-: [xq]
03:24:09 <pikhq> 520k uncompressed. . .
03:24:28 <calamari> E!1 z\n
03:24:29 <bsmntbombdood> yeah
03:24:36 <bsmntbombdood> pikhq: it's like 300 files
03:24:45 <calamari> E!1 j\n
03:24:51 <EsoBot> EsoBot _T_!EsoBot _T_! |-:( [xqz]
03:25:15 <EsoBot> EsoBot _T_!EsoBot _T_! |-:(< [xqzj]
03:25:17 <pikhq> 16+5+17 != 300
03:25:42 <calamari> << 300
03:26:10 <pikhq> Also, most of the source is in the build system. . .
03:26:17 <pikhq> Autoconf and automake take a lot of space.
03:27:17 <pikhq> It's 200k without the build system.
03:27:26 <bsmntbombdood> whatever
03:27:41 <pikhq> And it's a really, really fast interpreter. . .
03:27:56 <bsmntbombdood> he has weird opcode abreviations
03:29:19 <pikhq> It's optimize() which makes it rather impressive. . .
03:29:52 <calamari> bsmnt_bot: write your own bf interpreter ;)
03:29:59 <bsmntbombdood> yeah yeah yeah
03:30:01 <calamari> not that hard to do
03:30:09 <bsmntbombdood> I'll make mine faster ;)
03:30:18 <pikhq> Good luck.
03:30:39 <bsmntbombdood> argh
03:30:44 <bsmntbombdood> His code is hard to read
03:30:53 <bsmntbombdood> uses global variables to pass code around
03:31:03 <calamari> someday I need to finish my bf interpreter for the hp 41cx calculator
03:31:27 <pikhq> bsmntbombdood: Well, yeah. . . I am tempted to give him some stylistic improvements.
03:32:02 <bsmntbombdood> his design is interesting though
03:32:11 <bsmntbombdood> compiling it to bytecode
03:33:04 <pikhq> It is, in essence, a piece of Gregor code. ;)
03:34:31 <bsmntbombdood> Is that a good thing?
03:35:36 <pikhq> Depends upon your feelings towards ORK.
03:35:40 -!- bobot has joined.
03:36:01 <bsmntbombdood> ORK?
03:37:14 <bsmntbombdood> His optimization routine isn't too profound
03:37:26 <pgimeno> #malbolge (=<`:9876Z4321UT.-Q+*)M'&%$H"!~}|Bzy?=|{z]KwZY44Eq0/{mlk**hKs_dG5[m_BA{?-Y;;Vb'rR5431M}/.zHGwEDCBA@98\6543W10/.R,+O<
03:37:29 <bobot> Hello, world.
03:37:31 * pikhq needs to leave
03:37:41 -!- pikhq has quit ("leaving").
03:37:52 <pgimeno> :P
03:38:21 <bsmntbombdood> I do like the vm though
03:40:24 <bsmntbombdood> optaddto, though, is
03:41:14 <pgimeno> #bf ++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.
03:41:14 <bobot> Hello World!
03:41:39 <pgimeno> gotta love PHP
03:43:23 <bsmntbombdood> so, optimize() not only optimizes, but compiles too
03:43:38 <SimonRC> Problems that sound interesting but are trivial number 42:
03:44:03 <SimonRC> HPL(k): hamiltonian path length (k):
03:45:25 <SimonRC> "Given a graph with a Hamiltonian path, does it have a Hamiltonian path of at most k steps?"
03:45:28 <SimonRC> :-S
03:45:31 * SimonRC goes to bed for a bit.
03:54:59 <pgimeno> #me waves
03:54:59 * bobot waves
03:56:55 <bsmntbombdood> hmmm
03:57:46 <bsmntbombdood> ugh this code is so bad
03:58:57 * bsmntbombdood starts hacking
04:04:17 -!- bobot has quit ("bye bye!").
04:17:00 -!- GregorR has joined.
04:17:06 <calamari> E!quit
04:17:08 -!- EsoBot has quit ("requested by calamari").
04:18:03 <GregorR> Stupid power :-P
04:18:21 <calamari> your power was out?
04:19:22 <GregorR> Winter storm.
04:19:27 <GregorR> Mostly unexpected.
04:19:51 <calamari> does it get pretty cold there?
04:21:23 <calamari> man.. this bug is driving me crazy
04:21:35 <GregorR> No, this kind of weather is totally unheard of.
04:21:50 <GregorR> It's usually sleet and hail when it's that cold.
04:22:34 <calamari> oh, did you get snow?
04:22:42 <GregorR> Yeah, quite a bit.
04:22:46 <calamari> cool
04:22:49 -!- CakeProphet has quit (Read error: 113 (No route to host)).
04:23:41 <calamari> we get snow once maybe every 7-10 years or so
04:24:04 <calamari> it never lasts long tho
04:24:27 <calamari> but there is snow on the mountain, so we could go up there if we wanted to
04:26:10 <GregorR> Last time I saw any real snow ... hmmm ... Idonno ...
04:26:16 <GregorR> At least five years ago.
04:27:35 <bsmntbombdood> GregorR: sweet
04:27:39 <bsmntbombdood> Snow's awesome
04:29:57 <bsmntbombdood> ok, i KNOW that this code could be more compact: http://pastebin.ca/319229
04:32:42 <GregorR> That's fairly ingenius.
04:32:47 <GregorR> Could it be more compact? Maybe.
04:32:49 <GregorR> Should it be? No.
04:33:20 <bsmntbombdood> That's ingenious? cool!
04:34:21 <GregorR> Mind you, I'm not confident that it's /useful/ ;)
04:34:37 <GregorR> But for serving its fairly un-useful purpose, it's a nice way to do it.
04:35:09 <bsmntbombdood> yeah, maybe it's not very useful
04:39:39 <bsmntbombdood> GregorR, I'm was reading egobfi
04:39:55 <bsmntbombdood> Your use of global variables was so bad, I have to write my own now
04:42:34 <bsmntbombdood> And, what does LPO, LPC stand for?
04:46:12 <GregorR> Ha-HAH
04:46:20 <GregorR> I haven't read that code in sooooooooooooooooo long.
04:49:21 <bsmntbombdood> ...
04:59:19 <GregorR> LPO = LooP Open, LPC = LooP Close
05:02:00 <bsmntbombdood> ooh
05:02:10 <bsmntbombdood> I used JMPF and JMPT
05:02:30 <bsmntbombdood> "jump if false" and "jump if true"
05:38:55 -!- calamari has quit ("Leaving").
05:51:42 -!- oklopol has quit (Read error: 110 (Connection timed out)).
06:02:08 -!- ShadowHntr has joined.
06:19:48 -!- wooby has joined.
06:27:11 -!- wooby has quit.
06:28:54 -!- wooby has joined.
06:33:49 -!- oerjan has joined.
06:48:28 -!- ShadowHntr has quit (Client Quit).
07:01:57 -!- Asztal has joined.
07:06:49 <Asztal> IRP allowed? they've stopped now? ;)
07:07:07 <oerjan> Stopped, who?
07:07:43 <Asztal> The people who would find out about IRP on some social bookmarking site and come in here to test it
07:08:13 <oerjan> Ah yes. What _was_ that site, anyhow...
07:10:28 -!- oerjan has quit (Remote closed the connection).
07:10:32 -!- oerjan has joined.
07:19:46 <Asztal> stumbleupon, I think
07:22:44 -!- wooby has quit.
07:26:38 <lament> hm, i've never seen those people
07:26:58 -!- wooby has joined.
07:28:32 <lament> http://www.stumbleupon.com/url/esoteric.voxelperfect.net/wiki/IRP
07:28:34 <lament> there it is
07:34:35 <lament> did any stick around?
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
09:08:50 -!- oerjan has quit ("Not sticking around").
10:26:17 <SimonRC> lament: I see that you are a Go player from your exit message on #irp. I am too, but this is not the time to talk about it, alas.
10:26:20 * SimonRC goes
11:48:01 -!- ais523 has joined.
12:02:11 -!- ais523 has set topic: #esoteric - the international hub for esoteric programming language design and deployment - map: http://www.frappr.com/esolang - forum: http://esolangs.org/forum/ - EgoBot: !help (currently down) - wiki: http://esolangs.org/wiki/ - logs: http://tunes.org/~nef/logs/esoteric/ or http://meme.b9.com/cdates.html?channel=esoteric - for brainfuck-specific discussion, go to ##brainfuck - IRP ALLOWED - Pastebin: http://pastebin.ca/.
12:02:30 <ais523> For those who don't know, it was me who caused EgoBot to crash
12:03:13 <ais523> I fed it an infinite loop written in Unlambda, and it sent me an infinite number of copies of the letter 'b' in response, until it got thrown out
12:56:08 -!- ihope has quit (Read error: 110 (Connection timed out)).
14:05:11 -!- ais523 has quit ("this quit message is boring").
15:08:15 -!- proog has joined.
16:11:40 -!- ShadowHntr has joined.
16:17:10 -!- ShadowHntr has quit ("End of line.").
16:22:15 -!- sebbu has joined.
16:33:44 -!- proog has quit ("Chatzilla 0.9.77 [Firefox 2.0.0.1/2006120418]").
16:44:41 -!- jix__ has joined.
17:05:08 -!- tgwizard has joined.
17:40:51 -!- oerjan has joined.
18:25:04 -!- wooby has changed nick to juan_valdez.
18:25:09 -!- juan_valdez has changed nick to wooby.
18:51:53 -!- digital_me has joined.
18:53:01 -!- jix__ has changed nick to jix.
19:21:39 -!- surye has quit (Remote closed the connection).
19:30:06 * bsmntbombdood reads the ORK wiki page
19:38:32 <digital_me> bsmntbombdood: ORK?
19:39:25 <bsmntbombdood> http://esoteric.voxelperfect.net/wiki/ORK
19:46:19 <bsmntbombdood> GregorR: gah, why do you write everything in c++
19:47:54 -!- ShadowHntr has joined.
20:15:13 -!- oerjan has quit ("Despair").
20:29:33 -!- sebbu2 has joined.
20:40:09 -!- ihope has joined.
20:48:45 -!- sebbu has quit (Read error: 110 (Connection timed out)).
20:48:45 -!- sebbu2 has changed nick to sebbu.
20:53:19 -!- oklopol has joined.
21:34:04 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:06:40 -!- CakeProphet has joined.
22:30:05 <bsmntbombdood> I came up with an awesome esolang in math class just now
22:30:36 <bsmntbombdood> We have 2 stacks, an empty stack is filled with zeros
22:30:55 <bsmntbombdood> each command is one char
22:31:38 <bsmntbombdood> 'g' = take the logarithm of the top of the stack
22:31:48 <bsmntbombdood> '-' = subtract
22:32:05 <bsmntbombdood> '<' = push top of stack on to other stak
22:32:15 <bsmntbombdood> '>' = push top of other stack onto stack
22:32:26 <bsmntbombdood> '1' = push 1 onto stack
22:32:47 <bsmntbombdood> [] are the same as brainfuck
22:32:58 <bsmntbombdood> IO is the same as brainfuck
22:34:27 <CakeProphet> hmmm
22:34:37 <CakeProphet> FuckLogs?
22:35:13 <CakeProphet> hmm...
22:35:23 <CakeProphet> I'm not familiar with how to use logs to achieve nifty computations.
22:35:25 <CakeProphet> but that sounds cool.
22:35:29 <CakeProphet> double-stack languages are interesting.
22:35:49 * bsmntbombdood implements
22:36:06 <CakeProphet> I've been dabbling around with Thue-like ideas.
22:36:18 <CakeProphet> I'm going to be working on this one for a while I think..
22:36:39 <CakeProphet> for generating fractalic structures for other languages.
22:37:16 <CakeProphet> Like Thue... but with a decent ability to do computations and express structures.
22:38:42 <CakeProphet> and... maybe functional.
22:39:14 * ryanakca scratches his head
22:39:26 <CakeProphet> yup..
22:39:28 <CakeProphet> weird thought.
22:39:30 <CakeProphet> but..
22:39:32 <CakeProphet> fuck you
22:39:59 <ryanakca> why thank you CakeProphet :P
22:40:10 -!- Sgeo has joined.
22:40:14 * ryanakca deletes all of CakeProphet's PERL stuff :P
22:40:35 * ryanakca pulls the plug before CakeProphet saves his specification
22:40:41 <ryanakca> hehe
22:41:01 <ryanakca> Thue? fractalic structures? double-stack?
22:41:26 <CakeProphet> what Perl stuff. :P
22:45:49 <ryanakca> The stuff you set up in cygwin or whatever and that you were all thrilled about?
22:46:07 <CakeProphet> oh.
22:46:10 <CakeProphet> :P
22:47:46 <ryanakca> :P
22:57:40 <bsmntbombdood> ok, my interpreter works, except for looping, because that's hard
22:59:55 <oklopol> what are you making it with?
23:00:00 <bsmntbombdood> python
23:00:10 <oklopol> in python nothing is hard!
23:00:17 <ryanakca> lol
23:00:24 <oklopol> nothing small :)
23:00:44 <oklopol> hah you'd be so pissed if i made that language before you, bsmntbombdood :)
23:00:52 <ryanakca> CakeProphet: what do you say I start bugging oklopol with all my python problems?
23:01:01 <oklopol> noooooo :(
23:01:16 <oklopol> you can't solve python problems
23:01:27 <ryanakca> CakeProphet: give you a break...
23:01:37 <ryanakca> oklopol: well... you can solve mine... :D
23:02:33 <oklopol> bsmntbombdood, the operations only work on the other stack?
23:02:37 <oklopol> stack 1
23:02:39 <oklopol> right?
23:02:42 <bsmntbombdood> yeah
23:02:44 <oklopol> stack 2 is just for storing
23:02:46 <oklopol> k
23:03:21 <oklopol> logarithm in python?
23:03:27 <oklopol> or do i have to do my own?
23:03:36 <bsmntbombdood> math.log
23:03:38 <bsmntbombdood> use base 2
23:04:28 <ryanakca> btw... what's the difference between logarithm & algorithm?
23:04:55 <oklopol> whats the similarity?
23:06:04 <ryanakca> s/difference/difference & similarity
23:06:52 <bsmntbombdood> there is no similarity
23:07:25 <oklopol> (log base a)(a^x) = x
23:07:30 <oklopol> algorithm you should know
23:08:01 <bsmntbombdood> argh
23:08:14 <bsmntbombdood> I can't get cpp not to tell me a bunch of stuff I don't want to know
23:08:33 <ryanakca> oklopol: (log base a)(a^x) = x doesn't mean anything to me...
23:09:09 <oklopol> how old are you?
23:09:14 <oklopol> that's basic school stuff
23:09:34 <ryanakca> oh... 14
23:09:51 <oklopol> well, we learned it today, officially
23:09:56 <oklopol> i'm 17
23:10:07 <ryanakca> lol, ok :)
23:10:08 <oklopol> tho it's pretty basic stuff if you program
23:10:13 <oklopol> www.answers.com/logarithm
23:10:17 <ryanakca> kk, thanks
23:10:25 <oklopol> programmers know everything.
23:10:45 -!- tgwizard has quit (Read error: 110 (Connection timed out)).
23:10:59 <bsmntbombdood> there we go
23:11:08 <bsmntbombdood> cpp -P
23:12:43 <oklopol> i might have it now
23:12:57 <oklopol> nah
23:13:26 <oklopol> stack1[len(stack1)-1]=input()
23:13:30 <oklopol> this doesn't work
23:13:43 <oklopol> i never really read about pythons io
23:13:50 <oklopol> how do you do it?
23:14:36 <ryanakca> oklopol: ok... know what it is... why should I care about it... what would I use it in?
23:15:01 <oklopol> rarely
23:15:13 <oklopol> bsmntbombdood, floating point?
23:15:17 <bsmntbombdood> yes
23:15:39 <bsmntbombdood> for input do float(ord(sys.stdin.read()))
23:18:36 <oklopol> i might have it... tho i don't know how it's useful
23:18:52 <bsmntbombdood> argh, I can't figure out how to swap
23:18:54 <oklopol> you can only create 1's and zeroes with the log and subtraction :\
23:19:02 <oklopol> what you use as stack?
23:19:17 <oklopol> a,b=b,a :\
23:19:24 <bsmntbombdood> oklopol: no
23:19:35 <bsmntbombdood> I used a list as the stack
23:19:48 <bsmntbombdood> And I mean swap the top two values on the stack in this language
23:20:05 <oklopol> stackz[len(stackz)-2],stackz[len(stackz)-1]=stackz[len(stackz)-1],stackz[len(stackz)-2] then?
23:20:13 <oklopol> if stackz is your stack
23:20:22 <oklopol> or am i missing something?
23:20:23 <bsmntbombdood> just use list.append and list.pop
23:20:36 <oklopol> for swapping?
23:20:42 <bsmntbombdood> no
23:20:52 <bsmntbombdood> for the stack
23:20:55 <oklopol> that is not my code, that's the swap :\\
23:21:21 <bsmntbombdood> Not swap inside the interpreter, but swap in the language
23:21:24 <oklopol> i use append, i didn't know about pop :)
23:21:29 <oklopol> ah okay
23:21:43 <oklopol> but, can you give me something to run?
23:21:46 <oklopol> so i can test
23:22:19 <bsmntbombdood> "1 1-." should print "0"
23:22:31 <bsmntbombdood> or NUL, depending on how you do the output
23:22:37 <oklopol> ryanakca, for a simple and useless example, if you wanna converta number to a spesific base and allocate only what's necessary, you can use logs to calculate the length of the final string :)
23:22:59 <oklopol> >>> runsome("1 1-.")
23:22:59 <oklopol> 0
23:22:59 <oklopol> 0.0
23:23:01 <oklopol> 0 is debug
23:23:46 <oklopol> once again i got it working right away but couldn't use it right and thought it was flawed :D
23:23:53 <oklopol> i mean, up to that part
23:24:15 <oklopol> something hard that can fail actually... i assume you coded something in the math class :)
23:24:36 <bsmntbombdood> Do you have [ and ] yet?
23:24:44 <CakeProphet> ryanakca, An algorithm is just "an ordered procedure of steps that produces a desired outcome"
23:24:45 <CakeProphet> ....a program.
23:24:48 <oklopol> hmm... 6½ hours till school and 10 english tasks to do and i'm coding again :(
23:24:53 <oklopol> yes
23:24:58 <oklopol> i haves
23:25:02 <CakeProphet> logarithm is just the inverse of the exponent function.
23:25:08 <CakeProphet> totally different thing.
23:25:10 <CakeProphet> s
23:25:29 <oklopol> 11g1-- will produce 2 right?
23:25:47 <oklopol> ya
23:25:58 <oklopol> hmm, i don't specify the base
23:26:10 <oklopol> math.log(numz, [baze]) is it?
23:26:22 <oklopol> i just have math.log(...) now
23:26:54 <CakeProphet> pretty sure
23:26:59 <bsmntbombdood> yes
23:27:08 <CakeProphet> if all else fails just use the help function.
23:27:13 * CakeProphet loves help()
23:27:18 <oklopol> :D
23:27:26 <bsmntbombdood> TWO ZERO TWO -- ZERO TWO ZERO TWO -- -- g .
23:27:30 <bsmntbombdood> should produce "3.0"
23:27:40 <oklopol> TWO being?
23:27:44 <bsmntbombdood> #define ZERO 1 1-
23:27:44 <bsmntbombdood> #define TWO 1 1-1-1->1 1-<-
23:27:52 <bsmntbombdood> I'm running the code through cpp
23:27:52 -!- fatalis has joined.
23:27:56 <fatalis> UWAAAAAH
23:27:58 <oklopol> ah okay
23:28:01 -!- fatalis has left (?).
23:28:07 <oklopol> your interpreter c++ too?
23:28:10 <bsmntbombdood> no
23:28:22 <oklopol> i'd do it faster in c++ prolly but i'd have to make a project :\
23:28:52 <oklopol> 1 1-1-1->1 1-<- === 11g1--
23:29:19 <bsmntbombdood> 1g is zero
23:29:51 <oklopol> yes... i know
23:29:54 <oklopol> but, math.log
23:29:59 <oklopol> how to make it 2-base?
23:30:24 <oklopol> 1 1g 1 -- == 1 0 1 -- == 1 (-1) - == 1+1 == 2
23:31:17 <oklopol> bsmntbombdood, you must have it if you use it :\
23:31:24 <oklopol> oh
23:31:28 <oklopol> yeah
23:31:33 <oklopol> you have c++++++++++++++++++++++
23:31:43 <oklopol> i always think of you as one of the python guys
23:31:47 <oklopol> :)
23:31:50 <bsmntbombdood> huh?
23:31:55 <oklopol> math.log
23:31:59 <oklopol> 2-base
23:31:59 <oklopol> how
23:32:01 <oklopol> ?
23:32:07 <bsmntbombdood> second argument
23:32:25 <oklopol> TypeError: log() takes exactly 1 argument (2 given)
23:32:40 <oklopol> stack1[len(stack1)-1]=math.log(stack1[len(stack1)-1],2)
23:32:45 <oklopol> that's what i have
23:33:05 <bsmntbombdood> uuuuh
23:33:09 <bsmntbombdood> what python version?
23:33:28 <oklopol> :O
23:33:31 <oklopol> IDLE 0.8...
23:33:35 <oklopol> i have no idea
23:33:36 <oklopol> 2.2
23:33:37 <oklopol> i think
23:33:45 <bsmntbombdood> that's ooooold
23:33:47 <oklopol> or 2.4
23:33:50 <oklopol> ya :)
23:34:01 <bsmntbombdood> do math.log(x)/math.log(2) then
23:34:38 <oklopol> yeah, figured that just now
23:36:23 <oklopol> but
23:36:28 <oklopol> produces 3.0,. yeah
23:36:41 <oklopol> but it's kinda obvious non-looping works
23:37:00 <oklopol> and i'd be pretty suprised if the rest didn't :\
23:37:23 <oklopol> not my first brainfuck-loop exactly
23:38:16 <bsmntbombdood> how'd you do it?
23:38:23 <oklopol> what?
23:38:26 <oklopol> the loop?
23:38:34 <oklopol> i use a counter
23:38:36 <bsmntbombdood> yeah
23:38:39 <oklopol> for open brackets
23:38:45 <oklopol> easiest way
23:39:00 <bsmntbombdood> ...
23:39:04 -!- RodgerTheGreat has quit (Read error: 104 (Connection reset by peer)).
23:39:12 <oklopol> oh
23:39:13 <oklopol> sorry
23:39:20 <oklopol> that was the worst explanation ever
23:39:45 <oklopol> when i encounter [ i set opens=1, then go right until opens==0 while [ incs, ] decs
23:39:56 <oklopol> then just copypaste for ]
23:40:01 <oklopol> and some random swapping
23:40:35 <bsmntbombdood> show me the source
23:40:42 <oklopol> hmm
23:40:45 <oklopol> pastebin?
23:40:56 <bsmntbombdood> yeah
23:40:59 <oklopol> hmm
23:41:09 <oklopol> you remember any? :)
23:41:23 <bsmntbombdood> pastebin.ca
23:41:24 <oklopol> found
23:41:27 <oklopol> okay :)
23:42:14 <oklopol> http://cpp.sourceforge.net/?show=27733
23:42:28 <oklopol> (pastebin.ca wasn't a link :>)
23:42:54 <oklopol> i hate whitespace, sorry about that
23:43:47 <bsmntbombdood> It doesn't do anything
23:43:48 <oklopol> i'm not sure if stack1=stack1[:-1] means cut off last
23:43:53 <oklopol> but i'll change to pop
23:44:38 <oklopol> k now i have it
23:44:42 <oklopol> oh :(
23:44:56 <oklopol> runsome("11g1--11-11g1----11-11g1--11-11g1------g.")
23:45:04 <oklopol> will call it and produce 3
23:45:44 <bsmntbombdood> hrm, I think it needs a way to invert a logarithm
23:46:02 <oklopol> 1g11g-1-11g1---- is also 3
23:46:26 <oklopol> eh
23:46:27 <oklopol> no
23:46:40 <bsmntbombdood> ?
23:47:05 <oklopol> ?
23:47:10 <oklopol> but, it didn't work?
23:47:18 <oklopol> the function
23:47:19 <bsmntbombdood> ?
23:47:24 <bsmntbombdood> I didn't try
23:47:27 <oklopol> ah okay
23:47:31 <bsmntbombdood> but the code for [] doesn't do anything
23:47:56 <oklopol> oh
23:48:00 <oklopol> it changes icode
23:48:12 <oklopol> which is the index of code which is the code string
23:48:28 <oklopol> elif code[icode]==']':
23:48:28 <oklopol> if stack1[len(stack1)-1]!=0:
23:48:28 <oklopol> opens=1
23:48:28 <oklopol> icode-=1
23:48:28 <oklopol> while opens:
23:48:28 <oklopol> if code[icode]=='[':
23:48:30 <oklopol> opens-=1
23:48:32 <oklopol> elif code[icode]==']':
23:48:34 <oklopol> opens+=1
23:48:36 <oklopol> icode-=1
23:48:38 <oklopol> icode+=1
23:48:40 <oklopol> ...
23:48:47 <oklopol> "icode-="
23:48:50 <oklopol> eh
23:48:52 <oklopol> okay
23:48:56 <oklopol> the copypaste is nice
23:49:18 <bsmntbombdood> ?
23:49:36 <oklopol> why does it not do anything?
23:49:45 <oklopol> it changes icode, right?
23:49:58 <oklopol> and that's what a loop does, changes IP, right?
23:50:00 <oklopol> right?
23:50:05 <bsmntbombdood> hrm
23:50:22 <bsmntbombdood> yeah
23:50:26 <oklopol> yay
23:50:34 <bsmntbombdood> I dunno if that works though
23:50:40 <oklopol> maybe not
23:50:50 <oklopol> i've done more that 20 bf-interpreters
23:50:55 <oklopol> tho
23:51:03 <oklopol> most like that
23:51:39 <CakeProphet> I usually just use class variables.
23:51:46 <CakeProphet> class lolBF(object):
23:51:50 <CakeProphet> inc = ">"
23:51:52 <CakeProphet> dec = "<"
23:51:54 <CakeProphet> etc
23:52:05 <CakeProphet> same thing in practice.
23:52:08 <CakeProphet> less typing though. :P
23:52:19 <bsmntbombdood> ?
23:53:23 <bsmntbombdood> hmm, looks like that actually works
23:53:24 <oklopol> def makenumber(n):
23:53:24 <oklopol> if n==0:
23:53:24 <oklopol> return "1g"
23:53:24 <oklopol> return "11g"*(n-1)+"1"+"--"*(n-1)
23:53:30 <oklopol> generic algo for numbersa
23:53:32 <oklopol> *-a
23:53:46 <CakeProphet> hnnn,,,,
23:55:10 <oklopol> hmm... do i do a generic number-> bsmntbombdood-code function or english?
23:55:30 <bsmntbombdood> ?
23:55:34 <oklopol> i'm not sure about my math skills tho
23:55:37 <oklopol> ??
23:56:12 <oklopol> you know, everytime you use a question mark, i check everything i said for 20 lines
23:57:02 <bsmntbombdood> <oklopol> hmm... do i do a generic number-> bsmntbombdood-code function or english?
23:57:10 <oklopol> ya
23:57:47 <oklopol> with logarithms it's hard to get the exact number but you get close enought
23:57:48 <oklopol> *-t
23:58:04 <oklopol> *impossible
23:58:13 -!- ShadowHntr has quit ("End of line.").
23:58:43 <oklopol> i don't think you can retrieve a single rational non-integer with logs
23:58:51 <bsmntbombdood> dunno
23:58:53 <oklopol> is it mathematically possible?
23:59:00 <oklopol> but, doesn't matter
23:59:34 <oklopol> hmm
23:59:38 <oklopol> looping test...
23:59:39 <oklopol> oh
23:59:43 <oklopol> maybe a loop!
←2007-01-16 2007-01-17 2007-01-18β†’ ↑2007 ↑all