2007-01-01:

00:20:22 -!- CakeProphet has quit (Read error: 104 (Connection reset by peer)).
00:20:33 -!- CakeProphet has joined.
00:29:45 -!- digital_me has joined.
00:41:12 -!- digital_me has quit ("Lost terminal").
00:43:31 -!- RodgerTheGreat has joined.
00:49:08 -!- Asztal has joined.
00:49:18 * RodgerTheGreat tips his hat
00:53:36 <Asztal> happy new year! for me, anyway ;)
00:55:17 <RodgerTheGreat> cool! My new year isn't for a couple of hours. What's it like in the future?
00:55:35 <RodgerTheGreat> do you have flying cars?
00:57:01 <Asztal> What are cars? Oh, those old things!
01:01:43 <GregorR> New Years loses some of its luster when 99% of the people I talk to online have already been through it :P
01:02:12 <Asztal> Yeah, it's old by the time you have it :(
01:02:45 <Asztal> Oh well, you get Castlevania: Portrait of Ruin 3 months before us
01:02:49 <Asztal> :P
01:05:35 <GregorR> lol
01:07:00 <RodgerTheGreat> I'm not really sure how you can say a castlevania sequel is worth as much as a glimpse into... THE WORLD OF TOMORROW!
01:24:33 <Asztal> well, for me, a castlevania sequel would be a glimpse into the world of tomorrow
01:25:03 <bsmntbombdood> castlevania?!?
01:47:05 -!- Asztal has quit (Read error: 60 (Operation timed out)).
02:24:00 -!- oerjan has quit (sterling.freenode.net irc.freenode.net).
02:24:00 -!- GregorR has quit (sterling.freenode.net irc.freenode.net).
02:24:01 -!- Sukoshi has quit (sterling.freenode.net irc.freenode.net).
02:24:01 -!- tgwizard has quit (sterling.freenode.net irc.freenode.net).
02:24:01 -!- pikhq has quit (sterling.freenode.net irc.freenode.net).
02:24:01 -!- sekhmet has quit (sterling.freenode.net irc.freenode.net).
02:24:02 -!- sp3tt has quit (sterling.freenode.net irc.freenode.net).
02:24:03 -!- mtve has quit (sterling.freenode.net irc.freenode.net).
02:24:03 -!- RodgerTheGreat has quit (sterling.freenode.net irc.freenode.net).
02:24:03 -!- CakeProphet has quit (sterling.freenode.net irc.freenode.net).
02:24:03 -!- cmeme has quit (sterling.freenode.net irc.freenode.net).
02:24:04 -!- puzzlet has quit (sterling.freenode.net irc.freenode.net).
02:24:05 -!- lament has quit (sterling.freenode.net irc.freenode.net).
02:24:05 -!- pgimeno has quit (sterling.freenode.net irc.freenode.net).
02:24:06 -!- SimonRC has quit (sterling.freenode.net irc.freenode.net).
02:24:06 -!- tokigun has quit (sterling.freenode.net irc.freenode.net).
02:24:06 -!- EgoBot has quit (sterling.freenode.net irc.freenode.net).
02:24:06 -!- bsmntbombdood has quit (sterling.freenode.net irc.freenode.net).
02:30:06 -!- mtve has joined.
02:30:06 -!- sekhmet has joined.
02:30:06 -!- sp3tt has joined.
02:30:06 -!- GregorR has joined.
02:30:06 -!- pikhq has joined.
02:30:06 -!- tgwizard has joined.
02:30:06 -!- Sukoshi has joined.
02:30:06 -!- lament has joined.
02:30:26 -!- oerjan has joined.
02:30:29 -!- RodgerTheGreat has joined.
02:30:29 -!- CakeProphet has joined.
02:30:29 -!- cmeme has joined.
02:30:29 -!- puzzlet has joined.
02:30:29 -!- pgimeno has joined.
02:30:29 -!- tokigun has joined.
02:30:29 -!- SimonRC has joined.
02:30:34 -!- EgoBot has joined.
02:30:34 -!- bsmntbombdood has joined.
02:31:21 <CakeProphet> yay.
02:31:55 <bsmntbombdood> gah
02:35:23 -!- oerjan has changed nick to oerjan_.
02:35:50 -!- oerjan_ has changed nick to oerjan.
02:37:15 * CakeProphet writeth a esolang.
02:37:21 <CakeProphet> BUT IT'S A SECRET SO NO TELL WHAT IT DOES LOLOL
03:05:20 -!- ivan` has quit (Read error: 54 (Connection reset by peer)).
03:06:14 -!- ivan` has joined.
03:21:53 -!- tgwizard has quit (Remote closed the connection).
04:08:34 -!- oerjan has quit ("Good night.").
04:29:11 <CakeProphet> GregorR,   oh?
04:29:13 <CakeProphet> ha!
04:29:15 <CakeProphet> You lose.
04:29:33 <CakeProphet> Can EgoBot have interpreters made in any language?
04:29:48 <pikhq> It executes the interpreters seperately.
04:29:58 <pikhq> Calls exec() and all that.
04:30:33 <CakeProphet> so... yes?
04:30:37 <pikhq> Yes.
04:30:43 <CakeProphet> Swell.
04:30:51 <pikhq> You could have interpreters in Brainfuck for all it cares.
04:32:41 <CakeProphet> When I finish the interpreter for "stew" I'd like to put it on EgoBot... as I'm too lazy to code up an IRC bot at the moment.
04:33:08 <pikhq> Download the EgoBot source code, fiddle with it yourself.
04:33:32 <CakeProphet> hmmm... I can't read C well, but I'll try that as well.
04:43:26 <CakeProphet> hmmm...
04:43:39 <CakeProphet> BF should have syntax highlighting... all the eight characters would be colors of the rainbow.
04:44:17 <CakeProphet> and... like... brown
04:44:20 <CakeProphet> add a brown in.
04:44:22 <CakeProphet> just cause.
04:45:34 -!- calamari has joined.
04:48:15 <pikhq> . . .
04:49:09 <bsmntbombdood>  . . .
04:49:15 <bsmntbombdood> . . .
04:49:17 <bsmntbombdood>  . . .
04:49:19 <bsmntbombdood> . . .
04:49:21 <bsmntbombdood>  . . .
04:52:12 <pikhq> !!!
04:52:14 <EgoBot> Huh?
04:52:24 <pikhq> Teehee.
04:52:43 <pikhq> [Does EgoBot do IRP? No? Okay.]
05:47:35 <CakeProphet> so...
05:47:42 <CakeProphet> this is totally brain-warping.
05:48:01 <CakeProphet> trying to design a stack-of-queues-based language that actually... works.  O.o
05:49:06 <bsmntbombdood> it is?
05:55:03 <CakeProphet> ...well, it -was- :D
05:55:07 <CakeProphet> until I got a great idea.
06:09:19 <RodgerTheGreat> CakeProphet: I can provide you with a basic IRCbot skeleton for Java, if you want it
06:09:46 <CakeProphet> I know less of Java than I do C> :D
06:09:59 <RodgerTheGreat> Java is easier to learn
06:10:17 <CakeProphet> I think for the moment I'll just bolt it onto EgoBot  (once I test it and get it running)
06:10:48 <CakeProphet> I don't have much of a desire for an IRC bot anyways... except possibly for some odd interpreters.
06:15:29 <bsmntbombdood> java is poop
07:34:42 -!- freshness has joined.
07:36:11 -!- freshness has left (?).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:04:46 -!- calamari has quit (Client Quit).
08:12:44 <CakeProphet> hmmm... weird.
08:13:16 -!- RodgerTheGreat has quit.
08:14:02 <CakeProphet> Stew needs only about 4 or 5 different commands and some built-in functions... looks pretty lightweight.
08:16:18 <CakeProphet> hmmm....
08:17:25 <CakeProphet> Hello World would be   om!"Hello World"!?spam?%
08:17:31 <CakeProphet> er...
08:17:40 <CakeProphet> !"Hello World"!?spam?
08:17:43 <EgoBot> Huh?
08:17:56 <CakeProphet> !"Hello World"!?spam?%O
08:17:58 <EgoBot> Huh?
08:18:50 <CakeProphet>  om!?spam?"Hello World"%O                  would work as well
08:19:35 <CakeProphet> Yay queue-stacks!
09:47:58 <GregorR> To celebrate the new years ... we bought diet coke and mentos ^^
09:58:01 <CakeProphet> ...
09:58:03 <CakeProphet> whoooo...
09:59:18 <tokigun> GregorR, how many? :p
10:36:52 <CakeProphet> hehe... is it bad taste to include a builtin function in an esolang that executes Python code in a string?  :D
10:51:24 -!- anonfunc has joined.
11:36:22 -!- tgwizard has joined.
12:23:55 -!- oerjan has joined.
12:24:06 <CakeProphet> yay parsing.
12:24:24 <CakeProphet> oerjan,  I found a nifty parsing library for Python that looks almost like BNF
12:24:50 <oerjan> aha
12:26:41 <CakeProphet> makin' an esolang.
13:35:13 <CakeProphet> oerjan,  eep!
13:35:19 <CakeProphet> My parser is teh borken.
13:36:21 <CakeProphet> http://deadbeefbabe.org/paste/3095
13:36:31 <CakeProphet> See anything in the grammar definitions that's making it fuck up?
13:36:40 <CakeProphet> on the test program at the bottom... 
13:36:45 <CakeProphet> all the debugging stuff is at the bottom too.
14:24:28 <oerjan> i was away.
14:24:40 <CakeProphet> lol ya rite
14:24:45 <CakeProphet> you were laughing at me.
14:24:56 <oerjan> from the shower? :)
14:27:25 <CakeProphet> ....yes
14:27:31 <oerjan> lolno? :)
14:27:39 <CakeProphet> SHUTUP
14:27:42 <CakeProphet> ...
14:27:44 <CakeProphet> I mean.
14:27:46 <CakeProphet> yes.
14:27:51 <CakeProphet> yes that's the name of it.
14:28:02 <CakeProphet> There needs to be a funky Esoteric Parsing Language.
14:28:46 <oerjan> regular expression are pretty esoteric, really.
14:28:50 <oerjan> *s
14:29:37 <CakeProphet> They're not esoteric enough.
14:31:00 <oerjan> Thue might work.
14:31:28 <CakeProphet> I just can't figure out why my grammar is screwing up on the program.
14:31:42 <CakeProphet> when... looking at it... it seems like it would work fine.
14:32:02 <oerjan> could you give a short example that breaks?
14:32:17 <CakeProphet> at the very bottom of the pastebin thing.
14:32:25 <CakeProphet> The Hello World program.
14:32:32 <CakeProphet> with some debugging shit below it.
14:34:33 <CakeProphet> In Stew everything is a single character... except for things enclosed in quotes or ?'s
14:35:18 <CakeProphet> any character that doesn't serve a special purpose is a "symbol"... 
14:36:28 -!- jix_ has joined.
14:37:09 <CakeProphet> and anything in ?'s is a symbol   (what a symbol becomes depends on the context... it's a function if possible, otherwise an integer, otherwise a floating point number, otherwise a string)
14:37:22 <CakeProphet> things in quotes are just strings.
14:40:35 <CakeProphet> The layout is a stack of queues (a stew)... so all symbols (which are either functions, integers, floats, or strings, or bools) are put into the queue on the top of the stack.... and the builtin commands manipulate values in the stew.
14:41:02 <CakeProphet> It's like a weird variant of stack based languages. :D
14:50:59 -!- Sph1nx has joined.
14:51:22 -!- Sph1nx has quit (Connection reset by peer).
15:26:56 <oerjan> i haven't solved it, but a minor point: CharsNotIn matches a string, not a single character.
15:33:23 <CakeProphet> oerjan,  I set it to match exactly one.
15:33:28 <CakeProphet> exact=1
15:33:49 <oerjan> ah.
15:33:58 <oerjan> darn options :)
15:35:06 <CakeProphet> it looks like it is looking for an exact match size or something.
15:35:16 <CakeProphet> Like... how does it know it's 8 chars away?
15:35:32 <oerjan> what it _seems_ to me from reading the program, is that the OneOrMore barfs after reading one expression.
15:36:31 <CakeProphet> yeah...
15:36:36 <CakeProphet> but, it could be something else.
15:36:52 <CakeProphet> Group() is supposed to convert the match to a list of all repetitions.
15:37:15 <oerjan> yes, but if OneOrMore has a bug, then it would completely explain the debugging output.
15:39:06 <CakeProphet> doubt it.
15:39:13 <CakeProphet> pyparsing is third party... and pretty well used.
15:39:28 <CakeProphet> ZeroOrMore does the same thing.
15:39:36 <CakeProphet> and I tried removing Group() to see what happend... same thing.
15:40:35 <oerjan> have you tried replacing ?spam? with a one-character command?
15:40:59 <CakeProphet> nope.
15:41:09 <CakeProphet> lemme change the name of the output function to "o" and give it a shot.
15:41:24 <oerjan> and, also try an op definition with just a single expression.
15:41:52 <oerjan> (but not at the same time :) )
15:42:06 <CakeProphet> hmmm... same problem.
15:42:10 <CakeProphet> with o as a function.
15:42:16 * CakeProphet clips off the "hello world" and tries.
15:42:38 <CakeProphet> ha, it worked that time.
15:43:51 <CakeProphet> Matched {Suppress:("!") op name op definition Suppress:(";")} -> ['m', ['0', '^']]
15:43:53 <CakeProphet> ((['m', (['0', '^'], {})], {}), 0, 5)
15:44:32 <CakeProphet> so... it could possibly the string that's borking it up.
15:44:41 <oerjan> aha
15:45:59 <oerjan> yes, that might do it too, and might give the same errors.
15:47:06 <oerjan> do you think it could be a problem that STRQUOTE is a two-element string?
15:47:35 <oerjan> if QuotedString accepts only a single quotechar
15:48:30 <CakeProphet> hmmm... I remember saying it could be two.
15:48:37 <CakeProphet> but... I'll change it to one and see what happens.
15:49:15 <CakeProphet> Now I'm glad I made big glaring capital letter constants.
15:49:20 <CakeProphet> makes everything super-easy to modify.
15:49:25 <oerjan> heh :)
15:50:01 <CakeProphet> hmm... now it parses with just the one quote :D
15:50:26 <CakeProphet> now the bug-handling is safely back in my realm...
15:50:36 <oerjan> elementary, my dear CakeProphet :)
15:50:47 <CakeProphet> :P  I'm bug-prone.
15:51:47 <oerjan> hah, you should have seen all the syntax and type errors I got after updating IrpBot tonight.
15:52:32 <CakeProphet> ((['m', (['0', 'Hello World', '^'], {})], {}), 0, 18)
15:52:41 <CakeProphet> that's a confounding data structure :P
15:52:49 <oerjan> fortunately the Haskell compiler caught most of the bugs.  Hooray for static typing. :)
15:53:26 <CakeProphet> heh... errors involving type are usually pretty easy to fix.
15:53:48 <oerjan> probably.
15:54:20 <CakeProphet> {'rand': <function rand at 0x00AEFD70>, 'm': !m - 0, '+': <function add at 0x00AEFBB0>, '*': <function mul at 0x00AEFC30>, '-': <function sub at 0x00AEFBF0>, '/': <function div at 0x00AEFCB0>, 'lolno': <function neg at 0x00AEFB70>, 'o': <function out at 0x00AEFDB0>, 'in': <function inp at 0x00AEFDF0>, 'mod': <function mod at 0x00AEFCF0>, '=': <function eq at 0x00AEFB30>, 'round': <function...
15:54:22 <CakeProphet> ...round at 0x00AEFD30>, '^': <function exp at 0x00AEFC70>}
15:54:25 <CakeProphet> My beautiful operator dictionary.
15:54:37 <oerjan> those {} could need some pruning. Missing some .suppress'es?
15:54:50 <CakeProphet> the {} are for if I specify names for certain parts.
15:54:55 <CakeProphet> .setResultsName()
15:55:15 <CakeProphet> it creates a mapping to them.
15:55:29 <oerjan> aha
15:55:32 <CakeProphet> good for when you have a bunch of syntical parts with no real position to them.
15:57:35 <CakeProphet> see... with some names added... my confounding data structure becomes:
15:57:37 <CakeProphet> ((['m', (['0', 'Hello World', '^'], {})], {'opname': [('m', 0)], 'opdef': [((['0', 'Hello World', '^'], {}), 1)]}), 0, 18)
15:57:41 <CakeProphet> even more confounding.
15:58:07 <CakeProphet> not sure what the 0 thereis next to "m"...
15:58:32 <CakeProphet> ah... position
15:58:54 <CakeProphet> so if I grab the syntax by name... I have a handy reference to position.
15:59:06 <CakeProphet> Damn... they should have wrapped all this in a class... it gets easily confusing.
16:01:05 <CakeProphet> ah... it is.
16:01:10 <oerjan> reading the logs - i am sure someone must have made an irc bot in python you can snatch.
16:01:28 <CakeProphet> it's just the string representation of the class... so it looks like a crapload of tuples, lists, and dictionaries.
16:06:00 <oerjan> Well, I am out of the house.
16:06:25 <CakeProphet> alrighty
16:06:29 * CakeProphet waves.
16:06:56 <CakeProphet> thanks a bunch.
16:07:30 <oerjan> You're welcome.
16:07:42 -!- oerjan has quit ("Leaving").
16:13:07 -!- RodgerTheGreat has joined.
16:13:34 <RodgerTheGreat> how's it going everybody?
16:16:11 <CakeProphet> parsing :P
16:20:39 * CakeProphet is fleshing out an esolang.
16:20:49 <CakeProphet> once I've finished it and bug tested it I'ma get up on IRC somehow.
16:20:58 <CakeProphet> easiest way would be right through EgoBot
16:26:52 -!- ivan` has quit (" HydraIRC -> http://www.hydrairc.com <- Leading Edge IRC").
16:46:47 -!- Asztal has joined.
17:07:00 -!- Sph1nx has joined.
17:28:57 -!- Asztal has quit (Read error: 113 (No route to host)).
17:29:24 -!- Sph1nx has quit (Connection timed out).
17:41:53 -!- Sph1nx has joined.
17:46:53 -!- Sph1nx has quit ("äÏ Ó×ÉÄÁÎÉÑ ×ÓÅÍ!").
17:55:07 -!- ihope_ has joined.
17:55:12 <ihope_> Oh, rightright.
17:56:40 <ihope_> What's SOAP looking like so far?
17:59:35 <RodgerTheGreat> there was some discussion of using FORTH to write portions of the kernel.
17:59:50 <RodgerTheGreat> others want to just write a glass interpreter in C as the kernel
18:00:06 <RodgerTheGreat> and Gregor has a working bootable BF interpreter
18:00:13 <ihope_> Bootable?
18:00:16 <RodgerTheGreat> yeah
18:00:43 <ihope_> Hmm.
18:00:55 <RodgerTheGreat> so, we're making a little progress
18:01:03 <ihope_> Doesn't the kernel go on top of SOAP?
18:01:47 <ihope_> SOAP is the computer, at least in theory. In practice, SOAP is the emulator.
18:03:31 <RodgerTheGreat> we were thinking of the OS more as an interpreter for an esolang that will be used to host other interpreters. The base interpreter itself is what creates the hardware interface, memory management, etc, and is the kernel
18:04:08 <ihope_> And if we're writing in Glass, SOAP is the basic set of classes.
18:05:08 <RodgerTheGreat> yes, but they'd be builtins.
18:05:42 <RodgerTheGreat> you can't really synthesize things like low-level hardware access by writing them *in* glass.
18:07:17 <ihope_> Yes, SOAP would be the builtins.
18:07:42 <RodgerTheGreat> exactly
18:07:54 <ihope_> SOAP is the builtins, and the OS is the code that uses them.
18:08:19 <pikhq> In essence, we've got the whole OS, kernel and all, in an esolang.
18:08:26 <pikhq> (C is an esolang, IMO. :p)
18:08:30 <RodgerTheGreat> alright, I guess you could go with that definition. Ultimately they're two parts of a single program
18:08:58 <ihope_> Well, you could have multiple operating systems written for SOAP.
18:09:01 <RodgerTheGreat> C is an esolang in the same sense as BASIC is an esolang.
18:09:32 <RodgerTheGreat> If you do horribly evil obfuscations and play with the limitations of your compiler/interpreter, it can be an esolang
18:09:38 <ihope_> Aren't languages only considered esolangs if they're meant to be esolangs?
18:09:52 <RodgerTheGreat> it ultimately depends on your opinion
18:09:57 <ihope_> Maybe some horrible subset of C that plays with the limitations of your compiler/interpreter...
18:10:21 <pikhq> ihope_: That's the best part of C!
18:10:31 <pikhq> (sorry; I've been doing IOCCC coding recently)
18:10:33 <ihope_> It has horrible subsets?
18:10:36 <RodgerTheGreat> I don't personally think C is very esoteric... painful, maybe... but the IOCC seems to indicate it can be used as an esolang
18:11:05 <pikhq> It at least includes an esolang.
18:11:19 <pikhq> (if you don't think the preprocessor is an esolang, you've not done esoteric coding)
18:11:36 -!- Arrogant has joined.
18:11:53 <ihope_> How about we call the operating system itself PAOS?
18:12:05 <ihope_> It conveniently ends with "OS", after all.
18:12:44 <pikhq> Standing for?
18:13:00 <RodgerTheGreat> how about SOS? The eSoteric Operating System?
18:13:14 <ihope_> That too.
18:13:15 <CakeProphet> Why must OSes end with OS?
18:13:19 <RodgerTheGreat> and yes, the C preprocessor qualifies as an esolang, even if C proper doesn't
18:13:33 <ihope_> pikhq: hey, if I backronymmed SOAP, I can do it with PAOS!
18:13:43 <CakeProphet> Does that make C a minsky machine?
18:13:45 <RodgerTheGreat> CakeProphet: this is why I went the non-acronymic route with my suggestion of "Framework"
18:13:53 <pikhq> Heheh.
18:14:04 <CakeProphet> having a declaritive phase and an imperitive phase?
18:14:04 <bsmntbombdood> doobey
18:14:19 <ihope_> Probably Atrocious Operating System?
18:14:26 <bsmntbombdood> C is fun
18:15:06 <RodgerTheGreat> C is pain. They have a name for people like you- Masochists.
18:15:26 <bsmntbombdood> C is fun
18:15:33 <RodgerTheGreat> this does, of course, describe most esolang enthusiasts as well.
18:15:38 * bsmntbombdood eats some reheated pizza
18:15:42 <CakeProphet> There should be an esolang with one instruction... and a preprocessor with 90 or so commands.
18:15:59 <bsmntbombdood> CakeProphet: mine
18:16:27 <ihope_> CakeProphet: after proprocessing, wouldn't you just end up with a bunch of that one instruction?
18:17:28 <CakeProphet> Yes.
18:17:40 <CakeProphet> well... maybe
18:18:04 <CakeProphet> the preprocessor can do anything it wants to the code before executing the one-instructioned code.
18:18:26 <bsmntbombdood> someone should write a C compiler in cpp
18:18:36 <ihope_> But isn't preprocessing done at compile-time?
18:18:38 <pikhq> It *can8 be done.
18:18:52 <CakeProphet> ihope_,  why is that signifigant?
18:18:53 <pikhq> Cpp is, after all, Turing complete.
18:18:56 <pikhq> >:D
18:19:05 <pikhq> ihope_: It can be done seperately. ;)
18:19:05 <bsmntbombdood> it is?
18:19:12 <bsmntbombdood> it can?
18:19:30 <ihope_> CakeProphet: well, if you want to compile the program every time you run it...
18:19:43 <ihope_> Hmm.
18:19:46 <pikhq> bsmntbombdood: man cpp
18:19:48 <pikhq> info cpp
18:20:17 <ihope_> Maybe the preprocessor actually does just turn the code around, except output is possible via syntax errors.
18:20:57 <pikhq> The preprocessor is a seperate macro language, which happens to be designed to work with C-style syntax.
18:21:14 <pikhq> (as Gregor has proven, it can be applied to more than just that. . . See mbf.)
18:35:23 <ihope_> ...So, should we start thinking about SOAP?
18:36:04 <ihope_> Maybe there's a Device class and a Generator class, and invoking a Generator gives you a random Device.
18:36:21 <ihope_> That is, a Device that represents a random device.
18:37:04 <ihope_> So you just keep invoking the Generator randomly until you find a new device, then you store that device away somewhere.
18:37:23 <bsmntbombdood> wtf are you talking about
18:37:35 <ihope_> The classes that should be included in SOAP.
18:37:50 <bsmntbombdood> ...
18:38:16 <ihope_> Actually, maybe scrap the Generator and have each Device created be a random one.
18:40:33 <CakeProphet> ....so the OS would pick random devices to write too when someone wants to write to a decibe???
18:40:58 <ihope_> Write to a what?
18:41:15 <bsmntbombdood> a fooh?
18:41:28 <ihope_> The OS would be constantly pulling random devices and storing them somewhere.
18:41:47 <ihope_> If it ever met a device it already had, it would just throw it away and keep looking for new ones.
18:42:01 <bsmntbombdood> jtongue
18:42:54 <ihope_> Am I making any more sense than you are?
18:43:23 <bsmntbombdood> baba gnooush
18:43:27 * bsmntbombdood leaves
18:47:33 <bsmntbombdood> This manoeuvre, then, is ever precipitate -- and yet in the remotely antique.
18:59:00 <ihope_> The kind fodder takes architects.
18:59:21 <ihope_> (The above sentence was stolen from some bot in some channel on some server belonging to some network.)
18:59:39 <bsmntbombdood> The worm had brought me as I had seen in this little opportunity to know her whole of no great beauty.
18:59:55 <ihope_> (Specific(al)ly, Ami in #lobby on irc.aftran.com:9999 of Sine-Waves.)
19:01:28 <ihope_> ¿Por qué me comes? Quiero que comas mi perro.
19:03:14 <bsmntbombdood> Truff as had by at one-lessel. I prect, nor A. A my conly unateremoduskips, wered by no, le in you arger some trapen of floss
19:12:59 <ihope_> But alas, my truffles had not yet sprung into routers! If the co-ax need not be run, let my basement fly beside his windmills.
19:24:25 -!- cmeme has quit (Read error: 104 (Connection reset by peer)).
19:24:42 -!- cmeme has joined.
19:25:59 -!- cmeme has quit (Read error: 104 (Connection reset by peer)).
19:27:28 -!- cmeme has joined.
19:42:06 -!- Arrogant has quit ("Leaving").
20:20:05 -!- calamari has joined.
20:20:12 <calamari> hi
20:20:55 <ihope_> Ello.
20:20:56 -!- Asztal has joined.
20:22:15 <GregorR> I was thinkin' about the EsoOS ...
20:22:18 <GregorR> And filesystems ...
20:22:21 <GregorR> And Rogue ...
20:22:51 * calamari has rudimentary rendering taking place
20:24:50 <CakeProphet> GregorR,  no.
20:25:04 <pikhq> Rogue?
20:25:06 <CakeProphet> no rogue
20:25:43 * pikhq has no idea what that is
20:32:48 <Asztal> Visual studio 2005 service pack 1 destroyed my windows install :(
20:33:03 <Asztal> I can code with notepad + msbuild, I guess
20:34:31 <ihope_> Asztal: is Visual Studio a Microsoft product?
20:35:28 <GregorR> Oh come on!
20:35:33 <GregorR> A Rogue-based FS
20:35:36 <GregorR> That would rock :P
20:35:41 <ihope_> Wonderful!
20:35:51 <pikhq> GregorR: What the hell *is* Rogue?
20:35:55 <ihope_> pikhq: a game.
20:36:03 -!- oerjan has joined.
20:36:08 <ihope_> Rogue -> Hack -> NetHack.
20:36:11 <pikhq> ihope_: Very funy.
20:36:24 <pikhq> . . . Seriously? A nethack FS?
20:36:30 <ihope_> Specifically, it's a Roguelike.
20:36:30 <pikhq> WTF is wrong with you, Greg?
20:36:54 <CakeProphet> GregorR,   heh... maybe.
20:37:02 <ihope_> GregorR: didn't you say I was the only one who ever abbreviated your name that way?
20:37:05 <CakeProphet> if it had little ASCII letters that moved around.
20:37:21 <ihope_> CakeProphet: no, the letters won't be ASCII.
20:37:21 <CakeProphet> I don't think it make it terribly USEFUL or conceptually 
20:37:24 <CakeProphet> "out there"
20:37:39 <RodgerTheGreat> is the idea that you'd have to send your guy down to a specific level of the dungeon for him to find your files?
20:37:41 * pikhq imagines a filesystem set up as a series of potentially-interconnected rooms. . .
20:37:54 <ihope_> RodgerTheGreat: well, of course.
20:38:04 <ihope_> They'd be written in the dust on certain unknown levels.
20:38:15 <pikhq> It'd be so damned impossible to write out a traditional path.
20:38:19 <ihope_> So you'd really want levitation.
20:38:20 <CakeProphet> ...well... we could implement it as a second GUI... for kicks.
20:38:37 <pikhq> There'd be no actual *tree* in such an FS.
20:38:45 <ihope_> pikhq: certainly true.
20:39:00 <CakeProphet> I thought we were using a flat-ish memory layout?
20:39:18 <ihope_> Don't we want actual hardware access?
20:39:46 <ihope_> I mean really, doesn't SOAP come first? You have to have a language before you can write programs.
20:45:44 -!- oerjan has quit ("leaving").
20:46:21 -!- tgwizard has quit (Remote closed the connection).
20:50:44 -!- Asztal has quit (Read error: 104 (Connection reset by peer)).
20:51:01 <CakeProphet> hmm...
20:51:05 <CakeProphet> I think what we need..
20:51:17 <ihope_> ...is a spec for SOAP?
20:51:18 <CakeProphet> to do is lay out a universally agreed design goal.
20:51:41 <CakeProphet> We seem to be going at this kind of chaotically... without a clear-cut idea in mind. :D
20:52:06 <CakeProphet> as GregorR said before, we can't make up our damn minds.  :P
20:52:43 <CakeProphet> (on a sidenote: I have some experience in the realm of text-based game programmer... so I could help make a Rogue GUI  :D :D :D )
20:53:17 <CakeProphet> Not that it's a difficult task...
20:53:23 <CakeProphet> it's just, I can't do much ofanything else.
20:54:10 <ihope_> In SOAP, your basic classes'll be A, S, V, and D.
20:54:29 <ihope_> A, S and V will be what they are in plain old Glass.
20:55:10 <ihope_> D, when created, will look for a random device that hasn't yet been attached to an object, and then will attach that device to the new object.
20:55:34 <ihope_> Then D will have methods that somehow interact with the device.
20:55:45 <CakeProphet> Well I mean... before SOAP... we need to figure out what the hell we're doing... with everyone sharing their idea of "how it should work", and then go from there.
20:56:38 <CakeProphet> There doesn't seem to be much of a set consensus of what to do.
20:57:03 <ihope_> Working on SOAP first doesn't seem like a bad idea to me...
20:57:16 <CakeProphet> ...we know.
20:58:42 -!- oerjan has joined.
20:58:48 <ihope_> Indeed.
20:59:16 <ihope_> Well, okay then. How the OS'll work.
20:59:48 <ihope_> You know, Glass doesn't really provide any mechanism for loading code and running it. Should we add a class that does that to SOAP?
21:02:31 <CakeProphet> Basically,  we're either going to have to   A. totally redefine any esolang we come across    or    B. write a new one.
21:02:44 <CakeProphet> It's hard to compromise between high and low level.
21:02:54 <CakeProphet> and what we need right now low level.
21:04:02 <CakeProphet> something to write the kernel with... to create all of this interfacing with hardware and stuff.... and then a Glass interpreter to go on top of it.
21:13:40 * pikhq has fun playing SMB3
21:14:15 <pikhq> One person coding the whole thing has a wonderful advantage. ;)
21:17:41 <ihope_> The kernel goes on top of the platform, doesn't it?
21:18:55 <ihope_> The platform's what provides the hardware access in the first place, then the kernel is responsible for loading programs and running them.
21:42:46 <oerjan> That nonsense conversation between ihope and bsmntbombdood gives me a concept idea for an esolang.
21:45:01 <oerjan> a language in which the program _must_ look like a particular style of nonsense (unlike .gertrude where it _can_ do that, but doesn't have to.)
21:46:23 <ihope_> oerjan: wonderful!
21:47:23 <oerjan> On the other hand, making a language that is fairly grammatically correct english, may mean it is AI-complete for the compiler to determine whether it actually is nonsense.
21:49:14 <oerjan> Perhaps it could use a large dictionary organized by subjects, and then demand that your sentences mix completely different subjects.
21:50:24 <oerjan> I suppose that could be organized by having the subject of a word determine its programmatical meaning.
21:51:15 <bsmntbombdood> I be thislacket foor of my tilling have theades of litt, in timpetted mommuchin
21:52:12 <ihope_> The aesthetic value of the square root of the area of a butterfly's wing is roughly equal to that of raising a child on motor oil while building a bridge over the Pacific Ocean.
21:52:31 <bsmntbombdood> mone tato cour ving the vereffeltondescard sory do an peolooken-ble lumbecame
21:52:49 <oerjan> well, nonexistent words might work too, but they should not be completely prevalent. Besides that might require the dictionary to be enormous just to check that the programmer doesn't cheat by making sense with rare words.
21:54:00 <bsmntbombdood> diminutive wings covered with our loophole.
21:56:39 <bsmntbombdood> A door and my views rendered sufficiently near proximity; and I fell into unpleasant misrepresentations, and, in the raven-black, the brief r e-sinking into a peep at least I mean Moissart and were right, -- to his voice,  which you have I perceived that in the wire so forth.
21:57:43 <oerjan> hm, that dungeon filesystem - abstracting it would mean a filesystem organized as a mainly _undirected_ graph.
21:59:06 <CakeProphet> fuck trees.
21:59:10 <CakeProphet> fuck undirected graphs.
21:59:23 <CakeProphet> Our filesystem will be a big hole.
21:59:36 <ihope_> Just make sure all the verbs are missing the objects they need to make sence.
21:59:39 <ihope_> s/sence/sense/
21:59:46 <CakeProphet> with varying degrees of opacity.
21:59:51 <oerjan> oh, and labyrinthesse would mean: Your program can only remember a _limited_ number of exits, which are too few to get back from certain files :)
21:59:57 <CakeProphet> the further you go into the whole... the more different stuff pops up.
22:00:17 <ihope_> Or they have extra objects that don't make sense.
22:00:29 <ihope_> We drove of the router, but then he threw.
22:00:39 <oerjan> and of course there would be _some_ monsters.
22:01:09 <ihope_> Why did he do from the trees? I don't know through it.
22:01:37 <oerjan> Hm, maybe we could combine the two current subjects. A filesystem that is a dungeon of meaningless connections.
22:02:40 <ihope_> Meaningless connections?
22:03:08 <ihope_> Like the only door from the starting room leading straight into Moloch's sanctum?
22:03:14 <oerjan> To reap the philosopher's stone, first go to the bird's liquorice nest and fiddle the button of doom.
22:03:56 <oerjan> No, I mean that the actions necessary to get from one file to the other would have to be meaningless sentences like my previous one.
22:08:39 <CakeProphet> haha... so that would be the files "path" ?
22:10:31 <oerjan> Essentially.
22:28:34 -!- jix_ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:58:09 <CakeProphet> WHOOOO
22:58:15 <bsmntbombdood> OOOOHW
22:58:22 <CakeProphet> After arduous bug fixing... my programming language finally printed its first program.
22:58:45 <CakeProphet>  !m+22^)?spam?^;
22:58:52 <CakeProphet> prints 4
22:58:57 <CakeProphet> SUCCESS
22:59:00 * CakeProphet jumps around.
22:59:14 <bsmntbombdood> spam
22:59:19 <CakeProphet> yup.
22:59:32 <CakeProphet> Now I just need to get it on IRC so I can play around with it here...
23:00:06 <pikhq> Congrats.
23:00:45 <CakeProphet> Now I have to do Hello World.
23:01:05 * pikhq has a friggin' stupid way of storing directory names. . .
23:01:12 <CakeProphet> but I'm not sure it's turing complete... it doesn't really have any buiilt-in form of conditional... although there might be an interesting bypass to it.
23:01:14 <pikhq> Just have, on disk, a single root dir.
23:01:20 <pikhq> Story directorys in the pathname.
23:01:24 <pikhq> Err.
23:01:26 <pikhq> File name.
23:01:40 <CakeProphet> ....I kinda like flat, contiguous layout.
23:02:29 <pikhq> Thus, we've got a hole with directories as an additional abstraction.
23:02:46 <bsmntbombdood> psssh
23:02:53 <bsmntbombdood> an OS is just an abstraction
23:03:23 <pikhq> Your mom is just an abstraction!
23:04:28 <CakeProphet> !m?spam?"Hello World"^;   works too.  :D
23:04:32 <EgoBot> Huh?
23:08:32 <CakeProphet> ...but is it esoteric?
23:11:18 <CakeProphet> It looks pretty damn esoteric to me.
23:11:43 <CakeProphet> It's more mishmashy than any stack-based language I've seen.
23:15:30 <pikhq> Looks like it.
23:15:34 <pikhq> Can't be normal.
23:15:51 <CakeProphet> haha... it should have a quine command.
23:16:03 <CakeProphet> since the interpreter has the source code stored in it :D
23:16:19 <CakeProphet> That's cheating though  :P
23:16:35 <bsmntbombdood> write a quine in my OISC
23:16:40 <CakeProphet> pikhq,  It's a stack-of-queues based language...
23:17:10 <pikhq> Very esoteric.
23:17:19 <CakeProphet> Next up is a queue-of-stacks based language...
23:17:29 <CakeProphet> and possibly a mismatch... for swapping between the two witha command.
23:17:30 <oerjan> A quine in OISC? Wow.
23:20:50 <bsmntbombdood> oerjan: I don't have one
23:21:25 <CakeProphet> hmmm... the only problem is that boolean values are Untrue, Unfalse, and Unanything.
23:21:46 <CakeProphet> but... they just convert directly to True, False, and None in Python... so when you do an output of them... they don't come out in their glorified form.
23:22:44 <oerjan> So define classes for them.
23:22:55 <CakeProphet> yeah, that's what I was thinking...
23:23:05 <CakeProphet> but... that's a lot more work than I feel like doing.
23:23:18 <bsmntbombdood> hmm?
23:23:26 <CakeProphet> bool isn't directly subclassable... and it'll take a while to fine-tune all the specifics.
23:24:27 <oerjan> well then, write an output function instead.
23:24:39 <CakeProphet> ...oh.
23:24:42 <CakeProphet> duh.
23:24:44 <CakeProphet> :P
23:24:49 <CakeProphet> I'll just do some conditionals at the output function.
23:24:54 <bsmntbombdood> yeah, really
23:25:27 <bsmntbombdood> hmm
23:25:55 <bsmntbombdood> sometimes writing a compiler is easier than an interpreter, other times not
23:27:05 <CakeProphet> I'm assuming this one is an interpreter... I haven't -exactly- figured out the difference.
23:27:22 -!- Metuk has joined.
23:27:45 <oerjan> gah, xkcd.com is crazy today
23:27:52 <CakeProphet> It reads the entire soure code all at once... but there really isn't much compiling that needs to be done, as most of it is already single-character insructors.
23:27:54 <bsmntbombdood> CakeProphet: If it doesn't generate code, then it's an interpreter
23:28:40 <oerjan> The line _is_ blurry though.
23:28:57 <CakeProphet> In fact... all instructions are implicitly one character long unless surrounded by ?'s, quotes, or its comment (which really isn't an instruction)
23:30:15 <bsmntbombdood> oerjan: not really...what's an example where it's unclear?
23:30:43 -!- ihope has joined.
23:30:43 <oerjan> somewhere between generating an AST and generating bytecode.
23:30:46 <CakeProphet> Lots of "interpreted" languages generate bytecode.
23:31:12 <bsmntbombdood> the bytecode is interpreted
23:31:22 <CakeProphet> ....wha?
23:31:39 -!- ooooo has joined.
23:31:59 <oerjan> basically, what to you call something that compiles into a different form only to run it immediately.
23:32:06 <CakeProphet> Isn't compiled "broken down into machine-readable instructions before being ran"... while interpreted is "read line by line and performed while reading"?
23:32:10 <ihope> ooooo, shiny!
23:32:35 <oerjan> indeed, those are the extreme points.
23:32:38 <ooooo> ihope, binla!
23:33:16 <oerjan> except that very few languages are interpreted by that definition.
23:33:16 <ihope> That's "before being run", isn't it?
23:33:39 <ihope> Everything's either compiled or in between?
23:33:59 <CakeProphet> My language is definetely interpreted... there's not much compiling you could possibly do.
23:34:06 <CakeProphet> I don't even understand how you could compile BF  O.o
23:34:11 <bsmntbombdood> CakeProphet: sure there is
23:34:18 <pikhq> Easy.
23:34:27 <ihope> D'oh, I just remembered something.
23:34:28 * pikhq has written a BF compiler
23:34:36 <ihope> Pointy file systems!
23:34:38 <bsmntbombdood> compilation == translation to a different language
23:34:42 <CakeProphet> isn't compiling and interpreting in BF pretty much the exact same thing.
23:34:55 <bsmntbombdood> CakeProphet: absolutly not
23:35:15 <bsmntbombdood> A bf compiler is easier than a bf interpreter
23:35:19 <ihope> Every file has some pointers to other files. The file can only access files it has pointers to.
23:35:27 <CakeProphet> Explain the difference.
23:35:31 <oerjan> nearly every interpreter has _some_ translation stage, even if it is just to an AST.
23:35:50 <CakeProphet> Of course.
23:36:02 <CakeProphet> It would be a pain in the ass to read the raw source for some languages.
23:36:23 <ihope> CakeProphet: a compiler turns BF into something else, then runs it. An interpreter turns it into a list/tree/thing of instructions and runs through those.
23:36:34 <oerjan> actually compilers don
23:36:42 <oerjan> 't necessarily run it.
23:36:48 <ihope> Well, yeah.
23:36:54 <CakeProphet> Why would you ever change BF into something different?
23:37:03 <ihope> CakeProphet: to run it more efficiently?
23:37:05 <CakeProphet> I mean... it's single-character instructions... what more could possibly be done.
23:37:16 <pikhq> Compilers convert one language to another language.
23:37:20 <bsmntbombdood> CakeProphet: let's look at a bf -> c compiler. It only needs to preform simple textual substititution: > to "p++;", + to "(*p)++", etc.
23:37:21 <pikhq> That's it.
23:37:22 <ihope> Wouldn't you rather add 50 to a number than add 1 to it 50 times?
23:37:42 <CakeProphet> hmm....
23:38:01 <pikhq> CakeProphet: A complex BF->C compiler converts 50 "+"s into "*p+=50;".
23:38:14 <bsmntbombdood> gcc an optimizing compiler
23:38:24 <CakeProphet> so it's silly optimization stuff.
23:38:26 <bsmntbombdood> s/gcc //
23:38:30 <bsmntbombdood> CakeProphet: no
23:38:32 <ihope> Turning ++++++++++++++++++++++++++++++++++++++++++++++++++ into something more efficient is compilation.
23:38:41 * CakeProphet got it the first time ;)
23:38:48 <ihope> CakeProphet: optimization of BF is silly?
23:38:49 <pikhq> Turning ++++ into anything else is compilation.
23:38:59 <bsmntbombdood> ihope: compilation need not include optimization
23:39:16 <CakeProphet> heh... then I guess Python is compiled.
23:39:21 <CakeProphet> by that definition.
23:39:29 <ihope> Well, yes.
23:39:39 <bsmntbombdood> CakeProphet: it is compiled into bytecode, which is then interpreted
23:39:43 <ihope> It's the degree of compiledness.
23:39:47 <oerjan> another advantage of compilation is that you can run the program without having the compiler present.
23:39:51 <CakeProphet> bsmntbombdood,  ...see that's where you confuse me.
23:40:07 <CakeProphet> bsmntbombdood,  what.. are you supposed to compile the bytecode too?
23:40:11 <bsmntbombdood> hoever, python's bytecode interpreter is very complex
23:40:24 <oerjan> which can mean saving space.
23:40:33 <bsmntbombdood> CakeProphet: The byte code is never translated into a different language
23:40:48 <CakeProphet> bsmntbombdood,  The byte code -is- a different language.
23:40:59 <bsmntbombdood> yes, it is
23:41:13 <CakeProphet> Python -> bytecode    == compilation....    so how is Python not compiled?
23:41:24 <bsmntbombdood> it is compiled
23:41:32 <bsmntbombdood> but that bytecode is then interpreted
23:41:33 <pikhq> Python -> bytecode -> interpretation == interpretation. ;)
23:41:37 <ihope> I think the biggie is whether or not it's interpreted.
23:41:43 <ihope> If it's not interpreted, it's compiled.
23:41:49 <oerjan> The Haskell ghc compiler goes through a chain of up to 5 languages when compiling.
23:41:50 <CakeProphet> bsmntbombdood,  why the "but"... it makes it sound like an objection.
23:42:08 <ihope> If it's turned into an executable, it's compiled.
23:42:22 <bsmntbombdood> compilation ususaly translates into a simpler language python bytecode isn't much simpler than python itself
23:42:38 <pikhq> bsmntbombdood: It's slightly simpler to interpret, though.
23:42:46 <oerjan> Haskell -> System F -> STG machine -> C -> machine code
23:42:47 <bsmntbombdood> yes
23:42:49 <calamari> every language is interpreted
23:42:51 <CakeProphet> <bsmnthbombdood>   ihope: compilation need not include optimization
23:42:57 <pikhq> calamari: At some point, yes.
23:43:07 <calamari> so whether it is interpreted isn't a factor
23:43:42 <calamari> a compiled language is a language for which there exists a compiler to some other form
23:43:51 <bsmntbombdood> python execution goes interpret_bytecode(compile(code))
23:44:15 <ihope> calamari: isn't x86 machine code generally run directly, if it's on an x86?
23:44:28 <bsmntbombdood> ihope: A proccesor is an interpreter
23:44:32 <oerjan> it is interpreted by the hardware :)
23:44:36 <calamari> ihope: yes, but in that case, the x86 chip is the interpreter
23:44:37 * CakeProphet also notes that Python -does- make compiled versions of the source.
23:44:47 <ihope> Well, yes, then maybe whether it's interpreted by software.
23:45:02 <CakeProphet> .pyc files
23:45:13 <pikhq> ihope: You know, there are x86 software interpreters.
23:45:15 <calamari> CakeProphet: yep.. python is a compiler
23:45:17 <ihope> I guess even executable files are interpreted to some small degree.
23:45:26 <pikhq> CakeProphet: Python is also an interpreter. ;)
23:45:38 <CakeProphet> ...damn you people are confusing me.
23:45:44 <bsmntbombdood> but the interpretation part of python is much larger/more complex than the compilation stage
23:45:45 <oerjan> some processors have microcode, which is a software used by the processor to interpret the machine code in something simpler
23:45:46 <calamari> yes, python is both
23:45:51 <calamari> what's the big deal? :)
23:45:56 <CakeProphet> ...I don't know exactly...
23:45:57 <ihope> oerjan: d'oh...
23:46:03 <GregorR> How much wood ... would a woodchuck chuck ... if the wood was moss-flavored ...
23:46:13 <CakeProphet> it seems like everyone is contradicting themselves afer every other sentence.  O.o
23:46:34 <pikhq> That's because it's both.
23:46:44 <oerjan> I'm not contradicting myself, I am claiming that the line _is_ blurry.
23:47:13 <calamari> it seems pretty straightforward to me
23:47:18 <bsmntbombdood> CakeProphet: Executing pythn involves both compilation and interpretation
23:47:27 * CakeProphet nods.
23:47:31 <bsmntbombdood> (in cpython, that is)
23:47:58 <bsmntbombdood> a very simple compilation stage, and then a much more complex bytecode interpretation stage
23:48:21 <CakeProphet> Languages that have a linear interpretation are starting to grow on me :D
23:48:35 <CakeProphet> Especially when I have to write up the parser for them.  :P
23:54:38 <bsmntbombdood> any language with a eval/exec function is probably going to be classified as interpreted
23:55:35 <GregorR> OK, time for a vote.
23:55:36 <CakeProphet> exec is fairly useful.  :D
23:55:40 <GregorR> Rogue-style FS or no.
23:55:47 <pikhq> Yes.
23:55:47 * GregorR votes yae.
23:56:00 <CakeProphet> Indifferent.
23:56:02 <pikhq> bsmntbombdood: Lisp can be compiled. It's got an eval function.
23:56:19 <pikhq> To be fair, the eval function *is* a Lisp interpreter. . .
23:56:29 <bsmntbombdood> right
23:57:02 <pikhq> So, it's compiled if your code's not being (eval)ed.
23:59:23 -!- NK` has joined.
23:59:34 <NK`> Yw
23:59:37 <NK`> yaw
23:59:39 <CakeProphet> Yw
23:59:41 <GregorR> Ywhw
23:59:50 <CakeProphet> Sounds like the start of a programing language.
23:59:52 <GregorR> Wait
23:59:55 <GregorR> That's Yhwh

2007-01-02:

00:00:01 <CakeProphet> ....
00:00:08 <NK`> :)
00:00:10 <calamari> hehe
00:00:19 <NK`> !help
00:00:21 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
00:00:23 <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:00:24 <GregorR> YhwOS, the OS for the True Believer.
00:00:41 -!- ooooo has left (?).
00:01:31 <calamari> http://kidsquid.com/images/irdr-01Jan2007.jpg
00:02:08 <calamari> (that's a pic of my ipod screen)
00:02:38 <calamari> not too good at macro photography yet
00:03:54 <calamari> next step is to be able to click links :)
00:05:02 <bsmntbombdood> wifif
00:08:24 <calamari> what does "wifif" mean?
00:09:50 <CakeProphet> hmmm... stack-based languages are pretty easy to inspect...
00:10:05 <CakeProphet> since you can put in a debugging command to have the program print out its stack.
00:12:16 <bsmntbombdood> s/wifif/wifi/
00:13:14 <CakeProphet> but you could achieve the same effect in other languages.
00:13:36 <pikhq> With some difficulty.
00:13:38 <CakeProphet> Like in PYthon you can print globals() and locals() and get the program state from your perspective.
00:13:47 <bsmntbombdood> ja
00:13:49 <pikhq> Brainfuck's equivalent is printing out the entire memory.
00:13:54 * bsmntbombdood departs 
00:14:07 <CakeProphet> Or dir(object) you peek into the scope of an object.
00:14:10 * CakeProphet waves.
00:20:39 * pikhq says "Sayounara".
00:20:50 <pikhq> Anyone seen RazorX lately?
00:27:43 <oerjan> certainly, just not under that name.
00:29:01 <pikhq> What name?
00:29:59 * GregorR points at Sukoshi 
00:30:17 <pikhq> Sukoshi: Anata ga iru!
00:45:46 * bsmntbombdood hasn't seen Razor-Z long time
00:45:59 <bsmntbombdood> Razor-X
00:46:03 <bsmntbombdood> or whatever
00:52:36 -!- Asztal has joined.
00:56:56 -!- clog has joined.
00:56:56 -!- clog has joined.
00:57:27 -!- meatmanek has joined.
01:14:09 -!- fizzie has joined.
01:17:38 <Sukoshi> も����ら�pikhq.
01:17:43 <Sukoshi> bsmntbombdood: I'm Razor-X.
01:18:53 <pikhq> Sukoshi: Meaning?
01:19:02 <Sukoshi> ``Maybe''.
01:19:05 <pikhq> Ah.
01:19:06 <pikhq> ;)
01:21:57 <Sukoshi> �ら�忘れ�����������������。新年�強�生������
01:24:02 <pikhq> What's 忘 and 強 mean?
01:24:11 <Sukoshi> Your Kanji's not very strong, is it? :P
01:24:16 <pikhq> No.
01:24:32 <Sukoshi> 忘れる == ��れる, 強� == �よ�
01:24:47 <pikhq> Also, what's the reading for "new year" there?
01:24:54 <Sukoshi> �ん�ん
01:25:04 <Sukoshi> Both are pretty easy Kanji, so :P
01:25:04 <pikhq> . . . I should've known that.
01:25:23 <Sukoshi> Annoying Kanji : 風
01:25:33 * pikhq wonders what tsuyoi means
01:25:42 <Sukoshi> Strong.
01:25:44 <pikhq> Ah.
01:26:18 <pikhq> (I can't be expected to know the kanji for words I don't know. . . As for wasureru. . . Yeah, I need to know that for class. My bad.)
01:26:56 <Sukoshi> Advantages of not taking a Japanese class.
01:27:29 <pikhq> Yeah, yeah, yeah.
01:27:38 * pikhq still doesn't have an IME set up. :/
01:28:08 <Sukoshi> 大変��。
01:28:30 <pikhq> 変 means. . .?
01:28:54 <pikhq> (furigana, please)
01:29:01 <Sukoshi> �ん��� --> Strange, exchange.
01:29:10 <pikhq> Hmm.
01:29:11 <Sukoshi> Yeah. It's a Kanji which makes no sense :P
01:29:17 <Sukoshi> Here used as ���ん
01:29:20 <CakeProphet> http://deadbeefbabe.org/paste/3099    beautiful... my first esolang  (that I built an interpreter for)
01:29:26 <pikhq> Ah.
01:29:29 <Sukoshi> Look. Even the J2's in my school beat you!
01:29:40 <pikhq> I'm Japanese 3.
01:29:47 <Sukoshi> J2 == Japanese 2.
01:29:56 <CakeProphet> Now I just need to add in maybe a few more commands (I kinda like it the way it is... with minimal commands though).. and maybe something weird like a preprocessor.
01:29:56 <pikhq> (to be fair, the first two years had the world's. Stupidest. Teacher.)
01:30:07 <pikhq> He waited until second year to teach *kana*.
01:30:15 <Sukoshi> .......................................................................................................
01:30:27 <pikhq> Much less kanji.
01:30:37 <Sukoshi> Almost every piece of literature I've come across, and my own experiences, scream that you should learn as little Romaji as humanly possible.
01:30:53 <pikhq> I self-taught kana first year.
01:30:57 <pikhq> Only student to do so.
01:31:14 <Sukoshi> Ouch.
01:31:26 <Sukoshi> Kana is easy to self learn though, heh.
01:32:51 <Sukoshi> 語 is also a Kanji with a lot of readings.
01:34:34 <pikhq> "Go" is the one that comes to mind.
01:35:16 <Sukoshi> ���������.
01:35:20 <Sukoshi> Ok. Not as bad as I thought.
01:35:33 <pikhq> (if that's wrong, well, it looks kind of. . . tiny on my screen.)
01:35:36 <Sukoshi> And �� Heh.
01:42:26 <bsmntbombdood> oooh Sukoshi 
01:46:07 <CakeProphet> hmmm... there's no conditional jumps in Stew though...
01:46:16 <CakeProphet> unless you can create one from the minimal tools given.
02:15:46 <oerjan> One thing I suspect is that the booleans are entirely useless for computation - you cannot do anything with them other than comparing, giving you just a new boolean.
02:17:36 <oerjan> However, it seems to me that numbers can be used to select an operator from a stack, which can then be run, giving you conditional execution.
02:20:55 <CakeProphet> hmmm... ooh yeah :D
02:21:01 <CakeProphet> I didn't think about that.
02:21:11 <CakeProphet> the @ command with some comparison operations.
02:21:42 <CakeProphet> 0 would give the current queue... 1 would give the second Queue
02:22:30 <CakeProphet> Neat.
02:22:33 <CakeProphet> That works out nicely too.
02:22:52 * CakeProphet loves it when an unintentional feature arises.
02:23:22 <CakeProphet> I also need a string-to-int int-to-string builtin.
02:23:33 -!- Asztal has quit (Read error: 113 (No route to host)).
02:23:45 <CakeProphet> maybe just call it "flip"... strings becomes ints (if possible)... ints become strings.
02:24:00 -!- Asztal has joined.
02:25:26 <CakeProphet> division and mod could easily be used as conditionals.
02:27:06 <CakeProphet> well... divsion plus floor  (Python divison will be "true" division by default in later releases... but you can go ahead and specify it now using the __future__ module)
02:27:21 <CakeProphet> so uneven division will return floats.
02:28:33 <oerjan> it is also a well-known fact that 1-x and x*y with 0/1 gives you boolean not and and
02:30:26 <oerjan> you can get integer division by combining true division with mod
02:30:32 <CakeProphet> Yeah.
02:30:45 <CakeProphet> or floor.
02:31:15 <oerjan> ah yes, you have all three.
02:31:34 <CakeProphet> I might get rid of the lolno function then
02:31:56 <oerjan> isn't that negation on numbers?
02:32:07 <CakeProphet> no... right now it's boolean not
02:32:09 <CakeProphet> but..
02:32:12 <CakeProphet> since I'm removing booleans
02:32:42 <CakeProphet> True converts to 1... False and None to 0
02:32:45 <CakeProphet> should they ever pop up
02:33:23 <CakeProphet> so boolean not would work... we just don't need it.
02:33:33 <CakeProphet> I want to strip out everything :D
02:33:40 <CakeProphet> that can be done otherwise.
02:33:49 <CakeProphet> in a more unconvential way.
02:35:03 <CakeProphet> Except random  :D
02:35:13 <CakeProphet> I don't want to fool with building a random number generator myself.
02:36:01 <oerjan> although that _is_ considered one of the canonical programs for a new esoteric language. :)
02:36:25 <CakeProphet> well... it's not a full blown random generator.
02:36:37 <CakeProphet> It just allows randit from 1 to a given int
02:37:08 <CakeProphet> and if the value on the queue isn't an integer... it does the from-zero-to-one-float-random-thing  (forogot the name of it)
02:38:15 <CakeProphet> floor can also be sumulated with   round(x - 0.5)
02:38:21 <oerjan> sounds about as much as you can expect without a full-blown library of statistical distributions.
02:38:54 <CakeProphet> I could put a shitload of the standardlb into the specification... if I wanted.
02:38:56 <oerjan> and everything else can be constructed from those two cases.
02:39:22 <CakeProphet> sockets, file IO, etc
02:39:50 <CakeProphet> which I might do as an "extended stew"... for OS related juju
02:41:06 <CakeProphet> hmm.. oh I need to add greater than and less than.
02:41:23 <CakeProphet> greaterthan-and-equal-to is just a superset of multiple operations.
02:43:21 <oerjan> i thought you said you could use div and floor.
02:43:55 <CakeProphet> I could?
02:44:26 * CakeProphet doesn't know how to do gt and lt any other way.
02:44:33 <CakeProphet> than by simply having them present :D
02:45:28 <Sukoshi> The INTERCAL stdlib has random number generation in it.
02:45:54 <CakeProphet> I like the way the syntax oscilates from postfix to prefix 
02:46:03 <CakeProphet> it's really bizzare.
02:47:50 <CakeProphet> I have the urge to add a little hack to do in-line Python....
02:47:54 <CakeProphet> :D
02:49:06 <Sukoshi> You need to try out other languages.
02:49:32 <CakeProphet> Yeah.
02:49:40 <CakeProphet> I can do some schemish stuff... nothing huge though.
02:49:44 <CakeProphet> I attempted C but got bored.
02:49:46 <oerjan> let's say you have a non-zero integer and you want to test if it is positive or negative.
02:49:47 <CakeProphet> Perl looks interesting.
02:49:53 <oerjan> look at floor (1/x)
02:50:13 <Sukoshi> Write an infix->prefix translator in Scheme.
02:50:27 <CakeProphet> >.>
02:50:56 <oerjan> actually, floor (1/(2*x))
02:50:57 <CakeProphet> I can do Glass fairly well... out of all the esolangs it's the one I'm most proficient at.
02:51:25 <oerjan> on second thought, zero is not a problem either.
02:51:35 <CakeProphet> I can read most of C... I still need to learn what structs are :D
02:51:38 <oerjan> floor (1/(2*x-1))
02:51:45 <CakeProphet> don't really want to code it though.
02:52:11 <oerjan> eh, wait
02:52:17 <CakeProphet> I can do FORTH... never actually used it... but the syntax is so simple how can you -not- use FORTH?
02:52:33 <CakeProphet> -1 would give you a division by zero
02:52:47 <CakeProphet> er... 1
02:52:52 -!- Asztal has quit (Read error: 104 (Connection reset by peer)).
02:53:06 <oerjan> nope.
02:53:10 -!- digital_5e has joined.
02:53:20 <oerjan> but it isn't quite there yet.
02:53:22 <CakeProphet> oh yeah... anything multiplied  by zero is one
02:53:28 <CakeProphet> duh, stupid math
02:53:54 <oerjan> floor (1/(4*x-2))
02:54:20 <CakeProphet> eh... I think I'll just use builtins for comparison  :P
02:54:31 <oerjan> that should have only two possible values, -1 and 0.
02:55:12 <CakeProphet> I guess it wouldn't be too hard to implement in Stew... since it's functional, I can abstract.
02:55:30 <CakeProphet> more properly... it's "procedural"  (everything is on a global stew)
02:55:45 <oerjan> so -floor (1/(4*x-2)) == (x<=0)
02:56:29 <CakeProphet> new builtins.
02:57:01 <oerjan> for floats you would take floor before doing this, giving (x<1)
02:57:02 <CakeProphet> CHORD (yes, all caps... it felt like the thing to do)   switches integers to ASCII... and ASCII to integers.
02:57:23 <CakeProphet> FLIP changes ints to strings, and strings to ints.
02:57:30 <CakeProphet> er... flip
02:57:32 <CakeProphet> lower case
02:58:05 <oerjan> so a CHORD is not a string? :)
02:59:34 <CakeProphet> hehe...
02:59:42 <CakeProphet> it's a combination of chr and ord
03:00:01 <CakeProphet> which are the functions that do the underlying magic.
03:00:25 <CakeProphet> CHORD was something that would have been waaay too tedious to implement in Stew.
03:00:36 <CakeProphet> and flip was just impossible
03:01:54 <CakeProphet> I suppose you could build a BF interpreter in Stew.
03:02:02 <ihope> Yum, Stew.
03:02:22 <CakeProphet> just have a queue representing each possible symbol... and do a bunch of conditional rotations via comparisons.
03:02:35 <CakeProphet> then call the function at the top que.
03:02:38 <CakeProphet> queue
03:02:58 <CakeProphet> except... there's always that pesky while loop.
03:05:53 <oerjan> just make sure that the op for the while loop places itself back in the queue
03:06:26 <oerjan> oh, you mean the bf loop
03:06:31 <CakeProphet> yeah
03:06:37 <CakeProphet> Stew doesn't have whiles.
03:06:49 <bsmntbombdood> [] is hard to implement
03:06:50 <ihope> Trying to prove Stew Turing-complete?
03:07:00 <CakeProphet> Nah...
03:07:12 <CakeProphet> just wondering -if- it could do a BF interpreter.
03:07:15 <oerjan> can a stack contain stack elements?
03:07:15 <CakeProphet> so... I guess so :P
03:07:21 <CakeProphet> Nope.
03:07:31 <CakeProphet> Just a single of stack of queues.
03:07:41 <CakeProphet> all data is in the queues... and all the queues are in the stack.
03:07:45 <CakeProphet> it's a little weird to get used to  :D
03:07:57 <oerjan> so no queues in the queues either.
03:08:12 * bsmntbombdood eats Cake(Prophet)
03:08:12 <CakeProphet> No unless you can find a bug that lets you do so.
03:08:15 <CakeProphet> which is highly likely.
03:09:08 <CakeProphet> If you push all the values from the top queue... it's removed and the one below it takes its place... if that paticular quirk helps an.
03:09:10 <CakeProphet> y
03:09:47 <RodgerTheGreat> back
03:10:02 <CakeProphet> the only loop construct in Stew (at the moment) is a function mapper()
03:10:09 <CakeProphet> which... I haven't tested yet.
03:10:11 <oerjan> is there a way to get to queues other than the top one?
03:10:36 <CakeProphet> Yeah.
03:10:47 <oerjan> how?
03:11:22 -!- digital_5e has quit (Connection timed out).
03:11:24 <CakeProphet> @ takes the topmost  int from the top-most queue as a stack looker-backer.
03:11:27 <CakeProphet> like DUP in Forth.
03:11:40 <CakeProphet> pushes an old queue back to the top.
03:11:54 <CakeProphet> it's how you would do conditionals in Stew.
03:12:24 <CakeProphet> give it a comparison... it returns either 1 or 0... and use that to conditionally flip between the top two queues.
03:13:34 <oerjan> is there a way to swap or rotate the top queues?
03:13:36 -!- ihope_ has quit ("Leaving").
03:13:39 <CakeProphet> and I'm guessing... if you used negative integers it would get the bottom most queue... since I didn't really specify any sort of check for that thing... and that's how Python would do it.
03:13:49 <CakeProphet> Like I just said  :P
03:13:55 <oerjan> aha!
03:13:59 <CakeProphet> Use comparisons in combination with @
03:14:10 <oerjan> that means you can use the bottom queues for globals!
03:14:29 <CakeProphet> An order list of globals  :/
03:14:33 <CakeProphet> ordered
03:14:40 <bsmntbombdood> facny
03:14:44 <bsmntbombdood> *fancy
03:15:43 <CakeProphet> % is the foreach operator... it calls a function for each item in the top queue (using some fancy voodoo to make sure that each item is at the front of the queue at some point.
03:16:25 <oerjan> can you use % to delete the topmost queue?
03:16:59 <CakeProphet> hmmm... don't think you could...
03:17:19 <CakeProphet> well... if your function didn't put anything in the queue.
03:17:39 <CakeProphet> I'd need to tweak the interpreter a bit to parse an empty function though  :D
03:17:47 <CakeProphet> it would take all of two seconds.
03:18:02 <oerjan> OneOrMore -> ZeroOrMore ? :)
03:18:18 <CakeProphet> yup
03:18:20 <CakeProphet> just did it.
03:18:22 <bsmntbombdood> abacus
03:18:25 <bsmntbombdood> oops
03:20:56 <CakeProphet> The queue-based counterpart to @ is .
03:20:59 <oerjan> let's say you made each BF loop into a queue.
03:21:14 <CakeProphet> you can get a specific element from the topmost queue as well.
03:21:28 <CakeProphet> allowing for inter-queue conditionals  :D
03:21:33 <oerjan> placing it in a specific position from the bottom.
03:21:34 * CakeProphet forgot about .
03:22:16 <CakeProphet> (by the way "stew" is the phonetical squashing of stack and queue)
03:22:40 <bsmntbombdood> s/stew/stueue/
03:22:48 <CakeProphet> that looks silly.
03:22:51 <CakeProphet> stew is much better :D
03:22:57 <bsmntbombdood> that's the point
03:23:09 * CakeProphet likes stew better for some reason.
03:23:54 <oerjan> although stue is norwegian for living-room
03:24:10 <CakeProphet> I can't imagine stew being very efficient... pretty much any operation on it involves messing with a two-dimensional array.
03:24:13 <oerjan> or a cottage
03:24:22 <CakeProphet> stue might work nicely :D
03:24:40 <CakeProphet> it has the -ue end of queue
03:24:47 <CakeProphet> and the st- beginning of stack.
03:25:08 <oerjan> what about quack?
03:25:15 <CakeProphet> hahahaha
03:25:24 <CakeProphet> stue quack?
03:25:29 <CakeProphet> quack stue?
03:25:41 <CakeProphet> I like quack stue  :D
03:25:42 <oerjan> or maybe just quack.
03:25:54 * bsmntbombdood likes
03:25:54 <CakeProphet> ...
03:26:11 <CakeProphet> meh... now I can't decide on a name.
03:26:14 <CakeProphet> so many good choices.
03:27:40 <CakeProphet> eh... for now I'll just call it stew
03:27:45 <CakeProphet> for reference purposes :D
03:28:30 <CakeProphet> hmm... wait
03:28:36 <CakeProphet> It'll be hard to get foreach to work properly.
03:28:57 <oerjan> why?
03:29:02 <CakeProphet> As functions that call will eat up their arguments and return new ones... which go on a fancy result list to the side.
03:29:15 <CakeProphet> it would be difficult to make it implicitly "eat up" values...
03:29:26 <CakeProphet> unless you just like... outputed them.
03:29:47 <CakeProphet> that's one of the few functions that eat up values and don't spit anything back.
03:29:53 <oerjan> is there a way to simply remove a value?
03:30:04 <oerjan> ah.
03:30:13 <CakeProphet> You could make it an instrinsic property of foreach... but then it would eat -too- many.
03:30:22 <CakeProphet> there's currently not a pop...
03:30:25 <CakeProphet> :D
03:30:57 <CakeProphet> pops just sorta happen as the low level commands and functions start consuming values... 
03:31:42 * CakeProphet -could- add a delete command...
03:31:44 <CakeProphet> it would be nice.
03:32:53 <CakeProphet> better yet... make it a builtin... so you can foreach it :D
03:33:35 <CakeProphet> builtin functions have the advanage of being treated as data... commands have the advantage of you-don't-need-to-explicitly-call-them-they-just-happen.
03:37:56 -!- Metuk has quit (Read error: 110 (Connection timed out)).
03:39:30 <oerjan> eh, why is Stew.q not being initialized?
03:40:32 <CakeProphet> it doesn't exist anymore :D
03:40:43 <CakeProphet> It was causing problems with referencing.
03:41:08 <CakeProphet> Now it just slices from the stack each operation... which is... kind of dirty... but eh.
03:41:18 <oerjan> so the pastebin is not accurate? (http://deadbeefbabe.org/paste/3099)
03:41:22 <CakeProphet> Nope.
03:41:43 <CakeProphet> as soon as I make a little tweak, I'll post up the latest.
03:44:12 <CakeProphet> a minor tweak in how Stew does symbols allows the interpreter to call any arbitrary string as though it were an op. :D
03:44:29 <CakeProphet> ( op  is the "official" term for a procedure in the Stew lingo...)
03:44:33 <CakeProphet> OFFICIAL
03:44:37 <CakeProphet> ADHERE TO IT
03:50:26 <oerjan> NEVER
03:50:43 <oerjan> WE WILL CALL IT A "DUWN"
03:51:36 <RodgerTheGreat> alright, I think I have a functioning def-bf interpreter...
03:51:52 <RodgerTheGreat> would anyone like to help me make some test programs?
03:52:11 <bsmntbombdood> +[>+]
03:52:22 <CakeProphet> hehe... got my own interpreter testing to do  :P
03:52:50 <pikhq> RodgerTheGreat: Test any normal Brainfuck code.
03:52:56 <pikhq> If that fails, j00 fail.
03:53:01 <RodgerTheGreat> pikhq: already did that
03:53:06 <RodgerTheGreat> works like a champ
03:53:08 <pikhq> Mmkay.
03:53:15 <bsmntbombdood> +[<+]
03:53:17 <pikhq> Hmm. . .
03:53:29 <pikhq> Not sure what to do.
03:53:40 * bsmntbombdood dies and goes to bed
03:53:52 <CakeProphet> oerjan,  oh... and functions have the nifty ability to be constants  :D
03:54:03 <RodgerTheGreat> and I'm working on testing pointer control...
03:54:04 <CakeProphet> since they just push values to the stack... you can use them as constants to values.
03:54:18 <RodgerTheGreat> program counter control is going to be tricky to test...
03:54:21 <CakeProphet> I mean... ops]
03:54:23 <CakeProphet> :D
03:54:27 <pikhq> Yeah. . .
03:56:41 <RodgerTheGreat> alright, # pushes pointer location, and ; pops it.
03:56:59 <RodgerTheGreat> so if my program is >>,<++#.,;[->.<]
03:57:23 <RodgerTheGreat> with an input of "ab"
03:57:34 <RodgerTheGreat> I should get an output of "abb", right?
04:00:52 <oerjan> ah!
04:01:11 <oerjan> you can create a constant function
04:01:25 <oerjan> just use eq to start with
04:01:41 <oerjan> eh, i mean, op :)
04:02:12 <CakeProphet> :P
04:02:22 <CakeProphet> the OP needs to be called though.
04:02:34 <CakeProphet> and... currently my interpreter is printing ouit strange results.
04:02:45 <CakeProphet> ...I messed it up again.  :P
04:03:11 <oerjan> what i mean is, you can use it with foreach to turn every element of a queue into the same value.
04:03:57 <CakeProphet> ...aaaah
04:04:33 <RodgerTheGreat> pikhq: er... did I code that right?
04:04:58 <CakeProphet> hehe... using esoteric languages is the fine art of misusing every bit of the languages features.
04:07:29 <oerjan> eh, is recursion the only way to do a loop in Stew?
04:07:50 <oerjan> because it might be hard on the Python stack.
04:08:21 <CakeProphet> as far as I can tell.
04:08:41 <CakeProphet> indefinite loops anyways
04:08:45 <pikhq> Um. . .
04:08:50 <CakeProphet> there's iterations.
04:08:55 <pikhq> Maybe?
04:09:28 <RodgerTheGreat> well, shit- I'm getting stack underflows. It's either a faulty program or my interpreter
04:09:38 -!- Sukoshi has left (?).
04:09:44 -!- Sukoshi has joined.
04:10:21 <CakeProphet> my interpreter keeps printing the stack with no apparent reason to do so.
04:10:29 <CakeProphet> I've searched the whole program for a reason why.
04:10:45 <RodgerTheGreat> hi, Sukoshi 
04:10:47 <oerjan> you might want to adjust run to do proper tail call optimization.
04:10:52 <Sukoshi> Hey.
04:11:18 <RodgerTheGreat> I'm working on getting a functioning Def-BF interpreter going
04:11:21 <CakeProphet> oerjan,  run doesn't do function calls.
04:11:23 <oerjan> so that recursion can be safely used for loops.
04:12:05 <CakeProphet> oerjan,  it retrieves the functions as data... the call is from the ^ command... which calls the call() method... which calls the __call__ method of an Op object :D
04:12:30 <CakeProphet> which might be unnesiary.
04:12:50 <CakeProphet> I could easily reduce it to a call to run()
04:21:05 <CakeProphet> alright...
04:21:15 <CakeProphet> fixed some stuff... but it still prints out the stack a bunch..
04:23:35 <CakeProphet> hmmm... to make it do optimization for tail recursion you simply return the call right?
04:24:00 <CakeProphet> that ensures that Python no longer has to keep track of the functions local state.
04:24:48 * pikhq discovers that SMB3 kicks ass with a game genie. . .
04:25:01 <pikhq> Hammer Mario. All. Day. Long.
04:25:03 <pikhq> :)
04:26:08 <oerjan> or you turn the call into iteration.
04:27:43 <Sukoshi> RodgerTheGreat: Has someone finished the spec?
04:28:07 <RodgerTheGreat> I wrote the original spec, and the low-level portion is complete.
04:28:20 <Sukoshi> Link me up, Rodger.
04:28:27 <oerjan> if you check in run whether the last command in the list is ^, and then whether its argument is an op, then you can shortcut and use the same invocation of run to do it.
04:28:53 <RodgerTheGreat> The only change I made to what you've seen before is that I replaced the @ symbol with %, to free up @ as a reserved "word". One moment...
04:29:29 <RodgerTheGreat> http://nonlogic.org/dump/text/1167711731.html
04:30:06 <RodgerTheGreat> I'm implementing the low-level spec outlined in "Basic Commands"
04:30:28 <RodgerTheGreat> Currently, I've left out ? just to save myself some minor headaches
04:31:00 <Sukoshi> So, the low-level commands perform definite jumps?
04:31:06 <RodgerTheGreat> yes
04:31:26 <Sukoshi> Like +++++%. should output what?
04:31:35 <RodgerTheGreat> %: control the program counter, and #; control the pointer
04:32:14 <RodgerTheGreat> I think that ought to output CHR$(5)
04:32:42 <Sukoshi> But doesen't % jump to location 5?
04:32:51 <RodgerTheGreat> wait, no- that would infinite loop
04:32:53 <RodgerTheGreat> yes
04:32:57 <RodgerTheGreat> zero-indexed
04:33:26 <Sukoshi> Hooray. Def-BF -- More ways to infinite loop.
04:33:32 <RodgerTheGreat> yeah...
04:34:04 <RodgerTheGreat> anyway...
04:34:11 * RodgerTheGreat snaps his fingers
04:34:13 -!- BrainMachine has joined.
04:34:22 <RodgerTheGreat> bfmode
04:34:22 <BrainMachine> execution mode is currently: defbf
04:34:29 <Sukoshi> What about +++++#, inputs 'a' .
04:34:46 <Sukoshi> BrainMachine: +++++#,
04:34:49 <RodgerTheGreat> that would store a in location 5
04:34:55 <RodgerTheGreat> the syntax is
04:35:01 <RodgerTheGreat> bfprog +++++#
04:35:03 <RodgerTheGreat> er
04:35:07 <RodgerTheGreat> bfprog +++++#,
04:35:12 <RodgerTheGreat> bfinput a
04:35:13 <RodgerTheGreat> bfrun
04:35:29 <RodgerTheGreat> and that's pretty much that
04:35:44 <Sukoshi> bfprog +++++#,.
04:35:46 <Sukoshi> bfinput a
04:35:48 <Sukoshi> bfrun
04:35:48 <BrainMachine> a
04:35:52 <Sukoshi> Yay.
04:36:22 -!- oerjan has quit ("Good night.").
04:36:22 <RodgerTheGreat> bfprog +++++>>>>,<<<<#.
04:36:24 <RodgerTheGreat> bfrun
04:36:39 <RodgerTheGreat> whoops
04:36:43 <Sukoshi> Heh.
04:36:44 <RodgerTheGreat> bfprog +++++>>>>,<<<<#<.
04:36:46 <RodgerTheGreat> bfrun
04:36:46 <BrainMachine> a
04:36:54 <RodgerTheGreat> so, that aspect works
04:37:26 -!- calamari has quit ("Leaving").
04:37:26 <Sukoshi> Man. I wish I could play some more with this.
04:37:29 <pikhq> bfprog +++++#,<+++++;.
04:37:33 <pikhq> bfinput a
04:37:34 <pikhq> bfrun
04:37:35 <BrainMachine>  Pointer stack underflow error. Amazing.
04:37:36 <Sukoshi> But, I must finish my homework.
04:37:36 <BrainMachine> 
04:37:45 <RodgerTheGreat> lol
04:38:01 <Sukoshi> Why does it spit out some erroneous character at the end?
04:38:08 <pikhq> bfprog +++++#,<<<<<[-]>>>>>.
04:38:11 <pikhq> bfinput a
04:38:15 <pikhq> bfrun
04:38:15 <BrainMachine> a
04:38:24 <pikhq> Whoo.
04:38:35 <RodgerTheGreat> Sukoshi: oh, that's a bug/feature of the way error messages work
04:39:03 <RodgerTheGreat> it just adds a "\nError Message\n" to the output stream
04:39:29 <Sukoshi> Aha.
04:39:33 <Sukoshi> Anywho, homework time.
04:39:38 <RodgerTheGreat> cya
04:39:43 <Sukoshi> I might come up with my own interpreter tonight too.
04:39:47 <RodgerTheGreat> sweet
04:39:51 <RodgerTheGreat> the more the merrier
04:40:20 <Sukoshi> Oh, how does ? work, by the way?
04:40:44 <RodgerTheGreat> once I can get this interpreter firing on all cylinders, I'll start working on the High-Spec->Low-Spec compiler
04:41:21 <RodgerTheGreat> Sukoshi: the plan is for it to read the next n characters as long as they're numbers. Inelegant, but it works
04:41:58 <Sukoshi> How'll you tell that they're numbers? Do an ASCII bound check?
04:42:06 <RodgerTheGreat> yeah
04:42:14 <Sukoshi> Aha.
04:42:36 <RodgerTheGreat> or, since it's Java, I can repeatedly try Integer.parseInt()
04:42:49 <RodgerTheGreat> I'm not really sure which would be easier
04:42:59 <Sukoshi> Well, in the all cylinders world, there's nothing that fancy.
04:42:59 <RodgerTheGreat> it'll end up being ugly code, I know it
04:44:49 <RodgerTheGreat> if you can think of a better way for ? to work, by all means let me know
04:45:28 <RodgerTheGreat> I was thinking about having it just read in the next ascii char, but that limits values to 8-bit, and makes it hard to use interactive interpreter
04:45:29 <RodgerTheGreat> s
04:48:26 * pikhq jumps off of cliffs in SMB3, singing "Suicide is painless, it brings on many changes, I can take or leave it if I please."
04:48:58 <RodgerTheGreat> the philosophical side of nintendo.
04:49:09 <GregorR> http://www.codu.org/Kill_Yourself.org
04:49:10 <GregorR> Erm
04:49:13 <GregorR> http://www.codu.org/Kill_Yourself.ogg
04:49:13 <pikhq> Actually, it's the song from MASH.
04:49:18 <pikhq> GregorR: I've got it.
04:49:32 <pikhq> http://en.wikipedia.org/wiki/Suicide_Is_Painless
04:49:42 <GregorR> Uh, different song ...
04:49:53 <pikhq> I've got the Kill Yourself song.
04:49:57 <GregorR> Ah, OK :P
04:50:24 <pikhq> "Take out your favorite limb, take out your favorite eye, it doesn't matter how so long as you die!"
04:50:49 <pikhq> RodgerTheGreat: I'm doing Mash *and* Nintendo.
04:51:15 <RodgerTheGreat> lmao: http://en.wikipedia.org/wiki/List_of_songs_about_suicide
04:52:46 <GregorR> I should add my Kill Yourself song to that 8-D
04:53:23 <RodgerTheGreat> wtf? "Strawberry Fields Forever" isn't on the list.
04:58:30 <RodgerTheGreat> "Let me take you down/'cause I'm going to/Strawberry fields-/nothing is real/-and nothing to get hung about/"
05:03:53 <pikhq> Don't use Wikipedia to gain relevance.
05:05:37 <RodgerTheGreat> ?
05:15:20 -!- anonfunc has quit.
05:16:48 -!- anonfunc has joined.
05:32:39 <RodgerTheGreat> good night, everyone
05:32:50 -!- RodgerTheGreat has quit.
05:32:55 -!- BrainMachine has quit (Remote closed the connection).
06:39:51 <Sukoshi> I ... eat ... babies.
06:48:01 <GregorR> High-five!
06:48:29 <GregorR> http://www.donotputthebaby.com/index.php?s=Mouth
07:56:22 * pikhq would like to salute the RIAA for their claims on a) the rampancy of piracy b) the cost of each song
07:57:58 <pikhq> They have recently valued a single song to be worth $150,000. . .
07:59:05 <Sukoshi> Well, if each person is worth $1,000,000 then their songs must be some fraction of them, no?
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:00:34 <pikhq> Let's estimate that maybe 20% of the US population (6,000,000 people here) pirate songs.
08:01:00 <pikhq> Let's say each of these downloads, say, 3 albums of 12 songs a year.
08:01:23 <pikhq> 2,160,000,000 songs.
08:01:32 <pikhq> This is, obviously, a low estimate.
08:02:13 <pikhq> Now, with each worth $150,000, we get $324,000,000,000,000 worth of songs pirated.
08:02:16 <Sukoshi> I'd say 40%.
08:02:30 <pikhq> 324 trillion dollars.
08:02:56 <Sukoshi> That's more than the entire GDP of France.
08:03:10 <pikhq> For comparision, the USA GDP is $12.485 trillion dollars.
08:03:22 <Sukoshi> :
08:03:23 <Sukoshi> P
08:05:17 <pikhq> Wow.
08:05:28 <pikhq> That's an order of magnitude larger than the world's GDP.
08:06:00 <pikhq> $44,454,843,000,000 dollars.
08:06:06 <pikhq> 44 trillion dollars.
08:06:08 <pikhq> Dear god.
08:10:01 <pikhq> Shift my calculations by an order of magnitude.
08:10:51 <pikhq> 60,000,000, people, 21,600,000,000 songs, $3,240,000,000,000,000 songs pirated.
08:15:06 <Sukoshi> Well, in the RIAA's heart, that's how much is being pirated.
08:15:41 <pikhq> Only in the US.
08:16:04 <pikhq> Applying this to global scale gets us having lost every year the amount of value produced since the dawn of mankind.
08:16:20 <pikhq> (just guessing on that, but hey. Sounds about right.)
08:20:49 <pikhq> In conclusion: balding men with more cash than sense should not be allowed to talk about money at all.
08:21:07 <Sukoshi> In conclusion: We should sue the RIAA.
08:22:18 <pikhq> In conclusion: We should just let the RIAA's recent decision to sue a front company for the Russian mafia take its course.
08:22:25 <pikhq> I'm buying the popcorn. ;)
08:22:34 <Sukoshi> Ah. Russia.
08:22:53 <pikhq> They decided to sue AllOfMP3.
08:22:54 <Sukoshi> The We're-still-totalitarian-you-bums nation.
08:23:02 * Sukoshi laughs.
08:23:13 <pikhq> For. . . More than the GDP of Russia.
08:23:24 <Sukoshi> Hahahahahahaha.
08:23:42 <pikhq> Since AllOfMP3 has mafia ties, this should be rather amusing.
08:23:52 <Sukoshi> Yeah, if that happened, AllOfMP3 would own Russia by now and they'd have their own corporate army and their own figurehead President.
08:24:35 <pikhq> s/AllOfMP3/RIAA/ s/Russia/America/
08:24:38 <pikhq> Creepy.
08:24:45 <Sukoshi> Yup.
08:25:05 <pikhq> It's RIAA vs. EquallyHugeGiant.
08:25:37 <pikhq> (I've also heard rumors of the RIAA having American mafia ties. . . This gets more and more amusing.)
08:25:46 <Sukoshi> This 'aint exactly ripe fields for Socialism in the world now.
10:01:40 -!- jix_ has joined.
11:43:17 -!- tgwizard has joined.
11:49:05 -!- Asztal has joined.
12:19:24 -!- oklopol has joined.
12:32:01 -!- jix__ has joined.
12:33:20 -!- oerjan has joined.
12:40:29 -!- jix_ has quit (Read error: 113 (No route to host)).
14:33:38 -!- Asztal has quit (Read error: 113 (No route to host)).
14:46:32 -!- anonfunc has quit.
14:57:11 -!- Sph1nx has joined.
15:11:01 -!- ihope_ has joined.
15:12:33 -!- Sph1nx has quit ("äÏ Ó×ÉÄÁÎÉÑ ×ÓÅÍ!").
15:28:49 -!- ihope has quit (Read error: 110 (Connection timed out)).
15:35:43 -!- oerjan has quit ("leaving").
16:23:47 -!- RodgerTheGreat has joined.
16:23:58 <RodgerTheGreat> hi
16:28:23 -!- RodgerTheGreat_ has joined.
16:28:23 -!- RodgerTheGreat has quit (Read error: 104 (Connection reset by peer)).
16:31:18 -!- RodgerTheGreat_ has changed nick to RodgerTheGreat.
18:09:31 -!- oerjan has joined.
18:43:54 <oerjan> hey, lambdabot@#haskell also has a BF interpreter
18:51:38 <oklopol> not that shocking since a bf interpreter takes 15 minutes to write
18:52:09 <oerjan> yeah
19:04:14 -!- RodgerTheGreat has quit (Read error: 104 (Connection reset by peer)).
19:04:25 -!- RodgerTheGreat has joined.
20:21:16 -!- Asztal has joined.
20:24:48 -!- Asztal has quit (Client Quit).
21:50:46 <bsmntbombdood> using minimal evaluation with boolean and/or makes for nice looking code
21:51:28 <RodgerTheGreat> you mean making use of logical short-circuiting?
21:52:18 <bsmntbombdood> char *editor = getenv("VISUAL") || getenv("EDITOR") || (command_exists_p("emacs") && "emacs") || "vi";
21:53:05 <GregorR> Yes, making use of logical short-circuiting :P
21:54:05 <oerjan> actually it is not essential in that example.
21:54:50 <GregorR> True ... but it would be fairly inefficient without :P
21:56:03 <bsmntbombdood> void *p=malloc(x) || exit(1)
21:57:19 <pikhq> That *works*. . . But I'd rather not use such a thing.
21:57:23 <pikhq> void *p;
21:57:26 <pikhq> Err.
21:57:32 <pikhq> void *p=malloc(x);
21:57:43 <pikhq> if(!p) exit(1);
21:57:49 <pikhq> Seems a bit clearer to me.
21:57:56 <bsmntbombdood> conciseness is good
21:58:28 <pikhq> Clarity is worthwhile, IMO.
21:58:52 <oerjan> some languages call that operator 'orelse'.
21:59:12 <oerjan> which is pretty clear.
21:59:30 <RodgerTheGreat> I like the idea of making threats to your compiler
21:59:49 <oerjan> and (...) or die(1); is idiomatic perl. 
21:59:50 <RodgerTheGreat> it'd be like the opposite of INTERCAL
22:00:37 <bsmntbombdood> oerjan: is that good or bad?
22:00:40 <oerjan> hm, that probably should be die("..."). my perl is getting rusty.
22:02:10 * GregorR hates perl's proponderance of silly conditional keywords.
22:02:11 <oerjan> it's good. perfectly clear, too.
22:02:28 <GregorR> Also, I hate this:   do something if (x);  instead of if (x) do something;
22:02:45 <GregorR> And 'unless', I hate that too.
22:02:53 <GregorR> Really, I just hate Perl.l
22:03:16 <pikhq> I hate executable line noise.
22:03:24 <oerjan> and here i was going to mention that Haskell has when and unless in the Control.Monad module.
22:03:25 <bsmntbombdood> python > perl
22:03:36 <oerjan> prefixed though, being functions.
22:03:40 <GregorR> Brainfuck > Python
22:03:54 <bsmntbombdood> GregorR: that is nice sometimes
22:03:57 <bsmntbombdood> closer to english
22:04:07 <GregorR> Closer to English != nice
22:04:29 <oerjan> Malbolge > Brainfuck :)
22:05:49 <oerjan> but what is perl > ?
22:06:02 <GregorR> A pile of horse dung?
22:06:08 <GregorR> Mind you, that's only in terms of programming.
22:06:10 <oerjan> maybe COBOL.
22:06:13 <GregorR> In general, the horse dung is more useful.
22:07:22 <oerjan> darn, has someone made a BF interpreter in COBOL yet?
22:07:36 <pikhq> oerjan: Undoubtedly.
22:07:44 <GregorR> I made one in ORK, that's like COBOL++ :)
22:07:50 <pikhq> :)
22:07:53 <bsmntbombdood> I still need to do BF in my OISC
22:08:07 <pikhq> Actually, it's ADD 1 TO COBOL GIVING COBOL.
22:08:22 <GregorR> pikhq: Sooo much typing ;)
22:08:31 <GregorR> When you say OISC, are you referring to OISC the general concept with no specific implementation or a specific implementation, such as MISC?
22:09:03 <bsmntbombdood> GregorR: MY oisc
22:09:06 <oerjan> of course that is anecdotical, i believe the GIVING COBOL is redundant.
22:09:10 <GregorR> bsmntbombdood: Ahhhhhhhh
22:09:19 <pikhq> Perhaps even INCREASE COBOL BY 1.
22:09:24 <pikhq> :p
22:09:32 <GregorR> There is such a thing as a programming language.
22:09:37 <GregorR> A programming language can be incremented.
22:09:38 <GregorR>  
22:09:46 <GregorR> There is a programming language named COBOL.
22:09:50 <GregorR> COBOL is to be incremented.
22:09:58 <pikhq> Not quite.
22:10:10 <oerjan> and i think there is some reasonable expression notation in cobol as well. perhaps.
22:10:17 -!- RodgerTheGreat_ has joined.
22:10:26 <pikhq> Make your class be operated on by a mathematician named Gregor.
22:10:34 <GregorR> Oh right.
22:10:39 -!- RodgerTheGreat has quit (Read error: 104 (Connection reset by peer)).
22:10:50 <GregorR> There is a mathematician named Gregor.
22:10:54 <GregorR> Gregor's first operand is COBOL.
22:10:58 <GregorR> Gregor's second operand is 1.
22:11:01 <GregorR> Gregor is to add.
22:11:13 <GregorR> ORK is Gregor's result.
22:11:51 <GregorR> Or, the acronym for that: MNGGFOCOBOLGSO1GAORKGR
22:34:33 -!- ihope_ has quit (pratchett.freenode.net irc.freenode.net).
22:34:33 -!- tgwizard has quit (pratchett.freenode.net irc.freenode.net).
22:34:34 -!- GregorR has quit (pratchett.freenode.net irc.freenode.net).
22:35:49 -!- ihope_ has joined.
22:35:49 -!- tgwizard has joined.
22:35:49 -!- GregorR has joined.
22:41:10 -!- ihope_ has quit (pratchett.freenode.net irc.freenode.net).
22:41:10 -!- tgwizard has quit (pratchett.freenode.net irc.freenode.net).
22:41:10 -!- GregorR has quit (pratchett.freenode.net irc.freenode.net).
22:41:33 -!- ihope_ has joined.
22:41:33 -!- tgwizard has joined.
22:41:33 -!- GregorR has joined.
22:50:46 -!- ihope_ has quit (pratchett.freenode.net irc.freenode.net).
22:50:46 -!- tgwizard has quit (pratchett.freenode.net irc.freenode.net).
22:50:46 -!- GregorR has quit (pratchett.freenode.net irc.freenode.net).
22:51:08 -!- ihope_ has joined.
22:51:08 -!- tgwizard has joined.
22:51:08 -!- GregorR has joined.
23:03:50 -!- ihope_ has quit (pratchett.freenode.net irc.freenode.net).
23:03:50 -!- tgwizard has quit (pratchett.freenode.net irc.freenode.net).
23:03:50 -!- GregorR has quit (pratchett.freenode.net irc.freenode.net).
23:04:14 -!- ihope_ has joined.
23:04:14 -!- tgwizard has joined.
23:04:14 -!- GregorR has joined.
23:39:49 -!- Asztal has joined.
23:43:48 -!- ihope_ has quit ("http://tunes.org/~nef/logs/esoteric/06.08.09").
23:48:00 -!- Fordsway has joined.
23:50:12 -!- Fordsway has left (?).

2007-01-03:

00:12:45 -!- Asztal has quit (Read error: 113 (No route to host)).
00:13:05 -!- Asztal has joined.
00:18:31 -!- jix__ has changed nick to jix.
00:24:35 -!- tgwizard has quit (Remote closed the connection).
00:59:06 -!- Asztal has quit (Read error: 113 (No route to host)).
00:59:45 -!- Asztal has joined.
01:21:54 -!- digital_me has joined.
02:00:24 -!- RodgerTheGreat_ has changed nick to RodgerTheGreat.
02:05:39 -!- Sandman has joined.
02:06:28 <Sandman> Hello, world
02:06:52 <bsmntbombdood> Enter, Sandman 
02:07:06 <CakeProphet> 99 bottles of beer on the wall.
02:07:22 <oerjan> Please write "Hello, world" _before_ I make this request.
02:07:23 <CakeProphet> hmmm...
02:07:37 <CakeProphet> I should make a language based on coroutines.
02:07:47 <CakeProphet> and... somehow mix it into my genetic language idea.
02:07:51 <Sandman> Sandman entered
02:08:01 <bsmntbombdood> coroutine?
02:08:04 <oerjan> Thank you.
02:08:07 <CakeProphet> Yeah... 
02:08:34 <CakeProphet> a subroutine takes input, executes, and returns an output to its caller.
02:08:58 <bsmntbombdood> ...
02:09:33 <CakeProphet> a coroutine takes in input, executes, returns a value, halts execution, awaits more input, continues execution until it returns a new value, repeat.
02:09:47 <CakeProphet> a glorified generator.
02:09:56 <bsmntbombdood> oh
02:10:28 <CakeProphet> you can use them to do psuedothreads nicely.
02:10:36 <CakeProphet> since they can halt their execution.
02:10:49 <CakeProphet> and take in more input when they continue.
02:11:27 <CakeProphet> You could actually use a coroutine to simulate an infinite list.
02:11:33 -!- Administrator has joined.
02:11:42 -!- Administrator has changed nick to kilovh.
02:11:53 <kilovh> hi
02:12:12 <kilovh> Please, write the 99 bottles lyrics
02:12:16 -!- kilovh has quit (Client Quit).
02:12:32 <Sandman> 99 nine bottles of beer on the wall
02:12:36 <Sandman> 98 nine bottles of beer on the wall
02:12:40 <Sandman> 97 nine bottles of beer on the wall
02:12:43 <Sandman> 96 nine bottles of beer on the wall
02:12:58 <oklopol> a lazy evaluator like me won't do that if the programmer isn't looking
02:13:16 <Sandman> 99...0 bottles of beer on the wall
02:13:57 <RodgerTheGreat> 0 bottles of beer on the wall, 0 bottles of beer, go to the store, pick up some more, 99 bottles of beer on the wall
02:14:09 <jix> i don't like beer
02:14:14 <RodgerTheGreat> me neither
02:14:24 <RodgerTheGreat> seems like just decrementing would be easier
02:14:30 <jix> so 99 bottles of beer on the wall... (2 hours later) still 99 bottles of beer on the wall
02:14:35 <RodgerTheGreat> lol
02:14:38 <Sandman> 99 bottles of beer go to the store and pick upp 99 bottles, 99*99 bottles of beer on the wall
02:15:03 <RodgerTheGreat> that's picking up way more than 99 bottles
02:16:00 <Sandman> oh sorry it should have been: 99 bottles of beer go to the store and pick upp 99 bottles each, 99*99 bottles of beer on the wall
02:16:54 <pikhq> Sandman: Join #irp; we need programmers.
02:17:03 <RodgerTheGreat> what I've always wondered about the song is: "why do they store all the beer on a *wall*? Wouldn't a box, refrigerator, or at least shelf prove a more efficient storage medium?"
02:18:36 <Sandman> Yeah me too...walls ive tried storing bottles of beer on the wall, and guess what? They fell to the floor
02:19:59 <RodgerTheGreat> You could glue them to the wall, but it'd make it tricky to take them down again
02:20:27 <pikhq> Cleverly arranged nails, perhaps.
02:20:37 <RodgerTheGreat> I imagine something like a workbench tool rack, with beer bottle-sized loops
02:21:00 <Sandman> I once heard something about some shelve thingy. dont really know what thats all about
02:33:12 -!- Asztal has quit (Read error: 113 (No route to host)).
02:37:04 -!- Sandman has quit ("Merry christmas to ya all out there!").
02:39:56 <CakeProphet> hmmm... I kind of regret that = become the most popular way to assign variables.
02:40:17 <bsmntbombdood> why?
02:40:47 <oklopol> a<-b :DD
02:40:57 <bsmntbombdood> eeew
02:41:10 <oerjan> There is of course the broken BF version.
02:41:18 <CakeProphet> one of the most common confusions by new programmers is the distinction between variabe assignment and mathematical equality... most likely because = (the symbol for mathematic equality) is used for it...
02:41:33 <bsmntbombdood> CakeProphet: The symbol used doesn't matter
02:41:35 <CakeProphet> and they look superficial similar at first glance (VERY first glance :D )
02:41:41 <CakeProphet> it does when you're starting out.
02:41:45 <CakeProphet> not later.
02:41:50 <oerjan> 0 bottles of bear on the wall, 0 bottles of beer.  Take one down, pass it around, 255 bottles of beer on the wall!
02:41:52 <CakeProphet> once you know the symbol means nothing  :P
02:41:55 <bsmntbombdood> If someone can't wrap their head around that, they aren't very smart
02:42:28 <oklopol> I myself do not really care how hard it is for newbies to start programming :\
02:42:30 <CakeProphet> Pretty much everyone makes the leap... I just wonder why it's nessicary to put the cliff there.  :P
02:42:37 * CakeProphet does.
02:42:48 <CakeProphet> C is a bitch... 
02:42:57 <CakeProphet> to start out on.
02:43:03 <oklopol> you can do a:=b
02:43:06 <bsmntbombdood> C is fun
02:43:16 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
02:43:17 <CakeProphet> if programming is a bitch... programming looks painful and boring.
02:43:22 <CakeProphet> if it's easy... it looks fun.
02:43:41 <CakeProphet> It -is- fun... but only if you know what you're doing.
02:43:47 <oklopol> i use c++ almost exclusively
02:43:53 <bsmntbombdood> oklopol: ewwww
02:43:56 <oklopol> :D
02:44:01 <bsmntbombdood> CakeProphet: As with anything
02:44:28 <CakeProphet> So I think it's best to start with something that's easy to learn... so programming starts out fun.
02:45:07 <bsmntbombdood> if it's easy to learn it's not going to be worth using
02:45:38 <CakeProphet> Not true.  ;)
02:45:50 <CakeProphet> If it's easy to learn... that means it's more intuitively worth using.
02:46:08 <CakeProphet> or... it could mean it's not worth using.
02:46:20 <CakeProphet> but... let's be optimistic and go with the first option.
02:46:25 <CakeProphet> :D
02:46:30 <oklopol> I started with basic, was a bitch changing to C++ since i couldn't understand the distinction between = and ==, i though "How can I know which kind of equality this is?".
02:47:59 <CakeProphet> yeah... things like that are bad..
02:48:43 <bsmntbombdood> pssh
02:49:15 <CakeProphet> You should start from the top and work your way down... not stay at the top and keep the bottom hidden  (ir works nicely for abstraction, but not for learning)
02:49:32 * pikhq went Basic -> Javascript -> rm -rf basic -> Tcl -> shell -> C -> C++ -> way, way too many esolangs.
02:49:34 <oklopol> tho i was kinda small, didn't really understand what was happening there, prolly properly taught a basic programmer would've understood the difference even tho the same symbon is used :)
02:51:19 * oklopol wants to list too: Basic -> C++ -> python -> C++ -> Brainfuck -> Java -> C++ -> Haskell -> C++
02:51:26 <CakeProphet> Python -> Scheme -> Python -> C (for a second) -> esolangs yay
02:51:38 <oklopol> esolangs all the way
02:51:44 <CakeProphet> I should really get to know a lot of other languages better... rather than just skimming over them.
02:51:58 <oerjan> shall we see...
02:52:07 <CakeProphet> C makes my stomach churn... so not going there.
02:52:29 <CakeProphet> Perl and Lisp (definetely Lisp) look cool...
02:52:35 <CakeProphet> Smalltalk?
02:53:33 <oklopol> i don't know perl, lisp, pascal, cobol, intercal or smalltalk, i hate it when i know the name but not the language
02:53:35 <oklopol> :\
02:53:41 <pikhq> I've gotten to the point where I can at least do a minor amount of fiddling around in the vast majority of languages (with the help of Google).
02:53:59 <CakeProphet> I'm more familiar with Scheme than I am Lisp.
02:54:05 <CakeProphet> but... they're not that different anyways.
02:54:08 <pikhq> Scheme is a Lisp.
02:54:12 <CakeProphet> yeah.
02:54:19 <CakeProphet> By "lisp" I mean Common Lisp.
02:54:24 <pikhq> Ah.
02:54:25 <oerjan> Basic -> Turbo Pascal -> Modula -> LPC -> C -> Perl -> Ocaml -> Haskell and a bunch that i just read about
02:54:45 <oerjan> or used even less than the ones mentioned
02:54:48 <pikhq> It's comparable to the difference between C and C++.
02:55:16 <CakeProphet> I like that Scheme uses a single define function  :D
02:56:25 <CakeProphet> LPC... hmmm... a language used to create MUDs...
02:56:36 <CakeProphet> sounds like something I would enjoy... but probably not.
02:56:40 <oerjan> oklopol: it is usually not considered a disadvantage not to know cobol. :)
02:56:44 * CakeProphet is making a MUD in Python that uses freaky meta-programming stuff.
02:57:24 <CakeProphet> Perl is a little weird... it has a lot of obvious disavantages, but I like the philosophy behind it.
02:57:37 <pikhq> oklopol: The use of COBOL cripples the mind, therefore, it's teaching should be considered criminal.
02:58:01 <oklopol> i wanna learn it :(
02:58:12 <pikhq> Learn ORK.
02:58:19 <oerjan> You are supposed to change your nick to dijkstra when you say that :)
02:58:36 <pikhq> Rather,
02:58:39 <pikhq> MNGGFOCOBOLGSO1GAORKGR
02:58:44 <pikhq> oerjan: Yeah, yeah, yeah
02:59:12 <oklopol> i'll learn ork once i see a complete reference for it
02:59:17 <oklopol> or a tutorial
02:59:28 <pikhq> Hit the Esolangs wiki.
02:59:43 <pikhq> And realise that code is a bunch of English sentences.
03:00:17 <oklopol> i thought there was just a few examples
03:00:27 <oklopol> pikhq, i've seen ork code
03:00:48 <pikhq> It's not that hard. . .
03:00:55 <pikhq> When the program starts:
03:01:00 <oerjan> the wiki doesn't describe the builtin classes very well, i guess.
03:01:06 <pikhq> There is a scribe named Hi.
03:01:14 <pikhq> Hi is to write "Hello, world!\n."
03:01:19 <CakeProphet> http://esoteric.voxelperfect.net/files/ork/doc/README
03:02:02 <oklopol> i've made a lot of english based langs while planning on a project etc but never made an interpreter for any since they often grow quite complex
03:02:27 <CakeProphet> short jumbled-up-series-of-characters languages are starting to grow on me.
03:02:34 <CakeProphet> as are overly verbose ORK-ish languages.
03:02:48 <pikhq> It's compiled into C++.
03:02:59 <CakeProphet> Yeah.
03:03:12 <CakeProphet> So what?
03:04:41 <pikhq> Just saying.
03:05:39 <CakeProphet> :P   Most languages go to assembly at some point... doesn't mean I'd enjoy coding in assembly very much.  :P
03:06:12 <oklopol> I like assembly :)
03:06:29 * CakeProphet has never actually seen assembly code before.
03:06:48 <CakeProphet> I wonder what CPython looks like...
03:06:52 * CakeProphet goes and checks.
03:07:15 * pikhq doesn't do any assembly. . .
03:07:38 <pikhq> Although I do tons of equally crazy stuff. ;)
03:08:13 <CakeProphet> I can see where ORK sometimes looks like obvious syntatic sugar over C++... but it's strangely different in a way that I like.  :D
03:08:45 <pikhq> It's syntactic sugar over C++ and some libraries, in some ways.
03:09:24 <CakeProphet> I don't consider syntatic sugar a bad thing though.
03:09:39 <CakeProphet> Everything is just syntax sugar for some super low-level operation anyways.
03:11:05 <oklopol> i don't like asciiWrite
03:11:06 <oklopol> :\
03:11:12 <pikhq> oklopol: Why not?
03:11:16 <oklopol> so poetic otherwise
03:12:03 <CakeProphet> yeah... I don't like readOne  :D
03:12:13 <CakeProphet> why not just read one?
03:13:07 <CakeProphet> The whole function-names-blending-into-the-syntax is the coolest part.... so seeing readOne is just kind of annoying. :P
03:13:14 <oklopol> yeah, ORK should try to avoid anything that looks like programming imo
03:13:18 <oklopol> actually
03:13:19 <pikhq> Functions with a space in the name produce some vagueness in parsing.
03:13:25 <oklopol> exactly what  CakeProphet said
03:13:37 <GregorR> ORK doesn't support multi-word function names :(
03:13:49 <oklopol> make it support :) then i love it
03:13:51 <GregorR> Due to the parsing difficultimpossibility.
03:13:54 <bsmntbombdood> lisp does!
03:14:05 <GregorR> The problem is this:
03:14:10 <GregorR> <actor> is to <function> <variable>
03:14:24 <GregorR> If both functions and variables can have spaces, it's very difficult to parse.
03:14:31 <oklopol> yeah, but you can avoid that if you know it
03:14:35 <oklopol> oh
03:14:51 <oerjan> you could demand an article between <function> and <variable>.
03:14:52 <bsmntbombdood> In lisp symbol names can be anything
03:14:55 <pikhq> And impossible if one has two function/variable combinations that match.
03:15:08 <GregorR> oerjan: Yeah, but then it doesn't read well X_X
03:15:13 <GregorR> pikhq: A-yup :(
03:15:17 <oklopol> but the compiler could give an error if names can collide
03:15:19 <GregorR> It's the one corner of ORK that bugs me 8-X
03:15:28 <GregorR> oklopol: And then what? There's still no solution ;P
03:15:34 <CakeProphet> hmmm... Python has a just-in-time compiler implementation... neato.
03:15:45 <oklopol> GregorR, why?
03:15:49 <oklopol> it is a solution
03:15:52 <oerjan> it can read well if the variables are nouns
03:16:38 <oerjan> common nouns i mean
03:16:51 <CakeProphet> it would still parse fine...
03:16:53 <oklopol> if there are say 5 words in the bit that has <function> and <variable>, it checks all possibilities (4 of them) and does the right one
03:17:22 <GregorR> oklopol: But if there are conflicts, there would then be no way to right it.
03:17:34 <oklopol> an error
03:17:40 <oklopol> compile-time error
03:17:53 <oklopol> if there are 2 that apply
03:18:06 <CakeProphet> hmmm...
03:18:21 <oerjan> now wait. proper nouns can be detected because they are capitalized.
03:18:50 <pikhq> Perhaps a rewrite of the sentence's grammer?
03:19:05 <oerjan> so a variable would be either 'the' <common noun>, 'a' <common noun> or a capitalized proper noun.
03:19:22 <GregorR> oerjan: That's a good point ...
03:19:41 <oklopol> i mean, if a thing has functions "a b c" and "a b" and vars called "c d e" "d e", it would give an error, very easy to check for each class
03:19:42 <CakeProphet> Doggie Samuels is to be or not to be that is the question                when there is the functions  "to be" "be or not"  
03:20:15 <CakeProphet> hmmm... if it finds the variable first... it can clip off the variable name and know -exactly- what function to look for.
03:20:20 <CakeProphet> but...
03:20:24 <GregorR> oklopol: Giving an error isn't a solution, it just leaves the coder with no way to call that particular selection :P
03:20:27 <CakeProphet> there's something wrong with that.
03:20:53 <oklopol> GregorR, you still have the old way of naming if you MUST have colliding names
03:21:03 <GregorR> True *shrugs*
03:21:16 <oklopol> and, it can support the ucase thing too
03:21:36 <CakeProphet> so in that example...  the parse would find   the variable "to be that is the question"... and could conclude that "to be or not" is the only function.
03:21:37 <oklopol> if collision, check for uppercase and solve that way
03:21:56 <CakeProphet> but... there could be ambigious -between- multiple functions and variables... which is where you would have problems.
03:22:42 <oklopol> as i said, then check if there are uppercase beginnings in words that indicate change of noun, if not, tell the programmer his names are colliding
03:22:57 <oklopol> and please supply me with a better word that collision...
03:23:00 <oklopol> :)
03:23:14 <oklopol> might be fine tho
03:23:14 <CakeProphet> yeah... the chance of colliding names is rare enough that it could simply complain to the programmer about it.
03:23:44 <CakeProphet> and then have OPTIONAL syntax to explicitly mark the beginning of the parameter... should a name collision occur.
03:23:54 <CakeProphet> :D
03:24:13 <oklopol> yep, just harder to make a compiler, but not much
03:24:26 <CakeProphet> I would interpreter it myself...
03:24:32 <CakeProphet> er.. interpret
03:24:38 <oklopol> i'll do it if GregorR won't
03:24:46 <oklopol> THAT'LL show him
03:25:04 <CakeProphet> It's line-by-line statements that each do one thing... so it can't be that harder than a compiler.
03:25:41 <CakeProphet> it actually sounds easier than convert all of it to C.
03:25:46 <CakeProphet> (++)
03:26:58 <oklopol> both simple, i just meant the pattern-matching for the var- and cuntnames
03:27:01 <oklopol> -_________-
03:27:03 <oklopol> funcnames
03:27:07 <CakeProphet> but yeah... the chance of there being a bunch of name overlaps that ORK couldn't possibly figure out is so rare that it can just be solved by optional syntax to split up the two.
03:27:09 <CakeProphet> hahahahaha
03:27:14 <oklopol> :D
03:27:47 <oklopol> or, it can be guaranteed to be lazy
03:28:08 <CakeProphet> yeah, de-ambiguity rules is the other route.
03:28:08 <oklopol> i mean, shortest possible func for example
03:28:10 <oklopol> and the rest as a var
03:28:22 <CakeProphet> stating what the interpreter will do during ambiguity...
03:28:24 <GregorR> oklopol: I would, but since you volunteered, feel free :P
03:28:26 <CakeProphet> I like the optional syntax route myself.
03:28:59 <oklopol> GregorR, depends on whether i go to sleep still
03:29:00 <CakeProphet> it would be the Perl way to go about it.  :D
03:29:21 <CakeProphet> well no... hueristical evaluation is also in Perl's domain.
03:30:08 <oklopol> must the built-in classes be named like that? i mean, inputter is too programmingish imo, ork shouldn't sound like that
03:30:33 <CakeProphet> there could just e a single read/write class called scribe.
03:30:40 <CakeProphet> or typist... or any other nifty name you want.
03:30:57 * CakeProphet writes an ORK interpreter for Python.
03:32:26 <CakeProphet> maybe with static typing removed  :P
03:32:32 <CakeProphet> but it kinda adds a nice touch to the syntax.
03:32:41 <CakeProphet> so I'll probably keep it.
03:33:30 <CakeProphet> hmm... what's the delimiter for statements... periods or newlines (or both?)
03:34:06 <pikhq> Both, I believe.
03:34:50 <CakeProphet> aaand... # is comment I'm guessing?  Like Python comments?
03:35:01 <CakeProphet> yeah.
03:35:32 <pikhq> oklopol: inputter is a temporary name. . . Like, Gregor doesn't know of a better name for it.
03:35:39 <CakeProphet> oooh... I like the separation of function and class...
03:35:45 <CakeProphet> you can mix and match classes to functions.
03:36:47 <CakeProphet> oh wait...
03:37:03 <CakeProphet> no they're connected right?  ...to prevent scoping ambiguity.
03:37:29 <GregorR> Only newline is a delimiter.
03:37:30 <oklopol> # is a comment in ork?
03:37:32 <GregorR> Periods are just fluff.
03:37:46 <GregorR> # is a comment, yes :P
03:37:51 <GregorR> (Perhaps this should be a comment)
03:38:03 <CakeProphet> yeah... I like that  :D
03:38:11 <CakeProphet> you could use it for inline comments.
03:38:26 <CakeProphet> Like asides to the actual program.
03:38:29 <oklopol> This is an object for expressing BigNums, but that is ignored.
03:38:37 <oklopol> ^^^^ comment
03:38:53 <oklopol> () is good too
03:39:04 <CakeProphet> This is an object for expression BigNum, but nobody cares.       (reference to an uncyclopedia inside joke)
03:39:16 <oklopol> thought about that too
03:39:29 <oklopol> i mean
03:39:35 <oklopol> not that exact string  of course :)
03:39:42 <CakeProphet> http://uncyclopedia.org/wiki/Nobody_cares
03:39:49 <CakeProphet> I like () though.
03:40:44 <CakeProphet> I think "backwards if" statements look a little more englishy.
03:41:23 <CakeProphet> Bob is to eat a sandwhich, if my kitchen is not exploded.
03:41:49 <oerjan> I thought i heard someone here say today that they hated such statements. :)
03:42:14 <CakeProphet> I use them quite a bit... since it's how Python does conditional expressions
03:42:31 <CakeProphet> x = (True if MyConditional() else False)
03:42:39 <CakeProphet> so I'm just used to them.  :D
03:43:42 <oklopol>  When looper is to loop a number:
03:43:43 <oklopol>   There is a mathematician called Fibonacci.
03:43:43 <oklopol>   I have a number called current.
03:43:43 <oklopol>   Fibonacci's first operand is the number.
03:43:43 <oklopol>   Fibonacci's second operand is 1.
03:43:43 <oklopol>   Fibonacci is to subtract.
03:43:44 <oklopol>   current is Fibonacci's result.
03:43:46 <oklopol>   Fibonacci's first operand is Fibonacci's result.
03:43:48 <pikhq> Looks like [set x [expr {1 ? [myConditional] : 0}]]
03:43:48 <oklopol>   Fibonacci's second operand is 0.
03:43:50 <oklopol>   Fibonacci is to compare.
03:43:52 <oklopol>   If Fibonacci says it's greater then I am to loop.
03:43:54 <oklopol> whoops
03:43:56 <oklopol> long paste :)
03:44:05 <pikhq> Or:
03:44:14 <pikhq> Err.
03:44:22 <oklopol> well, anyways, "I have a number called current." means int &current = number; ? because otherwise number wouldn't change
03:44:31 <pikhq> That's [expr {[myConditional] ? 1 : 0]}] XD
03:45:07 <pikhq> I think it means "number &current;".
03:45:15 <pikhq> Err.
03:45:15 <oklopol> :O
03:45:18 <pikhq> "number current;"
03:45:20 <oklopol> i don't
03:45:27 <oklopol> eh
03:45:30 <oklopol> in c++?
03:45:31 <CakeProphet> I don't like C's conditional expressions  :P
03:45:39 <pikhq> Nah, it's "double current;".
03:45:59 <pikhq> (thought that Gregor had number as a seperate class, which he doesn't.)
03:46:03 * CakeProphet needs to figure out all the possible statements in ORK to do a proper implementation of it.
03:46:05 <oklopol> okay, then this is an infinite loop, right?
03:46:22 <oerjan> we don't have to choose. we could make it alternating current.
03:46:49 * CakeProphet implements a form of coroutine in his ORK :D
03:47:12 <oklopol> right?
03:47:15 <pikhq> Right.
03:47:16 <oklopol> isn't it?
03:47:29 <oklopol> This would loop from the value you gave it down to 0.  You would of course want to add some sort of
03:47:30 <oklopol> functionality there, too.
03:47:33 <oklopol> so it's wrong?
03:49:03 <pikhq> It's an infinite Fibo loop.
03:49:27 <pikhq> Err.
03:49:29 <pikhq> Never mind.
03:49:44 <pikhq> I'm stupid.
04:01:47 -!- anonfunc has joined.
04:11:08 <oklopol> GregorR, you'll prolly make it faster, i've only done some basic classes
04:11:30 <oklopol> if you have the old code, i mean, it won't take long prolly :)
04:12:59 <oklopol> haha made a regexp parser last night and got to use it right away :)
04:20:05 * CakeProphet is just now definining the new number class for ORK numbers.
04:20:34 -!- oerjan has quit ("Good night.").
04:20:37 <CakeProphet> it would basically be a floating point with an overriden __str__ class... so it doesn't print the a trailing .0 like Python does.
04:26:00 <RodgerTheGreat> hm. I just had a thought- can anyone think of a way to calculate the length of an optimal BF program that generates a constant, without actually creating he program?
04:28:59 <oklopol> i've made the calculations i think
04:29:05 <oklopol> i'll check if i finished
04:31:20 <RodgerTheGreat> the problem with creating a compiler to Def-BF is the absolute addresses- if you don't use a constant-generation command (?), you have to generate values in-place. This means that making constants changes code length, requiring a change in what the resulting values should be. The only way I can see to get around this would be making use of a lookup table as on the BF-constants page.
04:31:27 <RodgerTheGreat> it's a really inelegant approach
04:31:53 <oklopol> yeah, i've researched it a bit, but can't find the fucking file :(
04:32:48 <oklopol> you can brute force the most optimal way to create a number quite easily
04:33:50 <oklopol> 1 levels, takes: N
04:33:51 <oklopol> 2 levels, takes: Abase+A+B+7, where N=Abase+B*A
04:33:51 <oklopol> 3 levels, takes: Abase+Bbase+A+B+C+14, where N=Abase+(Bbase+C*B)*A
04:34:06 <oklopol> levels is the amount of memory slots you are willing to use
04:34:22 <RodgerTheGreat> hm. interresting
04:34:41 <oklopol> i've not come up with a clever algoritm to produce good bases for 3 levels, but you don't need it often
04:34:52 <oklopol> hmm levels, good name :)
04:36:20 <oklopol> if you use one memory slot for help, you the smallest possible "Abase+A+B+7" where a*b+abase = your number
04:37:19 <oklopol> and constructed of course A times + [ > B times + < - ] > abase
04:37:33 <RodgerTheGreat> yeah
04:38:01 <oklopol> the amount of auxiliary symbols is (memory slots used)*7
04:38:13 <oklopol> if you want the result in your starting slot
04:38:28 <RodgerTheGreat> what about programs of the form A+ [>B+<-]>C+/- ?
04:38:45 <oklopol> abase can be negative
04:38:53 <oklopol> actually
04:39:03 <oklopol> abs(Abase)+A+B+7
04:39:06 <oklopol> like that
04:39:52 <RodgerTheGreat> ah- I see
04:39:55 <oklopol> but, seems i didn't make it thro to the end
04:39:56 <oklopol> sorry
04:40:03 <oklopol> i don't have an algorithm :)
04:42:04 <oklopol> hmm take the squareroot of the number and make a and b that, or if not an integer, a<sqrt, b>sqrt
04:42:22 <oklopol> abase will be balance it out
04:42:32 <oklopol> that is the best algorithm i think, actually
04:43:33 <oklopol> with three levels, taking the cuberoot and brute forcing different values for abase and bbase while changing a, b and c near the cuberoot might do the trick
04:45:38 <RodgerTheGreat> hm
04:45:47 <oklopol> for numbers smaller than 256 you don't get much profit from 3 levels
04:45:56 <RodgerTheGreat> well, that's a lot of help
04:46:03 <oklopol> hopefully
04:46:10 <RodgerTheGreat> in most cases, we'll be dealing with relatively large numbers
04:46:21 <oklopol> okay
04:46:28 <oklopol> you can take the easy way out of course
04:46:31 <RodgerTheGreat> the Def-BF standard pretty much requires 32-bit cells
04:46:38 <RodgerTheGreat> which is?
04:46:38 <oklopol> just split the numbers in 4 pieces
04:46:49 <oklopol> with num>>8
04:47:01 <RodgerTheGreat> hm
04:47:04 <oklopol> octet by octet
04:47:17 <oklopol> then just merge them by multiplying with 256
04:47:18 <oklopol> actually
04:47:28 <oklopol> much worse
04:47:35 <RodgerTheGreat> yeah- then it just becomes a problem of generating the components, which could feasibly be done via lookup...
04:47:39 <oklopol> since the 256 takes 36 symbols again
04:48:06 <oklopol> +++>>++++++[-<++++++>]<[-<+++++++>]< is the smallest 256 i think
04:49:15 <oklopol> it has abase=3, bbase=0, c=6, b=6, a=7 3+(0+6*6)*7
04:49:32 <oklopol> 3+(0+6*6)*7 was just to help me think
04:49:34 <oklopol> :)
04:49:39 <RodgerTheGreat> the smallest non-wrapping level 3 is one of four variants that are 32 commands
04:50:04 <RodgerTheGreat> wait, three variants
04:50:31 <oklopol> huh?
04:50:43 <oklopol> one of what variants?
04:50:50 <RodgerTheGreat> >>++++++++[-<[-<++>]<+[->+<]>>]< (32, 3) non-wrapping
04:50:50 <RodgerTheGreat> >+>+++++++[-<[-<++>]<+[->+<]>>]< (32, 3) non-wrapping
04:50:51 <RodgerTheGreat> >>++++[-<[-<++++>]<+++[->+<]>>]< (32, 3) non-wrapping
04:50:57 <oklopol> yes
04:51:02 <oklopol> i forgot to mention that
04:51:35 <oklopol> all that matters about the small differences in the final length is where you end
04:52:05 <oklopol> otherwise you have many strategies to position abase, bbase etc
04:52:24 <RodgerTheGreat> luckily, Def-BF makes memory use in programs a little less vital than most BF-derivatives, so we don't have to do something messy like hard-allocate 3 cells per constant
04:53:46 <oklopol> you do realize that even if using 4 levels allows a 32-bit number to be expressed in <60 symbols, it still takes 2^32 cycles to create? :)
04:55:10 <RodgerTheGreat> yeah
04:55:57 <RodgerTheGreat> we're assuming for now that either the machine is fast enough for anything we want or that the BF-ASM compiler is infinitely deep in it's analysis and optimization of code
04:56:40 <oklopol> ++++[>++++<-]>[>++<-]> (32, 2)
04:57:06 <oklopol> i have all loops separate in the system
04:57:59 <oklopol> i'll do the complete algorithm to find the optimal way for that someday unless i see it somewhere else
04:58:06 <oklopol> i'll continue the ork now
04:58:41 <oklopol> 176 "smth had to be truncated to 256 characters for debug information" warnings
04:58:47 <oklopol> so far so good :D
04:59:43 <RodgerTheGreat> haha
05:01:56 <oklopol> can i see an ork program to check the final syntax? :D
05:03:06 <oklopol> if there are accidental infinite loops in a tutorial, i'd like to check i working program to be sure
05:03:15 <oklopol> *a working
05:04:16 <oklopol> sleep retry ->
05:05:08 <CakeProphet> http://esoteric.voxelperfect.net/files/ork/src/orkfuck.ork
05:06:06 <GregorR> Woooh, ORKFuck!
05:06:37 <CakeProphet> GregorR,  hmmm... do you have some sort of docs on the exact specs of ORK?
05:06:45 <GregorR> Ha! It is to laugh!
05:06:57 <CakeProphet> I'm too lazy to crack open the source and read it with my shoddy C++ literacy.
05:07:17 <GregorR> I do, but the site it's all on is apparently down >_>
05:07:43 <oklopol> There is such a thing as a brainfuck interpreter.
05:07:45 <oklopol> A brainfuck interpreter can instanciate.
05:07:45 <oklopol> A brainfuck interpreter can subinstanciateData a number.
05:07:45 <oklopol> A brainfuck interpreter can subinstanciateProgram a number.
05:08:03 <oklopol> put the "There is... " line beneath the others?
05:08:39 <oklopol> and, could i declare "A brainfuck interpreter can instanciate." in say, the main
05:08:56 <GregorR> No and no.
05:08:57 <RodgerTheGreat> 'night, everyone. I should be on again late tomorrow.
05:09:01 <oklopol> i'm making an interpreter now, tho it's a trivial conversion if needed
05:09:05 <oklopol> good
05:09:17 <GregorR> Bye RodgerTheGreat 
05:09:27 <oklopol> Bye
05:09:39 -!- RodgerTheGreat has quit.
05:10:16 <oklopol> godfuck... who wrote the bfork?
05:10:43 <oklopol> orkfuck i mean
05:10:56 <GregorR> <--
05:12:12 <oklopol> haha you're sick
05:12:27 <oklopol> or did you just do an evil conversion?
05:15:23 <GregorR> I wrote it from the top.
05:15:30 <GregorR> I don't recall anything about it *shrugs*
05:16:58 <CakeProphet> hmm... the comments in the source should be enough to get all the possible syntax.
05:17:07 <CakeProphet> unless you randomly don't-comment-certain-parts
05:17:13 <CakeProphet> my C-reading skills are lacking.
05:36:00 <pikhq> oklopol: Allow me to give you a much shorter version of 255.
05:36:06 <pikhq> - (1, 1) wrapping
05:38:01 <oklopol> true, i meant non-wrapping since i assumed bignum
05:38:50 * pikhq is generally used to having wrapping, since chars, well, wrap.
05:39:01 <oklopol> and secondly, i'm lying, i recalled wrapping much after i'd said said my thing
05:39:16 <pikhq> HEheh.
05:42:33 <CakeProphet> hmmm... are function definitions independent of class declarations?
05:42:44 <oklopol> in ork?
05:42:46 <CakeProphet> or are they "within" the last defined function.
05:42:48 <CakeProphet> yeah.
05:42:55 <CakeProphet> er... last defined class
05:43:05 <pikhq> See the C++ code. ;)
05:43:25 <oklopol> they are in the class that is mentioned in the "When a ... is to ..."
05:43:29 <oklopol> the first ...
05:43:42 <CakeProphet> ooooh.
05:43:46 <CakeProphet> duh  :P
05:44:09 <CakeProphet> pikhq,  See makes my eyes hurt when I try to understand it.
05:44:20 <CakeProphet> but the comments are useful.
05:53:03 -!- digital_me has quit (Read error: 54 (Connection reset by peer)).
06:28:00 <CakeProphet> GregorR,  haha... you could introduce metaclasses into ORK
06:28:13 <CakeProphet> "thing" being the default metaclass  :D
06:28:17 <GregorR> lol
06:28:26 <CakeProphet> There is such a <metaclass> as a <class>
06:28:47 <CakeProphet> +
06:28:49 <pikhq> There is such a mammal as a dog.
06:29:05 <pikhq> Wheee. . .
06:29:13 <GregorR> There is such a thing as a <class>, which is a type of <metaclass>
06:29:31 <pikhq> I prefer Cake's idea. . .
06:29:40 <pikhq> But whatever.
06:29:40 <CakeProphet> Yeah  :D
06:30:43 <CakeProphet> There is such a thing as a thing
06:30:47 <CakeProphet> O.o
06:31:01 <CakeProphet> No clue how metaclasses would work in ORK though.
06:31:38 * CakeProphet sometimes wishes there was a simpler version of regex that used that kind of syntax
06:31:49 <CakeProphet> This <variable> is a <blank> that likes to <blank>
06:32:06 <CakeProphet> ... I could... make it?
06:32:13 <CakeProphet> :D
06:32:25 * CakeProphet makes it.
06:37:58 * Sukoshi groans.
06:38:03 <Sukoshi> Ugggh. Metaclasses.
06:39:27 <Sukoshi> The future of OOP: An abstract framework of abstract metaclasses.
06:44:58 <CakeProphet> haha
06:45:03 <CakeProphet> metaclasses are magical  :P
06:45:12 <Sukoshi> How are they magical?
06:45:17 <CakeProphet> Dunno...
06:45:22 <CakeProphet> they're not very useful for most things.
06:45:35 <Sukoshi> That about sums up all of theoretical OOP.
06:45:36 <CakeProphet> only a few specific things that need a little funky class-based magic.
06:45:52 <CakeProphet> OOP can at times be redundent... and it's a little weird.
06:46:04 <CakeProphet> but it makes things weirdly effective.
06:47:43 <pikhq> Sukoshi: The future of OOP:
06:48:04 <pikhq> There is an object which does everything I want.
06:48:58 <pikhq> The stdlib always has every object that does everything you want.
06:49:10 <CakeProphet> factory functions that produce classes are strangely powerful....
06:49:21 <pikhq> And it's an abstraction ontop of 500 different layers. . . ;)
06:49:42 <CakeProphet> you can box a few generalized patterns about certain class designs into a single word.
06:52:44 <Sukoshi> You remind me of the wackiest abstraction I made/used.
06:53:34 <pikhq> Yes?
06:54:09 <pikhq> (that abstraction is?)
06:54:50 <Sukoshi> I wanted to generalize binary classes in a user-made package that had the same named slots but different names under one generic class so I could save myself the typing, so I made an alist with the keys as the symbols for the generic class names and what was assoc'd with the key was an anonymous function produced by a macro for the metaclass definition. This function then defined a new class according to another macro, and generated an
06:54:50 <Sukoshi> instance of it if desired.
06:59:54 <pikhq> That's almost like writing an OS to implement dc.
07:03:25 <Sukoshi> I wanted to save 40 lines of typing.
07:04:53 <Sukoshi> I did -- I did the thing in like 10 lines.
07:06:28 <pikhq> Still.
07:06:48 <Sukoshi> What? I saved my hand from OCD.
07:06:50 <Sukoshi> Errr...
07:06:52 <Sukoshi> RSI.
07:06:59 <Sukoshi> ;D
07:07:28 <Sukoshi> Ah the power of Lisp.
07:17:21 <CakeProphet> hmmm...
07:17:23 <CakeProphet> not surprisingly.
07:17:30 <CakeProphet> when you use regex to substitute things into regex.
07:17:32 <CakeProphet> problems arise.
07:18:03 <Sukoshi> I can't think why if you use your macros correctly.
07:18:12 <Sukoshi> Oh wait -- this is Python.
07:18:22 <CakeProphet> Yah.
07:18:31 * Sukoshi pities the stringent syntax.
07:18:46 <CakeProphet> eh... I must be used to it.
07:18:51 <CakeProphet> I find it very "lazy".
07:19:05 <Sukoshi> Haskell is lazier :P
07:19:08 <CakeProphet> No semicolons and braces and all that jazz.
07:19:28 <CakeProphet> C looks gawd-awful to type... but I guess you'd get used to all the symbols after a while.
07:19:42 <Sukoshi> It's easy to parse.
07:19:51 <Sukoshi> Plus, it makes for fun formatting tricks.
07:20:11 <Sukoshi> I, personally, abhor overreliance on whitespace.
07:20:32 <CakeProphet> meh... small rewards for the task of typing all that crap out.
07:20:44 <Sukoshi> Typing what out?
07:20:47 <Sukoshi> A semicolon?
07:20:57 <CakeProphet> semicolons and braces... not to mention it looks ugly.
07:21:07 <CakeProphet> A few hundred semicolons.
07:21:27 <Sukoshi> What if you were working on a very small resolution display, and indendation would look horrible?
07:21:50 -!- MM2 has joined.
07:21:56 <CakeProphet> ...I haven't thought about it much.
07:22:02 <Sukoshi> :P
07:22:13 <CakeProphet> Good argument though..   :P :P :P
07:22:45 <Sukoshi> Also, think about using regexps to go through Python code and change stuff around -- annoying.
07:23:22 <CakeProphet> It's like saying "You'd care more about how slow Python is if you were on a 1980s IBM"
07:23:55 <Sukoshi> More like "You'd care more about how slow Python is if you did anything system critical."
07:24:31 <CakeProphet> I remember some implementation of Python written in Python, with the very ambitious goal of becoming faster than C.  :P
07:24:46 <CakeProphet> Don't think it'll happen anytime soon.
07:24:50 <Sukoshi> There's Jython, and that's scary.
07:24:56 <CakeProphet> PyPy
07:25:16 <Sukoshi> Python being compiled by Java. Whoo.
07:25:24 <CakeProphet> Yeah...
07:26:02 <CakeProphet> I've never encounted any slowness with Python so far... but I haven't really worried about it
07:26:56 <Sukoshi> Python is slow on my box.
07:27:00 <Sukoshi> At times.
07:27:07 <Sukoshi> My box is on the older side, so.
07:27:45 <Sukoshi> Take a look at the Computer Language Shootout results.
07:39:37 * CakeProphet doesn't trust benchmarks.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
09:26:14 -!- anonfunc has quit.
09:52:12 <CakeProphet> whjoooo
10:25:58 -!- xpika has joined.
10:26:19 -!- xpika has left (?).
11:53:48 -!- tgwizard has joined.
13:19:30 -!- tgwizard has quit (Read error: 110 (Connection timed out)).
13:48:39 <MM2> please tell me 8 first fibonacci numbers
14:27:39 -!- tgwizard has joined.
15:01:29 -!- jix has joined.
15:04:21 -!- Asztal has joined.
15:07:29 -!- Asztal has quit (Client Quit).
15:21:30 -!- oklopol has quit (Read error: 110 (Connection timed out)).
15:41:22 -!- oklopol has joined.
16:11:36 -!- oerjan has joined.
16:32:41 -!- CakeProphet has quit ("haaaaaaaaaa").
16:55:36 -!- digital_me has joined.
17:15:06 -!- CakeProphet has joined.
17:21:55 -!- CakeProphet has quit (Read error: 104 (Connection reset by peer)).
17:35:49 -!- digital_me has quit (Read error: 104 (Connection reset by peer)).
17:41:00 -!- digital_me has joined.
17:57:00 -!- digital_me_ has joined.
18:04:10 * SimonRC goes ooh:  http://www.coolopticalillusions.com/optical_illusions_pictures_3/candy_stripes.htm
18:06:05 <oerjan> cool
18:07:00 <SimonRC> There seems to be a battle going on in the high-tech language world.
18:07:37 <SimonRC> On one side, there is Lisp, with its ability to perform arbitrary transformations on program source code.
18:08:10 <SimonRC> On another side, there is Haskell, with its power of manipulating actual programs and computations.
18:08:35 * oerjan is at the moment programming Brainfuck in Haskell
18:08:40 <SimonRC> On a third side, there are the OO languages with high-powered reflection.
18:08:59 <SimonRC> oerjan: define "programming Brainfuck in Haskell"
18:09:06 <oerjan> making an interpreter
18:09:18 <pikhq> On the fourth side, there are low-level languages saying "we can do it, too!"
18:09:28 -!- digital_me has quit (Read error: 110 (Connection timed out)).
18:10:10 <oerjan> I wanted to make a brainfuck interpreter that is completely customizable as to tape size, cell value sizes and wrapping.
18:10:28 <SimonRC> LOOKIT ME I ARE USING THE VISITX0rZ-PATTEN LOLZ
18:10:37 <SimonRC> oerjan: ooh
18:10:51 -!- digital_me has joined.
18:11:19 * digital_me goes oooh too
18:11:57 <SimonRC> at my URL, not what oerjan said I hope
18:12:06 <SimonRC> unless you forgot to turn your ESP off again
18:12:09 <SimonRC> XP
18:13:07 <pikhq> Is bad for you.
18:13:21 * SimonRC is reading _Thud_ by PTerry.  Very good book, especially page 290.
18:19:05 <digital_me> SimonRC: yes, lol
18:28:44 -!- digital_me_ has quit (Connection timed out).
18:40:59 -!- sebbu has joined.
18:41:47 -!- CakeProphet has joined.
18:59:38 <SimonRC> CakeProphet: hi
19:07:15 -!- oerjan has quit ("leaving").
19:16:21 <CakeProphet> mskeg
19:16:22 <CakeProphet> Hey.
19:18:40 * SimonRC wonders what MS Keg would be if it existed.
19:20:42 <CakeProphet> hmmm
20:07:42 * SimonRC has dinner
20:23:12 -!- RodgerTheGreat has joined.
20:23:29 <RodgerTheGreat> howdy
20:55:29 <CakeProphet> aah
20:56:18 * CakeProphet is toying with new ideas on how to turn common parts of programming languages into unconvential data types.
20:56:39 <CakeProphet> Everything should be data... if it isn't, you can't manipulate it to its full potential.
20:58:05 <CakeProphet> So thinks like variable names, call stacks, evaluation stack, parse trees, and language syntax should all be expressable by data of some sort.
20:59:48 <CakeProphet> So... for example...
21:00:21 <CakeProphet> x = syntax("(")
21:00:28 <CakeProphet> y = syntax(")")
21:00:43 <CakeProphet> 2root = sqrty x 2 y
21:00:48 <CakeProphet> should yield the square root of two.
21:02:00 <CakeProphet> a weird example... but I'm sure with some tweaking to how it works you could make some interesting applications with it.
21:02:58 <CakeProphet> That would requite some interesting runtime parsing mechanics.  :P
21:03:28 <CakeProphet> Better yet... you could do it like Lisp with the quote operator.
21:03:52 <CakeProphet> and have the quote operator represent a "suspended" sytax... that isn't evaluated till later.
21:09:25 -!- Keymaker has joined.
21:09:53 <Keymaker> hello. 99 bottles of beer in underload: http://koti.mbnet.fi/~yiap/programs/underload/99.ul
21:10:14 <Keymaker> finally got around finishing this one. i'm happy about it, as it's my first program in this kind of language
21:10:32 <Keymaker> first that does something logic, that is
21:10:52 <Keymaker> my two others in underload are a quine and something that prints natural numbers in unary
21:11:03 * SimonRC returns himself.
21:11:38 <SimonRC> CakeProphet: yuk
21:11:57 <SimonRC> Thou shalt not fuck around with the parser at runtime.
21:12:16 <RodgerTheGreat> Keymaker: cool
21:12:21 <Keymaker> thanks
21:13:49 * SimonRC wonders where Underload is defined
21:14:11 <RodgerTheGreat> http://esoteric.voxelperfect.net/wiki/Underload
21:14:17 * RodgerTheGreat slaps SimonRC 
21:14:36 <RodgerTheGreat> this is why we can't have nice things
21:17:52 <SimonRC> heh
21:17:56 <SimonRC> nice
21:18:07 <CakeProphet> SimonRC, Why not  :(
21:18:27 <CakeProphet> You could assign expressions to any generic set of symbols... 
21:18:46 <CakeProphet> '[ := '(
21:18:52 <CakeProphet> Hello["World")
21:19:15 <SimonRC> I feel that changing suck things at runtime would make the language a little slow.
21:19:52 <CakeProphet> Not if you do it right
21:20:00 <SimonRC> In fact, you are almost screwing with the lexer at run-time.
21:20:19 <CakeProphet> If the language is designed for it's purposes... rather than implementing it as a bolt-on later in life... it'll be more well-suited for it.
21:20:31 <SimonRC> plus you would end up leaving large holes all over your language spec.
21:21:15 <CakeProphet> ...it's an esolang idea... it's supposed to be weird.  :P
21:21:19 <SimonRC> Lisp only gets away with it because it restricts lexer-around-with-screwing to read-time.
21:21:45 <SimonRC> You know about the lifecycle of Lisp source code, right/
21:21:46 <SimonRC> ?
21:21:50 <CakeProphet> No.
21:22:15 <SimonRC> the compiler reads a series of "forms" from each input file.
21:22:23 <SimonRC> that s called read time
21:22:51 <SimonRC> any of those forms may change the lexer.
21:22:56 <Keymaker> termination..
21:22:59 -!- Keymaker has quit.
21:23:16 <SimonRC> ah, they may only change the lexer for following forms
21:24:07 <CakeProphet> The if the lexer holds a series of states... and plugs in the proper values from these malleable state values... it would be trivial to have a lexer that can change how it parses mid-runtime.
21:24:16 <SimonRC> once the forms are read it, there is compile time, which IIRC starts with macro-expansion, which allows you to pass parts of parse trees (s-expressions) through arbitrary functions, which it handy.
21:24:28 <CakeProphet> it would most likely be an interpreted language though.
21:24:37 <SimonRC> CakeProphet: yeah, but that reduces your ability to optimise
21:24:58 <SimonRC> it prevents such fundamental optimisations as, say, *compiling* the program.
21:25:03 <CakeProphet> ...no use optimizing a interpreter/compiler that doesn't exist yet.
21:26:02 <CakeProphet> I don't care about speed.
21:43:57 -!- RodgerTheGreat_ has joined.
21:44:00 -!- RodgerTheGreat has quit (Read error: 104 (Connection reset by peer)).
21:44:13 -!- RodgerTheGreat_ has changed nick to RodgerTheGreat.
21:56:55 -!- RodgerTheGreat_ has joined.
21:57:11 <RodgerTheGreat_> motherfucking wifi
22:00:05 -!- ihope_ has joined.
22:00:15 <ihope_> Any idea how much bandwidth the esowiki uses?
22:02:42 -!- oerjan has joined.
22:04:37 <bsmntbombdood> ONE MILLION MEGABITS
22:05:04 <oerjan> ooh
22:05:40 <RodgerTheGreat_> make that ONE BILLION and you have yourself a deal
22:05:42 <ihope_> Per day?
22:05:58 <bsmntbombdood> ihope_: No, per seconds
22:05:59 <ihope_> ONE BILLION per day?
22:06:03 <ihope_> Oh.
22:06:11 <ihope_> Per how many seconds? :-P
22:06:12 <bsmntbombdood> s/second/mu second/
22:06:25 <ihope_> Still plural.
22:06:33 <bsmntbombdood> s/seconds/mu second/
22:09:08 -!- RodgerTheGreat has quit (Read error: 110 (Connection timed out)).
22:12:28 -!- RodgerTheGreat_ has quit (Remote closed the connection).
22:12:47 -!- RodgerTheGreat has joined.
22:15:07 <RodgerTheGreat> http://youtube.com/watch?v=WwylBRucU7w&mode=related&search <- lol
22:18:21 <bsmntbombdood> LOL 2 U
22:23:07 <CakeProphet> jajajaja
22:31:13 <ihope_> Is that that blender thing?
22:41:00 -!- digital_me has quit ("Lost terminal").
22:51:29 -!- RodgerTheGreat_ has joined.
22:51:46 -!- RodgerTheGreat_ has quit (Remote closed the connection).
22:52:26 -!- RodgerTheGreat has quit (Read error: 104 (Connection reset by peer)).
22:52:26 -!- RodgerTheGreat_ has joined.
23:31:08 -!- digital_me has joined.

2007-01-04:

00:01:43 -!- calamari has joined.
00:24:56 <bsmntbombdood> !ps
00:25:00 <EgoBot> 1 bsmntbombdood: ps
00:25:02 <bsmntbombdood> !ps a
00:25:06 <EgoBot> 1 bsmntbombdood: ps
00:25:13 <bsmntbombdood> !help
00:25:16 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
00:25:18 <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:25:59 -!- tgwizard has quit (Read error: 110 (Connection timed out)).
00:26:34 <bsmntbombdood> !daemon cat bf +[,.]
00:26:38 <bsmntbombdood> !cat foo
00:26:42 <EgoBot> foo
00:26:48 <bsmntbombdood> !cat bsmntbombdood 
00:26:52 <EgoBot> bsmntbombdood 
00:27:08 <bsmntbombdood> !cat bsmntbombdood 
00:27:12 <EgoBot> bsmntbombdood 
00:27:27 <CakeProphet> bf has one of the smallest Cat programs ever :P
00:27:27 <bsmntbombdood> thanks EgoBot 
00:30:40 <oerjan> There are probably some languages where the empty program is a cat.  Concatenative languages where the program is a function to turn input into output.
00:31:05 <calamari> you guys see any problem with this code?  
00:31:08 <calamari> http://rafb.net/p/GCgLp467.html
00:32:40 -!- Yoshi-kun has joined.
00:32:53 -!- Yoshi-kun has changed nick to yoshibot.
00:36:22 -!- sebbu has quit ("@+").
00:36:40 <oerjan> It does not actually null out any links, so eventually you will access an already freed node.  Or was that a rhetorical question?
00:37:11 <calamari> thanks
00:37:52 <calamari> so I should add temp = NULL;
00:38:04 <calamari> no..
00:38:53 <oerjan> Before the while loop, add a links -> prev = NULL, I think.
00:39:25 <calamari> how about     links -> next = NULL; before the free
00:39:36 <calamari> no, then I don't free the last node
00:39:38 <calamari> hrm hehe
00:39:48 <oerjan> No, it is enough to do it on as single node, before you start.
00:39:59 <oerjan> to break the circularity.
00:40:04 <oerjan> *a
00:40:07 <calamari> but I'm not using prev
00:40:13 <calamari> (at least while freeing)
00:40:22 <oerjan> But you have it available.
00:40:53 <calamari> let me think about this.. I'm sure you're right I just don't quite get it yet :)
00:40:58 <oerjan> Oh, I meant links -> prev -> next = NULL.
00:41:12 <calamari> ahh 
00:41:15 <calamari> that makes more sense :)
00:41:23 <oerjan> not sure if that's the right syntax.
00:41:28 <RodgerTheGreat_> bbl
00:41:33 -!- RodgerTheGreat_ has quit.
00:43:54 -!- oerjan has quit (Remote closed the connection).
00:44:05 -!- oerjan has joined.
00:58:20 <calamari> oerjan: seems to be right, thank you 
00:58:31 <oerjan> You're welcome.
01:04:46 -!- Sukoshi has left (?).
01:04:50 -!- Sukoshi has joined.
01:05:49 <bsmntbombdood> !cat bsmntbombdood 
01:05:53 <EgoBot> bsmntbombdood 
01:05:58 <bsmntbombdood> wtf!
01:11:41 <oerjan> you seem strangely surprised.
01:11:56 <bsmntbombdood> yeah
01:12:10 * bsmntbombdood has lost a window
01:12:32 <oerjan> let me hope it was on the computer. :)
01:13:06 <bsmntbombdood> Yeah
01:13:18 <bsmntbombdood> !cat bsmntbombdood 
01:13:21 <EgoBot> bsmntbombdood 
01:13:29 <bsmntbombdood> !cat bsmntbombdood 
01:13:33 <EgoBot> bsmntbombdood 
01:13:39 <bsmntbombdood> owtf
01:18:30 <oerjan> !daemon dog !bf +[->,----------[>,----------]<[++++++++++.<]+]
01:18:33 <EgoBot> Huh?
01:19:00 <oerjan> !daemon dog bf +[->,----------[>,----------]<[++++++++++.<]+]
01:19:10 <oerjan> !dog bsmntbombdood
01:19:34 <oerjan> !undaemon dog
01:19:37 <EgoBot> doodbmobtnmsb
01:19:38 <oerjan> !ps d
01:19:39 <EgoBot> Process 2 killed.
01:19:40 * SimonRC goes  (addictive:  http://www.ophyr.nl/flash/games/hellbound.html)
01:19:43 <EgoBot> 1 bsmntbombdood: daemon cat bf
01:19:45 <EgoBot> 2 oerjan: ps
01:20:36 <oerjan> !daemon dog bf ++++++++++[---------->,----------[>,----------]<[++++++++++.<]++++++++++.]
01:20:40 <oerjan> !dog bsmntbombdood
01:20:43 <EgoBot> doodbmobtnmsb
01:20:57 <oerjan> !dog oerjan
01:21:01 <EgoBot> najreo
01:21:10 <oerjan> :)
01:21:20 <bsmntbombdood> !dog najreo
01:21:23 <EgoBot> oerjan
01:21:57 <bsmntbombdood> !dog kcus najreo
01:21:59 <EgoBot> oerjan suck
01:22:21 <bsmntbombdood> !dog skcus najreo
01:22:25 <EgoBot> oerjan sucks
01:22:33 <oerjan> !dog rammarg ruoy seod os
01:22:37 <EgoBot> so does your grammar
01:23:17 <bsmntbombdood> !dog lol
01:23:18 <oerjan> but that bf program sucks, it is far too long.
01:23:21 <EgoBot> lol
01:33:25 -!- oklofok has joined.
01:33:26 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
01:46:42 -!- oklofok has changed nick to oklopol.
01:54:52 -!- tgwizard has joined.
01:58:21 <ihope_> !dog god!
01:58:24 <EgoBot> !dog
01:58:28 <ihope_> Not that that really... well.
01:58:51 <ihope_> !dog !dog !dog !dog god! god! god! god!
01:58:56 <EgoBot> !dog !dog !dog !dog god! god! god!
01:59:00 <ihope_> Perfect!
02:00:16 <EgoBot> !dog !dog !dog god! god! god!
02:00:28 <EgoBot> !dog !dog !dog god! god!
02:04:43 <oerjan> !ps d
02:04:46 <EgoBot> 1 bsmntbombdood: daemon cat bf
02:04:48 <EgoBot> 2 oerjan: daemon dog bf
02:04:50 <EgoBot> 3 oerjan: ps
02:05:36 <oerjan> why did it stop after 3 lines but not before?
02:06:01 <ihope_> It... what?
02:06:10 <oerjan> !dog !dog god! tac!
02:06:14 <EgoBot> !cat !dog god!
02:06:20 <EgoBot> !dog !dog god! god!
02:06:22 <bsmntbombdood> :(
02:06:36 <EgoBot> !dog god!
02:06:59 <oerjan> there the 4th line arrived.
02:07:18 <EgoBot> !dog !dog god!
02:07:30 <EgoBot> !dog god!
02:08:00 <EgoBot> !dog
02:08:02 <oerjan> it is just delaying it. _or_ someone is cheating.
02:08:04 <EgoBot> !dog
02:08:48 <oerjan> i didn't know EgoBot parsed its own output
02:09:33 <oerjan> hmm...
02:09:34 <bsmntbombdood> nice
02:11:28 -!- EgoBot has quit (Excess Flood).
02:11:36 <ihope_> Wuh oh.
02:11:39 -!- EgoBot has joined.
02:11:42 <oerjan> what happened?
02:11:43 <ihope_> Whew.
02:11:49 <oerjan> !ps d
02:11:53 <EgoBot> 1 EgoBot: daemon cat reload
02:11:54 <ihope_> !bf +[.+]
02:11:54 <EgoBot> 2 EgoBot: daemon dog reload
02:11:56 <EgoBot> 3 oerjan: ps
02:11:58 <EgoBot> <CTCP>
02:12:14 <CakeProphet> Yeah... most bots simply parse everything on the channel.
02:12:18 <bsmntbombdood> lol
02:12:21 <CakeProphet> which includes themselves.
02:12:30 <ihope_> Most bots parse themselves?
02:12:34 <bsmntbombdood> no
02:12:46 <ihope_> The PRIVMSG isn't sent back to the client.
02:12:49 <bsmntbombdood> right
02:12:51 <CakeProphet> Ah.
02:12:58 <CakeProphet> It should :P
02:13:14 <ihope_> That would cause doubling in many client, I think.
02:13:15 <CakeProphet> that would serve as a way to test if you're actually connected.
02:13:20 <ihope_> And many clients, too.
02:13:23 <ihope_> /ping ihope_
02:13:38 <CakeProphet> Well of course it would... it's the current specification to simply echo the input
02:13:53 -!- bsmnt_bot has joined.
02:14:21 -!- bsmntbombdood has left (?).
02:14:33 -!- bsmntbombdood has joined.
02:14:35 <CakeProphet> !ps
02:14:38 <EgoBot> 3 CakeProphet: ps
02:14:46 <ihope_> Also, there's the actual PING messages.
02:14:46 <CakeProphet> !daemon
02:14:53 <bsmntbombdood> ~raw PRIVMSG #esoteric :I don't see my own messages
02:14:53 <bsmnt_bot> I don't see my own messages
02:14:58 <bsmntbombdood> yep
02:15:14 <CakeProphet> I mean... for the user.
02:15:14 <bsmntbombdood> PRIVMSGing doesn't get sent back to you
02:15:27 <CakeProphet> Just echoing input creates the illusion of being connected when you're not.
02:15:33 <CakeProphet> so it's hard to tell when the stream stops.
02:15:53 <ihope_> Most clients echo, you mean?
02:15:58 <ihope_> You type it, it displays it?
02:16:35 -!- tgwizard has quit (Remote closed the connection).
02:17:39 <oerjan> perhaps gregorR explicitly sends EgoBot's output back to it to make quines possible.
02:18:10 <ihope_> GregorR do--what?
02:18:23 <bsmntbombdood> oooh I want an EgoBot quine
02:18:32 <EgoBot> testing
02:18:38 <oerjan> ah.
02:18:42 <bsmntbombdood> I can write cat in python
02:18:57 <oerjan> i am strongly starting to suspect someone cheated.
02:19:09 <ihope_> !help
02:19:13 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
02:19:15 <EgoBot> 1l 2l adjust axo bch bf{8,[16],32,64} funge93 fyb fybs glass glypho kipple lambda lazyk linguine malbolge pbrain qbf rail rhotor sadol sceql trigger udage01 unlambda whirl
02:19:34 <ihope_> Yeah, it's pretty easy to cheat.
02:19:54 <oerjan> that would certainly explain the irregular, slow response
02:20:18 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~cat .*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % x.split("~cat ")[-1]))
02:20:21 <oerjan> heh :)
02:20:24 <bsmntbombdood> ~cat foo
02:20:24 <bsmnt_bot> foo
02:20:42 <oerjan> excuse me a moment
02:20:51 -!- IrpBot has joined.
02:20:58 <bsmntbombdood> lol
02:21:13 <ihope_> !cat ~cat !cat ~cat
02:21:17 <EgoBot> ~cat !cat ~cat
02:21:17 <bsmnt_bot> !cat ~cat
02:21:20 <EgoBot> ~cat
02:21:26 <bsmntbombdood> lol
02:21:28 <ihope_> I think I know which one's faster.
02:21:31 <GregorR> Wonderful X_X
02:21:34 * bsmntbombdood grins
02:21:40 <GregorR> IrpBot: THERE'S NO IRP ALLOWED HERE, F*** OFF
02:21:40 <oerjan> !id !dog tset di!
02:21:42 <EgoBot> Huh?
02:21:46 <ihope_> !dog !dog tac~ tac~
02:21:48 <EgoBot> ~cat ~cat god!
02:21:49 <GregorR> ihope_: EgoBot is not slow, it's purposely throttled.
02:21:49 <bsmnt_bot> god!
02:22:00 <ihope_> GregorR: close enough.
02:22:04 <ihope_> Also, that didn't work.
02:22:06 <oerjan> ah wait. bug.
02:22:09 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
02:22:19 <oerjan> !raw LEAVE #esoteric
02:22:27 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~cat .*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % x.split(":~cat ")[-1]))
02:22:30 <bsmntbombdood> there
02:22:50 <oerjan> hmph.
02:22:54 <bsmntbombdood> meh I should do it the right way
02:22:56 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
02:22:59 <ihope_> GregorR: you know, if a !cat +.[+.] can kill it...
02:23:18 <oerjan> i forgot that IrpBot always writes to #irp, even if I join it here
02:23:21 <ihope_> (A !cat +[.+] can kill it too, by the way.)
02:23:54 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~cat .*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % re.compile(r"\S+ PRIVMSG #esoteric :~cat (.*)").match(x).group(0)))
02:24:01 <bsmntbombdood> ~cat ~cat foo
02:24:01 <bsmnt_bot> :bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :~cat ~cat foo
02:24:14 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
02:24:16 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~cat .*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % re.compile(r"\S+ PRIVMSG #esoteric :~cat (.*)").match(x).group(1)))
02:24:20 <bsmntbombdood> ~cat ~cat foo
02:24:20 <bsmnt_bot> ~cat foo
02:24:38 <bsmntbombdood> thar
02:24:49 <ihope_> Now, lemme think...
02:25:10 <ihope_> !dog ~cat god! tac~
02:25:13 <EgoBot> ~cat !dog tac~
02:25:13 <bsmnt_bot> !dog tac~
02:25:15 <bsmntbombdood> ~cat !cat ~cat !cat ~cat !cat ~cat !cat foo
02:25:15 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat foo
02:25:17 <EgoBot> ~cat
02:25:19 <EgoBot> ~cat !cat ~cat !cat ~cat !cat foo
02:25:19 <bsmnt_bot> !cat ~cat !cat ~cat !cat foo
02:25:20 -!- IrpBot has left (?).
02:25:23 <EgoBot> ~cat !cat ~cat !cat foo
02:25:23 <bsmnt_bot> !cat ~cat !cat foo
02:25:25 <ihope_> Whee.
02:25:27 <EgoBot> ~cat !cat foo
02:25:27 <bsmnt_bot> !cat foo
02:25:29 <bsmntbombdood> chaos ensues
02:25:31 <EgoBot> foo
02:26:21 <bsmntbombdood> ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat foo
02:26:22 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat foo
02:26:25 <EgoBot> ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat foo
02:26:25 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat foo
02:26:27 <EgoBot> ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat foo
02:26:27 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat foo
02:26:31 <EgoBot> ~cat !cat ~cat !cat ~cat !cat ~cat !cat foo
02:26:31 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat foo
02:26:33 <EgoBot> ~cat !cat ~cat !cat ~cat !cat foo
02:26:33 <bsmnt_bot> !cat ~cat !cat ~cat !cat foo
02:26:35 <EgoBot> ~cat !cat ~cat !cat foo
02:26:35 <bsmnt_bot> !cat ~cat !cat foo
02:26:37 <EgoBot> ~cat !cat foo
02:26:37 <bsmnt_bot> !cat foo
02:26:39 <EgoBot> foo
02:26:40 <ihope_> cat = badger?
02:26:50 <bsmntbombdood> yay!
02:27:06 <ihope_> ~cat ~cat ~cat
02:27:06 <bsmnt_bot> ~cat ~cat
02:27:10 <ihope_> Yay.
02:27:17 <bsmntbombdood> bsmnt_bot doesn't see its own ouput
02:27:34 <ihope_> Remember, bot-writers, send your replies with NOTICE!
02:27:58 <bsmntbombdood> ~raw NOTICE #esoteric :no
02:29:07 <ihope_> That's what the RFC says to do, after all.
02:29:38 <bsmntbombdood> nope
02:29:42 <bsmntbombdood> look at the regex
02:29:44 <ihope_> Also never automatically respond to a NOTICE.
02:30:03 <bsmntbombdood> r"\S+ PRIVMSG #esoteric :~cat .*"
02:30:12 <bsmntbombdood> PRIVMSG only
02:30:18 <ihope_> ~cat
02:30:27 <jix> ~raw NOTICE #esoteric :test
02:31:01 <ihope_> ~cat foo
02:31:02 <bsmnt_bot> foo
02:31:14 <ihope_> Just a second, eh?
02:31:15 -!- ihope_ has left (?).
02:31:25 -!- ihope_ has joined.
02:31:32 <bsmntbombdood> lol
02:31:39 <bsmntbombdood> #EsOtErIc, eh?
02:31:44 <ihope_> ~cat foo
02:31:44 <bsmnt_bot> foo
02:31:46 <ihope_> Yep.
02:31:50 <ihope_> Silly bot.
02:31:53 <bsmntbombdood> no
02:32:07 <bsmntbombdood> ircd converts all the channel names to lower case
02:32:09 <ihope_> ...I mean non-silly bot.
02:32:16 <ihope_> Or something.
02:33:51 <oerjan> ~cat !dog Testing... god! tac~ tac! tac~
02:33:51 <bsmnt_bot> !dog Testing... god! tac~ tac! tac~
02:33:55 <EgoBot> ~cat !cat ~cat !dog ...gnitseT
02:33:55 <bsmnt_bot> !cat ~cat !dog ...gnitseT
02:33:59 <EgoBot> ~cat !dog ...gnitseT
02:33:59 <bsmnt_bot> !dog ...gnitseT
02:34:03 <EgoBot> Testing...
02:34:08 <bsmntbombdood> :D
02:34:24 <bsmntbombdood> bot feedback!
02:35:20 <ihope_> sdrawkcab ,lol
02:36:03 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~loop.*", lambda x : bot.raw("PRIVMSG #esoteric :!cat ~loop"))
02:36:06 <bsmntbombdood> ~loop
02:36:07 <bsmnt_bot> !cat ~loop
02:36:09 <EgoBot> ~loop
02:36:09 <bsmnt_bot> !cat ~loop
02:36:13 <EgoBot> ~loop
02:36:13 <bsmnt_bot> !cat ~loop
02:36:17 <EgoBot> ~loop
02:36:17 <bsmnt_bot> !cat ~loop
02:36:21 <EgoBot> ~loop
02:36:21 <bsmnt_bot> !cat ~loop
02:36:25 <bsmntbombdood> lolz
02:36:25 <EgoBot> ~loop
02:36:25 <bsmnt_bot> !cat ~loop
02:36:29 <EgoBot> ~loop
02:36:29 <bsmnt_bot> !cat ~loop
02:36:32 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
02:36:33 <EgoBot> ~loop
02:37:02 <oerjan> hm...
02:37:17 <oerjan> a dangerous one:
02:38:01 <oerjan> nah wait
02:38:25 <oerjan> !help
02:38:27 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
02:38:29 <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:49:43 <oerjan> !daemon dup bf ++++[->++++++++<]>+[->,----------[>,----------]<[++++++++++<]>[.>]<[<]<.>[.>]++++++++++.[<]+]
02:49:48 <oerjan> !dup test
02:49:51 <EgoBot> *test
02:50:11 <oerjan> hm, that was rather unusual
02:50:34 <bsmntbombdood> ?
02:50:39 <oerjan> ah
02:50:46 <oerjan> !undaemon dup
02:50:49 <EgoBot> Process 3 killed.
02:51:03 <oerjan> !daemon dup bf ++++[->++++++++<]>>+[->,----------[>,----------]<[++++++++++<]>[.>]<[<]<.>[.>]++++++++++.[<]+]
02:51:12 <oerjan> !dup test
02:51:15 <EgoBot> test 
02:51:27 <bsmntbombdood> ...?
02:51:40 * oerjan sighs
02:53:38 <bsmntbombdood> ~raw PRIVMSG #esoteric :
02:53:41 <bsmntbombdood> ~raw PRIVMSG #esoteric : 
02:53:56 <bsmntbombdood> hmm
02:54:16 <oerjan> !dup test
02:54:19 <EgoBot> test
02:54:24 <oerjan> !undaemon dup
02:54:28 <EgoBot> Process 3 killed.
02:54:53 <oerjan> !daemon dup bf ++++[->++++++++<]>>+[->,----------[>,----------]<[++++++++++<]>[.>]<[<]<.>>[.>]++++++++++.[<]+]
02:55:02 <oerjan> now then
02:55:04 <oerjan> !dup test
02:55:07 <EgoBot> test test
02:55:12 <oerjan> :)
02:56:07 <oerjan> ~cat !dup test
02:56:07 <bsmnt_bot> !dup test
02:56:09 <EgoBot> test test
02:56:20 <oerjan> should i dare?
02:56:29 <oerjan> ~cat !dup ~cat !dup
02:56:29 <bsmnt_bot> !dup ~cat !dup
02:56:31 <EgoBot> ~cat !dup ~cat !dup
02:56:31 <bsmnt_bot> !dup ~cat !dup
02:56:35 <EgoBot> ~cat !dup ~cat !dup
02:56:36 <bsmnt_bot> !dup ~cat !dup
02:56:39 <EgoBot> ~cat !dup ~cat !dup
02:56:39 <bsmnt_bot> !dup ~cat !dup
02:56:43 <EgoBot> ~cat !dup ~cat !dup
02:56:44 <bsmnt_bot> !dup ~cat !dup
02:56:47 <EgoBot> ~cat !dup ~cat !dup
02:56:48 <bsmnt_bot> !dup ~cat !dup
02:56:49 <oerjan> !undaemon dup
02:56:51 <bsmntbombdood> lol
02:56:51 <EgoBot> Process 3 killed.
02:56:53 <EgoBot> ~cat !dup ~cat !dup
02:56:54 <bsmnt_bot> !dup ~cat !dup
02:56:55 <EgoBot> Huh?
02:57:06 <oerjan> !daemon dup bf ++++[->++++++++<]>>+[->,----------[>,----------]<[++++++++++<]>[.>]<[<]<.>>[.>]++++++++++.[<]+]
02:57:32 <oerjan> i believe we have an iterating quine :)
02:58:35 <bsmntbombdood> :)
02:59:31 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
03:03:00 <bsmntbombdood> ~cat naughty clever oerjan 
03:03:00 <bsmnt_bot> naughty clever oerjan
03:05:33 <CakeProphet> ~dup ah
03:05:38 <CakeProphet> ~dup ~cat ah 
03:05:49 <CakeProphet> !dup ~cat ah 
03:05:51 <EgoBot> ~cat ah  ~cat ah 
03:05:52 <bsmnt_bot> ah  ~cat ah
03:07:13 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~dup .*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % re.match(x, r"\S+ PRIVMSG #esoteric :~dup (.*)").group(1)))
03:07:17 <bsmntbombdood> ~dup foo
03:07:18 -!- bsmnt_bot has quit (Remote closed the connection).
03:07:43 <CakeProphet> !dog god!  rac! 
03:07:45 -!- bsmnt_bot has joined.
03:07:46 <EgoBot>  !car  !dog
03:07:52 <CakeProphet> !dog god!  rat! 
03:07:54 <oerjan> not quite so clever :)
03:07:56 <EgoBot>  !tar  !dog
03:08:00 <CakeProphet> "{
03:08:00 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~dup .*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % re.match(r"\S+ PRIVMSG #esoteric :~dup (.*)", x).group(1)))
03:08:04 <bsmntbombdood> ~dup foo
03:08:04 <bsmnt_bot> foo
03:08:18 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~dup .*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % re.match(r"\S+ PRIVMSG #esoteric :~dup (.*)", x).group(1)*2))
03:08:32 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
03:08:32 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
03:08:33 <CakeProphet> ~exec self.register_raw(r"
03:08:34 <CakeProphet> er..
03:08:39 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~dup .*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % re.match(r"\S+ PRIVMSG #esoteric :~dup (.*)", x).group(1)*2))
03:08:45 <bsmntbombdood> ~dup foo
03:08:45 <bsmnt_bot> fooPRIVMSG #esoteric :foo
03:08:59 <oerjan> ~cat Is this still working?
03:09:22 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~dup .*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % (re.match(r"\S+ PRIVMSG #esoteric :~dup (.*)", x).group(1))*2))
03:09:25 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
03:09:26 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~dup .*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % (re.match(r"\S+ PRIVMSG #esoteric :~dup (.*)", x).group(1))*2))
03:09:30 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
03:09:30 <bsmntbombdood> ~dup foo
03:09:30 <bsmnt_bot> fooPRIVMSG #esoteric :foo
03:09:34 <bsmntbombdood> argh
03:09:55 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
03:09:57 <oerjan> are you trying to make two lines?
03:10:02 <bsmntbombdood> no
03:10:25 <CakeProphet> You should keep all the regexes that are used in the register_raw() thing handy.
03:10:39 <CakeProphet> so you can backreference in the lambda.
03:11:07 <bsmntbombdood> yeah, not sure what a good way to do that is though
03:11:10 <oerjan> in other words but .* in a second group.
03:11:31 <CakeProphet> or better yet... make some convience function for simple commands.
03:11:34 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~dup .*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % (re.match(r"\S+ PRIVMSG #esoteric :~dup (.*)", x).group(1)*2)))
03:11:40 <bsmntbombdood> ~dup foo
03:11:40 <bsmnt_bot> foofoo
03:11:43 <bsmntbombdood> ~dup foo 
03:11:44 <bsmnt_bot> foofoo
03:12:01 <oerjan> hm...
03:12:15 <CakeProphet> !dup !dup 
03:12:18 <EgoBot> !dup  !dup 
03:12:20 <bsmntbombdood> my irc client or the irc proto strips trailing spaces
03:12:29 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
03:12:37 <CakeProphet> ~dup ~dup 
03:12:44 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~dup .*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % ((re.match(r"\S+ PRIVMSG #esoteric :~dup (.*)", x).group(1)+" ")*2)))
03:12:44 <CakeProphet> :(
03:12:48 <bsmntbombdood> ~dup foo
03:12:49 <bsmnt_bot> foo foo 
03:12:53 <bsmntbombdood> ~dup ~dup
03:12:54 <bsmnt_bot> ~dup ~dup 
03:12:54 <CakeProphet> ~dup ~dup 
03:12:54 <bsmnt_bot> ~dup ~dup 
03:12:57 <CakeProphet> :D
03:13:06 <bsmntbombdood> ~dup !dup
03:13:06 <bsmnt_bot> !dup !dup 
03:13:08 <CakeProphet> if it parsed itself... that would be a simple quine.
03:13:10 <EgoBot> !dup  !dup 
03:13:47 <bsmntbombdood> ~dup !dup ~dup
03:13:47 <bsmnt_bot> !dup ~dup !dup ~dup 
03:13:50 <EgoBot> ~dup !dup ~dup  ~dup !dup ~dup 
03:13:50 <CakeProphet> ~dup ~cat ~dup ~cat
03:13:50 <bsmnt_bot> !dup ~dup  ~dup !dup ~dup !dup ~dup  ~dup !dup ~dup 
03:13:50 <bsmnt_bot> ~cat ~dup ~cat ~cat ~dup ~cat 
03:13:54 <EgoBot> ~dup  ~dup !dup ~dup !dup ~dup  ~dup !dup ~dup  ~dup  ~dup !dup ~dup !dup ~dup  ~dup !dup ~dup 
03:13:54 <bsmnt_bot>  ~dup !dup ~dup !dup ~dup  ~dup !dup ~dup  ~dup  ~dup !dup ~dup !dup ~dup  ~dup !dup ~dup  ~dup !dup ~dup !dup ~dup  ~dup !dup ~dup  ~dup  ~dup !dup ~dup !dup ~dup  ~dup !dup ~dup 
03:14:00 <CakeProphet> hahaha
03:14:13 <bsmntbombdood> argh, leading space
03:14:17 <CakeProphet> !dup ~dup
03:14:20 <EgoBot> ~dup ~dup
03:14:20 <bsmnt_bot> ~dup ~dup 
03:14:35 <bsmntbombdood> !dup ~dup !dup
03:14:38 <EgoBot> ~dup !dup ~dup !dup
03:14:39 <bsmnt_bot> !dup ~dup !dup !dup ~dup !dup 
03:14:42 <EgoBot> ~dup !dup !dup ~dup !dup  ~dup !dup !dup ~dup !dup 
03:14:42 <bsmnt_bot> !dup !dup ~dup !dup  ~dup !dup !dup ~dup !dup !dup !dup ~dup !dup  ~dup !dup !dup ~dup !dup 
03:14:46 <EgoBot> !dup ~dup !dup  ~dup !dup !dup ~dup !dup !dup !dup ~dup !dup  ~dup !dup !dup ~dup !dup  !dup ~dup !dup  ~dup !dup !dup ~dup !dup !dup !dup ~dup !dup  ~dup !dup !dup ~dup !dup 
03:14:50 <CakeProphet> hahaha
03:14:54 <CakeProphet> love it
03:15:03 <bsmntbombdood> exponetial growth!
03:15:18 <CakeProphet> wonder what pattern it follows to stop like that.
03:15:28 <bsmntbombdood> yeah that's odd
03:15:54 <bsmntbombdood> !dup !dup ~dup !dup
03:15:58 <EgoBot> !dup ~dup !dup !dup ~dup !dup
03:16:08 <bsmntbombdood> !dup ~dup !dup !dup ~dup !dup
03:16:10 <EgoBot> ~dup !dup !dup ~dup !dup ~dup !dup !dup ~dup !dup
03:16:10 <bsmnt_bot> !dup !dup ~dup !dup ~dup !dup !dup ~dup !dup !dup !dup ~dup !dup ~dup !dup !dup ~dup !dup 
03:16:13 <CakeProphet> !dup ~dup !dup ~dup !dup
03:16:14 <EgoBot> !dup ~dup !dup ~dup !dup !dup ~dup !dup !dup !dup ~dup !dup ~dup !dup !dup ~dup !dup  !dup ~dup !dup ~dup !dup !dup ~dup !dup !dup !dup ~dup !dup ~dup !dup !dup ~dup !dup 
03:16:16 <EgoBot> ~dup !dup ~dup !dup ~dup !dup ~dup !dup
03:16:16 <bsmnt_bot> !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup 
03:16:20 <EgoBot> ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup 
03:16:20 <bsmnt_bot> !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup 
03:16:22 <EgoBot> ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !d
03:16:22 <bsmnt_bot> !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !d !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup
03:16:24 <EgoBot> ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !d !dup ~dup
03:16:24 <bsmnt_bot> !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !d !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup
03:16:25 <CakeProphet> There we go.
03:16:26 <EgoBot> !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !d !dup ~dup !dup !dup
03:16:35 <bsmntbombdood> or not
03:16:40 <CakeProphet> aha
03:16:45 <CakeProphet> it's like a cellular automaton.
03:16:54 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
03:16:55 <bsmntbombdood> ~dup !dup ~dup ~dup
03:16:55 <bsmnt_bot> !dup ~dup ~dup !dup ~dup ~dup 
03:17:00 <EgoBot> ~dup ~dup !dup ~dup ~dup  ~dup ~dup !dup ~dup ~dup 
03:17:00 <bsmnt_bot> ~dup !dup ~dup ~dup  ~dup ~dup !dup ~dup ~dup ~dup !dup ~dup ~dup  ~dup ~dup !dup ~dup ~dup 
03:17:01 <CakeProphet> hmm... I feel insipiration for an esoteric language.
03:17:03 <oerjan> if it is not to stop (apart from flooding) then there must never be two following ! or two following ~
03:17:13 <bsmntbombdood> yeah
03:17:25 <CakeProphet> !dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup
03:17:28 <EgoBot> ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup
03:17:28 <bsmnt_bot> !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup 
03:17:29 <oerjan> so the length must always be, hm, odd
03:17:32 <EgoBot> ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup  ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup 
03:17:32 <bsmnt_bot> !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup  ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup  ~dup !dup ~dup !dup ~dup ~dup 
03:17:36 <EgoBot> ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup  ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup 
03:17:36 <bsmnt_bot> !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup  ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~
03:17:40 <EgoBot> ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup  ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup 
03:17:40 <bsmnt_bot> ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup  ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup !dup ~dup ~dup ~
03:17:46 <CakeProphet> hmmm..
03:17:47 <bsmntbombdood> and fail
03:17:54 <bsmntbombdood> oerjan: But it can't be
03:18:07 <CakeProphet> There should be an esolang based off of this.
03:18:15 <CakeProphet> two interpreters that interpreter the output of each other.
03:18:43 <oerjan> there's a proof then.
03:18:44 <bsmntbombdood> brainfuck-brainfuck?
03:19:35 <oerjan> and of course with incompatible languages
03:19:40 <CakeProphet> !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup 
03:19:42 -!- puzzlet has joined.
03:19:44 <bsmntbombdood> interpert the program, recurse untill there are no brainfuck chars left
03:19:44 <EgoBot> ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup 
03:19:44 <bsmnt_bot> !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup 
03:19:48 <EgoBot> ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup 
03:19:48 <bsmnt_bot> !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !
03:19:52 <EgoBot> ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~
03:19:52 <bsmnt_bot> !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~ !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup
03:19:56 <EgoBot> ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~ !dup ~dup
03:19:56 <bsmnt_bot> !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~ !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup
03:20:00 <EgoBot> ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~ !dup ~dup !dup ~dup
03:20:00 <bsmnt_bot> !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~ !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup
03:20:04 <EgoBot>  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup  ~dup !dup ~dup !dup ~dup !dup ~dup !dup ~dup !dup !dup ~dup !dup ~ !dup ~dup !dup ~dup !dup  ~du
03:20:18 <CakeProphet> That might have been it :D
03:20:21 <oerjan> what i wonder is if it is possible to get a dog in there.
03:21:15 <bsmntbombdood> of course, any valid brainfuck program is the same in brainfuck-brainfuck, so it's boring
03:21:42 <CakeProphet> ~dup !dup ~dog  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud 
03:21:42 <bsmnt_bot> !dup ~dog  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud !dup ~dog  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud 
03:21:46 <EgoBot> ~dog  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud !dup ~dog  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud  ~dog  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud !dup ~dog  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud 
03:21:56 <CakeProphet> aw...
03:22:23 <CakeProphet> ~dup !dup ~dup !dog ~pud  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud 
03:22:23 <bsmnt_bot> !dup ~dup !dog ~pud  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud !dup ~dup !dog ~pud  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud 
03:22:26 <EgoBot> ~dup !dog ~pud  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud !dup ~dup !dog ~pud  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud  ~dup !dog ~pud  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud !dup ~dup !dog ~pud  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud 
03:22:26 <bsmnt_bot> !dog ~pud  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud !dup ~dup !dog ~pud  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud  ~dup !dog ~pud  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud !dup ~dup !dog ~pud  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud !dog ~pud  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud !dup ~dup !dog ~pud  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud  ~dup !dog ~pud  !pud ~pud !pud ~pud !pud ~pud !pud ~pud !pud !dup ~dup !dog ~pud  !p
03:22:30 <EgoBot> p!  dup~ god! pud~ pud! dup! dup~ dup! dup~ dup! dup~ dup! dup~ dup!  dup~ god! pud~  dup! dup~ dup! dup~ dup! dup~ dup! dup~ dup!  dup~ god! pud~ pud! dup! dup~ dup! dup~ dup! dup~ dup! dup~ dup!  dup~ god! dup! dup~ dup! dup~ dup! dup~ dup! dup~ dup!  dup~ god! pud~ pud! dup! dup~ dup! dup~ dup! dup~ dup! dup~ dup!  dup~ god! pud~  dup! dup~ dup! dup~ dup! dup~ dup! dup~ dup! 
03:22:36 <bsmntbombdood> p!!!!!!!!!!1
03:23:19 <CakeProphet> ~dup !dup ~dup !dog ~pud  !pud ~pud !pud pud~ pud! pud~ pud! pud~ pud! 
03:23:20 <bsmnt_bot> !dup ~dup !dog ~pud  !pud ~pud !pud pud~ pud! pud~ pud! pud~ pud! !dup ~dup !dog ~pud  !pud ~pud !pud pud~ pud! pud~ pud! pud~ pud! 
03:23:23 <oerjan> stripped for being too long
03:23:24 <EgoBot> ~dup !dog ~pud  !pud ~pud !pud pud~ pud! pud~ pud! pud~ pud! !dup ~dup !dog ~pud  !pud ~pud !pud pud~ pud! pud~ pud! pud~ pud!  ~dup !dog ~pud  !pud ~pud !pud pud~ pud! pud~ pud! pud~ pud! !dup ~dup !dog ~pud  !pud ~pud !pud pud~ pud! pud~ pud! pud~ pud! 
03:23:24 <bsmnt_bot> !dog ~pud  !pud ~pud !pud pud~ pud! pud~ pud! pud~ pud! !dup ~dup !dog ~pud  !pud ~pud !pud pud~ pud! pud~ pud! pud~ pud!  ~dup !dog ~pud  !pud ~pud !pud pud~ pud! pud~ pud! pud~ pud! !dup ~dup !dog ~pud  !pud ~pud !pud pud~ pud! pud~ pud! pud~ pud! !dog ~pud  !pud ~pud !pud pud~ pud! pud~ pud! pud~ pud! !dup ~dup !dog ~pud  !pud ~pud !pud pud~ pud! pud~ pud! pud~ pud!  ~dup !dog ~pud  !pud ~pud !pud pud~ pud! pud~ pud! pud~ pud! !dup ~dup !dog ~pud  !p
03:23:28 <EgoBot> p!  dup~ god! pud~ pud! !dup ~dup !dup ~dup !dup ~dup dup! dup~ dup!  dup~ god! pud~  !dup ~dup !dup ~dup !dup ~dup dup! dup~ dup!  dup~ god! pud~ pud! !dup ~dup !dup ~dup !dup ~dup dup! dup~ dup!  dup~ god! !dup ~dup !dup ~dup !dup ~dup dup! dup~ dup!  dup~ god! pud~ pud! !dup ~dup !dup ~dup !dup ~dup dup! dup~ dup!  dup~ god! pud~  !dup ~dup !dup ~dup !dup ~dup dup! dup~ dup! 
03:23:33 <CakeProphet> p!
03:23:37 <bsmntbombdood> ~dup !dog !god pud~ 
03:23:37 <bsmnt_bot> !dog !god pud~ !dog !god pud~ 
03:23:40 <EgoBot>  ~dup dog! god! ~dup dog!
03:23:45 <CakeProphet> Maybe the occurance of a p! is what causes something to happen.
03:24:04 <bsmntbombdood> arg, the spaces
03:24:05 <CakeProphet> If an interpreter halts on p!  ...something changes... but the input alters in some way as well.
03:24:14 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
03:24:59 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~dup\s+.*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % ((re.match(r"\S+ PRIVMSG #esoteric :~dup\s+(.*)", x).group(1)+" ")*2)))
03:25:00 <oerjan> nothing wrong about the spaces, the double ones were put in at the start
03:25:06 <bsmntbombdood> we can cheat
03:25:14 <oerjan> but there is no need
03:25:18 <bsmntbombdood> ~dup !dog !god pud~
03:25:18 <bsmnt_bot> !dog !god pud~ !dog !god pud~ 
03:25:22 <EgoBot>  ~dup dog! god! ~dup dog!
03:25:40 <bsmntbombdood> oerjan: huh?
03:25:43 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
03:25:55 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~dup .*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % ((re.match(r"\S+ PRIVMSG #esoteric :~dup (.*)", x).group(1)+" ")*2)))
03:26:00 <bsmntbombdood> there, no spaces
03:26:05 <oerjan> ah, you multiply and get a space at the end
03:26:17 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
03:26:22 <oerjan> ~dup !dog test
03:26:26 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~dup .*", lambda x : bot.raw("PRIVMSG #esoteric :%s" % ((re.match(r"\S+ PRIVMSG #esoteric :~dup (.*)", x).group(1)+" ")*2).strip()))
03:26:42 <oerjan> ~dup !dog test
03:26:42 <bsmnt_bot> !dog test !dog test
03:26:46 <EgoBot> tset god! tset
03:26:48 <bsmntbombdood> wow that's some UGLY code
03:27:50 <oerjan> you definitely need to put a function in your bot to pick just the part after the colon.
03:28:14 <bsmntbombdood> But that is going to be different 
03:28:30 <bsmntbombdood> depending on PRIVMSG, NOTICE, whatever
03:28:57 <oerjan> i don't mean for the initial regex, but for convenience in the remaining part
03:29:33 <bsmntbombdood> What should I call it?
03:29:54 <CakeProphet> hmm...
03:29:55 <oerjan> in IrpBot it's called clean
03:30:02 <CakeProphet> if you had three interpreters with different symnols for different commands.
03:30:05 <bsmntbombdood> privmsg_message?
03:30:16 <oerjan> one of the functions defined by the code i snatched
03:30:52 <oerjan> or just message. it could be convenient for the others too.
03:32:32 <bsmntbombdood> ~quit update
03:32:32 -!- bsmnt_bot has quit ("update").
03:32:37 -!- bsmnt_bot has joined.
03:33:00 <bsmntbombdood> sample
03:33:14 <bsmntbombdood> ~exec print message(":bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :sample")
03:33:39 <bsmntbombdood> oops conflict
03:33:53 -!- bsmnt_bot has quit (Remote closed the connection).
03:33:56 -!- bsmnt_bot has joined.
03:34:02 -!- bsmnt_bot has quit (Remote closed the connection).
03:34:10 <bsmntbombdood> ~exec print get_message(":bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :sample")
03:34:16 -!- ihope_ has quit (Operation timed out).
03:34:20 -!- bsmnt_bot has joined.
03:34:23 <bsmntbombdood> ~exec print get_message(":bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :sample")
03:34:26 <bsmntbombdood> good
03:34:30 <bsmntbombdood> ~exec print get_message(":bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :sample:sample")
03:34:36 <bsmntbombdood> good
03:36:34 <bsmntbombdood> 3 lines of code
03:38:06 <bsmntbombdood> ~exec __import__("time").sleep(60)
03:38:18 <bsmntbombdood> ~raw PRIVMSG #esoteric :foo
03:38:22 <CakeProphet> hmmm..
03:38:32 <bsmntbombdood> I should put execs in their own thread
03:38:32 <CakeProphet> the formula for number of dups each run is.
03:38:39 <CakeProphet> (2d) - 1
03:38:41 <CakeProphet> so...
03:38:48 <CakeProphet> I don't think it would spawn infinitely...
03:39:07 <bsmnt_bot> foo
03:39:16 <bsmntbombdood> ABOUT TIME! :P
03:39:33 <bsmntbombdood> I bet I could make it SendQ out
03:39:38 <bsmntbombdood> ~exec __import__("time").sleep(120)
03:39:59 <CakeProphet> actually...
03:40:09 <CakeProphet> 2(d-1)
03:40:15 <CakeProphet> obviously.  :P
03:42:32 <bsmntbombdood> or not
03:43:56 * bsmntbombdood puts in threads
03:46:20 <bsmntbombdood> ~quit bsmntbombdood is leet
03:46:21 -!- bsmnt_bot has quit ("bsmntbombdood is leet").
03:46:55 <bsmntbombdood> stupid python lambdas
03:47:40 <NK`> do you guys know how is done an modulo in assembly language
03:47:43 <NK`> I means
03:47:51 -!- bsmnt_bot has joined.
03:47:57 <bsmntbombdood> ~exec __import__("time").sleep(120)
03:47:57 -!- bsmnt_bot has quit (Remote closed the connection).
03:48:01 <NK`> how gcc translate a modulo 
03:48:16 <bsmntbombdood> NK`: Use the -S option and find out
03:48:38 <NK`> and is it the best for telling if a division 
03:48:39 -!- bsmnt_bot has joined.
03:48:42 <bsmntbombdood> ~exec __import__("time").sleep(120)
03:48:43 -!- bsmnt_bot has quit (Remote closed the connection).
03:48:48 <NK`> is how do you say "right"
03:49:00 <NK`> I mean enclydienne
03:49:14 <NK`> euclydien
03:49:29 <NK`> euclidien* sorry
03:49:37 <NK`> bsmntbombdood: I was thinking about it
03:49:42 <NK`> I'm going into
03:50:20 -!- bsmnt_bot has joined.
03:50:22 <bsmntbombdood> ~exec __import__("time").sleep(120)
03:50:34 <bsmntbombdood> ~raw PRIVMSG #esoteric :yay, threads
03:50:35 <bsmnt_bot> yay, threads
03:50:37 <bsmntbombdood> yay
03:50:43 <oerjan> ~dup test
03:50:47 <oerjan> !dup test
03:50:51 <EgoBot> test test
03:51:01 <oerjan> ~cat test
03:51:08 <bsmntbombdood> Those commands don't persist
03:55:13 <NK`> idivl   -8(%ebp)
03:55:13 <NK`>         movl    %edx, %eax
03:55:13 <NK`>         movl    %eax, c
03:57:26 <NK`> !I think it 's optimized
03:57:29 <EgoBot> Huh?
03:58:47 <calamari> I wish I knew whether these bugs were due to c or the ipod .. hehe
03:59:46 <bsmntbombdood> great regex: r"^:(?P<nick>\S+)!(?P<ident>\S+)@(?P<host>\S+) (?P<command>\S+) (?P<channel>\S+) :(?P<message>.*)"
04:03:30 <bsmntbombdood> ~quit more code
04:03:30 -!- bsmnt_bot has quit ("more code").
04:03:34 -!- bsmnt_bot has joined.
04:03:58 <bsmntbombdood> ~exec print message
04:04:24 <bsmntbombdood> hmm
04:04:40 <bsmntbombdood> ~exec print self.get_message(":bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :hmm")
04:04:48 <bsmntbombdood> crap
04:04:56 <bsmntbombdood> threading introduces scope problems
04:11:59 -!- bsmnt_bot has quit (Remote closed the connection).
04:12:03 -!- bsmnt_bot has joined.
04:12:13 <bsmntbombdood> ~exec print locals(),globals()
04:12:59 <bsmntbombdood> ~exec print self
04:13:04 <bsmntbombdood> urgh
04:13:58 -!- bsmnt_bot has quit (Remote closed the connection).
04:14:02 -!- bsmnt_bot has joined.
04:14:06 <bsmntbombdood> ~exec print self
04:14:13 <bsmntbombdood> what. the. fuck
04:14:53 -!- bsmnt_bot has quit (Remote closed the connection).
04:15:04 -!- bsmnt_bot has joined.
04:15:05 <bsmntbombdood> ~exec print self
04:15:10 <bsmntbombdood> THERE
04:15:21 <bsmntbombdood> ~exec print locals(),globals()
04:15:58 <bsmntbombdood> ~exec __import__("pprint").pprint([locals(),globals()])
04:17:13 -!- bsmnt_bot has quit (Remote closed the connection).
04:17:35 -!- bsmnt_bot has joined.
04:18:07 <bsmntbombdood> ~exec print self.get_message(message)
04:18:12 <bsmntbombdood> GOOOOD
04:18:54 <bsmntbombdood> ~exec import time
04:18:59 <bsmntbombdood> ~exec print time
04:19:03 <bsmntbombdood> or not
04:26:36 -!- CakeProphet has quit (Read error: 113 (No route to host)).
05:32:17 * pikhq consideres a rewrite for !dog
05:34:52 <bsmntbombdood> wtf, python strings don't have a reverse method
05:35:31 <pikhq> ++++++++++[[>+<-]>[>,----------]<[++++++++++.<]++++++++++.]
05:35:43 <pikhq> Not much shorter, but hey; it's a start.
05:36:20 <pikhq> . . .
05:36:38 <pikhq> ++++++++++[[>-<-]>[>,----------]<[++++++++++.<]++++++++++.]
05:36:47 <pikhq> ++++++++++[[>-<-],>[>,----------]<[++++++++++.<]++++++++++.] even
05:36:57 <pikhq> ++++++++++[[>-<-]>,[>,----------]<[++++++++++.<]++++++++++.] even
05:36:58 * pikhq sucks
05:47:46 <bsmntbombdood> ~exec x=1
05:47:48 <bsmntbombdood> !print x
05:47:51 <EgoBot> Huh?
05:47:55 <bsmntbombdood> ~exec print x
05:48:13 <bsmntbombdood> ~~~~~~~~~~~~~~~~~~~~~~
05:50:18 <pikhq> !daemon dup bf ++++[->++++++++<]>>+[->,----------[>,----------]<[++++++++++<]>[.>]<[<]<.>>[.>]++++++++++.[<]+]
05:51:21 <pikhq> !cat ~cat !dup ~cat !dup
05:51:23 <EgoBot> ~cat !dup ~cat !dup
05:51:34 * pikhq watches the bots go boom
05:51:59 <pikhq> !cat !cat
05:52:00 <bsmntbombdood> ~exec self.register_raw(r"^\S+ PRIVMSG #esoteric :~cat (.*)", lambda x : bot.raw("PRIVMSG #esoteric :%s" % re.compile(r"^\S+ PRIVMSG #esoteric :~cat (.*)").match(x).group(1)))
05:52:01 <EgoBot> !cat
05:52:06 <bsmntbombdood> ~cat foo
05:52:07 -!- bsmnt_bot has quit (Remote closed the connection).
05:52:12 <pikhq> LMAO
05:52:15 -!- bsmnt_bot has joined.
05:52:21 <bsmntbombdood> ~exec self.register_raw(r"^\S+ PRIVMSG #esoteric :~cat (.*)", lambda x : self.raw("PRIVMSG #esoteric :%s" % re.compile(r"^\S+ PRIVMSG #esoteric :~cat (.*)").match(x).group(1)))
05:52:25 <bsmntbombdood> ~cat foo
05:52:25 -!- bsmnt_bot has quit (Remote closed the connection).
05:52:28 <bsmntbombdood> fuck
05:52:49 <bsmntbombdood> threading ~exec's messes up scope
05:53:02 -!- bsmnt_bot has joined.
05:53:28 -!- bsmnt_bot has quit (Remote closed the connection).
05:53:39 -!- bsmnt_bot has joined.
05:53:48 <bsmntbombdood> ~exec self.THREADING = False
05:54:11 <pikhq> !cat ~cat !dup ~cat !dup
05:54:15 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % self.THREADING)
05:54:15 <bsmnt_bot> False
05:54:15 <EgoBot> ~cat !dup ~cat !dup
05:54:18 <bsmntbombdood> ~exec self.register_raw(r"^\S+ PRIVMSG #esoteric :~cat (.*)", lambda x : self.raw("PRIVMSG #esoteric :%s" % re.compile(r"^\S+ PRIVMSG #esoteric :~cat (.*)").match(x).group(1)))
05:54:25 <bsmntbombdood> ~cat foo
05:54:25 -!- bsmnt_bot has quit (Remote closed the connection).
05:54:26 <pikhq> !cat ~cat !dup ~cat !dup
05:54:29 <EgoBot> ~cat !dup ~cat !dup
05:54:31 <pikhq> Victory?
05:54:33 <bsmntbombdood> ~exec self.THREADING = False
05:54:33 -!- bsmnt_bot has joined.
05:54:40 <bsmntbombdood> ~exec self.register_raw(r"^\S+ PRIVMSG #esoteric :~cat (.*)", lambda x : bot.raw("PRIVMSG #esoteric :%s" % re.compile(r"^\S+ PRIVMSG #esoteric :~cat (.*)").match(x).group(1)))
05:54:42 <pikhq> I don't think that works.
05:54:44 <bsmntbombdood> ~cat foo
05:54:44 <bsmnt_bot> foo
05:54:47 <pikhq> !cat ~cat !dup ~cat !dup
05:54:50 <pikhq> Finally.
05:54:52 <EgoBot> ~cat !dup ~cat !dup
05:54:52 <bsmnt_bot> !dup ~cat !dup
05:54:55 <EgoBot> ~cat !dup ~cat !dup
05:54:56 <bsmnt_bot> !dup ~cat !dup
05:54:59 <EgoBot> ~cat !dup ~cat !dup
05:55:00 <bsmnt_bot> !dup ~cat !dup
05:55:03 <EgoBot> ~cat !dup ~cat !dup
05:55:04 <bsmnt_bot> !dup ~cat !dup
05:55:07 <EgoBot> ~cat !dup ~cat !dup
05:55:08 <bsmnt_bot> !dup ~cat !dup
05:55:10 <pikhq> !undaemon dup
05:55:11 <EgoBot> ~cat !dup ~cat !dup
05:55:12 <bsmnt_bot> !dup ~cat !dup
05:55:13 <EgoBot> Process 4 killed.
05:55:15 <EgoBot> Huh?
05:55:27 <pikhq> Fun stuff, oerjan.
05:55:54 <bsmntbombdood> indeed
05:56:04 <pikhq> :)
05:58:50 -!- digital_me has quit ("night").
06:01:39 <bsmntbombdood> I can't get scoping right
06:02:01 -!- bsmnt_bot has quit (Remote closed the connection).
06:02:05 -!- bsmnt_bot has joined.
06:02:18 <bsmntbombdood> ~exec print self
06:02:26 <bsmntbombdood> ~exec print bot
06:02:32 <bsmntbombdood> ~exec print re
06:02:46 <bsmntbombdood> ~exec print globals()
06:03:07 -!- bsmnt_bot has quit (Remote closed the connection).
06:03:13 -!- bsmnt_bot has joined.
06:03:15 <bsmntbombdood> ~exec print self
06:03:19 <bsmntbombdood> ~exec print bot
06:03:23 <bsmntbombdood> hmmm
06:05:14 <bsmntbombdood> dumb bot
07:05:11 -!- oerjan has quit ("Good night").
07:09:46 <bsmntbombdood> ~raw privmsg #esoteric :foo
07:09:46 <bsmnt_bot> foo
07:21:07 -!- calamari has quit ("Leaving").
07:46:40 <Sukoshi> Aye. I hate it when I reach crossroads of program and programmer efficiency .
07:58:08 <pikhq> me need sleep
07:58:16 -!- pikhq has quit ("leaving").
07:58:23 <bsmntbombdood> sleep is for the weak
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:02:12 <Sukoshi> Yes it is.
11:40:25 -!- tgwizard has joined.
13:13:39 -!- mtve has quit (Read error: 110 (Connection timed out)).
14:00:50 -!- ihope_ has joined.
14:00:55 -!- ihope_ has changed nick to ihope.
14:58:48 -!- nemesis128 has joined.
15:02:06 -!- nemesis128 has left (?).
15:52:01 -!- jix has joined.
15:57:59 -!- digital_me has joined.
16:20:54 -!- ihope_ has joined.
16:37:03 -!- ihope has quit (Connection timed out).
17:08:31 -!- oerjan has joined.
17:09:29 -!- oklofok has joined.
17:09:42 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
17:09:42 -!- FabioNET has joined.
17:24:05 -!- ihope_ has quit (Connection timed out).
17:42:45 -!- ihope_ has joined.
17:42:53 -!- ihope_ has changed nick to ihope.
17:44:24 * SimonRC grins at the bot pong above
18:18:09 <ihope> !dup foo
18:18:14 <EgoBot> Huh?
18:18:16 <ihope> !ps d
18:18:19 <EgoBot> 1 EgoBot: daemon cat reload
18:18:22 <EgoBot> 2 EgoBot: daemon dog reload
18:18:23 <EgoBot> 3 oerjan: daemon dup bf
18:18:25 <EgoBot> 4 ihope: ps
18:19:26 <ihope> If dup is a daemon...
18:19:49 <ihope> !dup !dup
18:19:51 <EgoBot> Huh?
18:20:02 <ihope> Unless !dup outputs "Huh?"
18:20:45 <ihope> !undaemon dup
18:20:48 <ihope> !daemon dup bf ++++[->++++++++<]>>+[->,----------[>,----------]<[++++++++++<]>[.>]<[<]<.>>[.>]++++++++++.[<]+]
18:20:53 <ihope> !dup Grah
18:20:55 <EgoBot> Grah Grah
18:21:02 <ihope> Woot Woot.
18:21:26 <ihope> !dup ~cat !dup
18:21:29 <EgoBot> ~cat !dup ~cat !dup
18:21:43 <ihope> I see ~cat is not catting.
18:23:46 <ihope> ~cat !dup ~cat !dup
18:24:03 <ihope> I see ~cat is still not catting.
18:36:44 -!- oerjan has quit ("Out of the house").
18:43:51 -!- tgwizard has quit (Read error: 110 (Connection timed out)).
18:54:30 <bsmntbombdood> ~print [(i[0].pattern, i[1].__name__) for i in self.raw_regex_queue]
18:54:36 <bsmntbombdood> ~exec print [(i[0].pattern, i[1].__name__) for i in self.raw_regex_queue]
18:54:48 <bsmntbombdood> ~exec print [(i[0].pattern, i[1].__name__) for i in bot.raw_regex_queue]
18:56:55 -!- bsmnt_bot has quit (Remote closed the connection).
18:57:01 -!- bsmnt_bot has joined.
18:57:09 <bsmntbombdood> ~exec self.print_callbacks()
18:57:22 <bsmntbombdood> pretty
19:00:03 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~cat (.*)", lambda x : bot.raw("PRIVMSG #esoteric :%s" % re.compile(r"\S+ PRIVMSG #esoteric :~cat (.*)").match(x).group(1)))
19:00:07 <bsmntbombdood> ~cat cat
19:00:07 <bsmnt_bot> cat
19:00:13 <bsmntbombdood> ihope: ~cat now cats
19:00:39 <ihope> ~cat !dup ~cat !dup
19:00:39 <bsmnt_bot> !dup ~cat !dup
19:00:43 <EgoBot> ~cat !dup ~cat !dup
19:00:43 <bsmnt_bot> !dup ~cat !dup
19:00:47 <EgoBot> ~cat !dup ~cat !dup
19:00:47 <bsmnt_bot> !dup ~cat !dup
19:00:51 <EgoBot> ~cat !dup ~cat !dup
19:00:51 <bsmnt_bot> !dup ~cat !dup
19:00:53 <EgoBot> ~cat !dup ~cat !dup
19:00:53 <bsmnt_bot> !dup ~cat !dup
19:00:55 <bsmntbombdood> ~exec self.print_callbacks()
19:00:59 <EgoBot> ~cat !dup ~cat !dup
19:00:59 <bsmnt_bot> !dup ~cat !dup
19:01:03 <EgoBot> Huh?
19:01:09 <ihope> Fun.
19:02:51 -!- tgwizard has joined.
19:06:44 -!- bsmnt_bot has quit (Remote closed the connection).
19:06:47 -!- bsmnt_bot has joined.
19:07:36 <bsmntbombdood> ~exec print inspect.getargspec(self.do_exec)
19:10:58 <bsmntbombdood> ~exec print inspect.ismethod(self)
19:11:03 <bsmntbombdood> ~exec print inspect.ismethod(self.do_exec)
19:11:11 <bsmntbombdood> ~exec print inspect.ismethod(lambda x : x)
19:14:05 -!- RodgerTheGreat has joined.
19:14:10 <RodgerTheGreat> hi
19:15:26 <bsmntbombdood> hi
19:15:35 -!- bsmnt_bot has quit (Remote closed the connection).
19:15:39 -!- bsmnt_bot has joined.
19:16:46 <bsmntbombdood> ~exec self.register_raw(r".*:~test (.*)", lambda x, y : bot.raw("PRIVMSG #esoteric :%r, %r" % (x,y)))
19:16:51 <bsmntbombdood> ~test 
19:17:16 <bsmntbombdood> ~test foo
19:17:17 <bsmnt_bot> ':bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :~test foo', <_sre.SRE_Match object at 0xb7c0c620>
19:17:44 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
19:17:54 <bsmntbombdood> ~exec self.register_raw(r".*:~test (.*)", lambda x : bot.raw("PRIVMSG #esoteric :%r" % (x)))
19:17:58 <bsmntbombdood> ~test foo
19:17:58 <bsmnt_bot> ':bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :~test foo'
19:18:02 <bsmntbombdood> yay
19:18:19 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
19:18:31 <bsmntbombdood> ~exec self.print_callbacks()
19:19:31 <bsmntbombdood> ~exec self.register_raw("\S+ PRIVMSG #esoteric :~cat (.*)", lambda x,y: bot.raw("PRIVMSG #esoteric :%s" % y.group(1)))
19:19:34 <bsmntbombdood> ~cat foo
19:19:35 <bsmnt_bot> foo
19:20:03 <bsmntbombdood> now the regex for the callback is given to it
19:22:48 <bsmntbombdood> with some uglyness to allow the callbacks to take only one argument
19:39:53 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~dup (.*)", lambda x,y: bot.raw("PRIVMSG #esoteric :%s %s" % (y.group(1), y.group(1))))
19:39:58 <bsmntbombdood> ~dup foo
19:39:59 <bsmnt_bot> foo foo
19:40:05 <bsmntbombdood> ~dup !cat ~dup
19:40:05 <bsmnt_bot> !cat ~dup !cat ~dup
19:40:08 <EgoBot> ~dup !cat ~dup
19:40:08 <bsmnt_bot> !cat ~dup !cat ~dup
19:40:10 <EgoBot> ~dup !cat ~dup
19:40:10 <bsmnt_bot> !cat ~dup !cat ~dup
19:40:12 <EgoBot> ~dup !cat ~dup
19:40:12 <bsmnt_bot> !cat ~dup !cat ~dup
19:40:14 <EgoBot> ~dup !cat ~dup
19:40:14 <bsmnt_bot> !cat ~dup !cat ~dup
19:40:16 <EgoBot> ~dup !cat ~dup
19:40:17 <bsmnt_bot> !cat ~dup !cat ~dup
19:40:18 <EgoBot> ~dup !cat ~dup
19:40:18 <bsmnt_bot> !cat ~dup !cat ~dup
19:40:22 <EgoBot> ~dup !cat ~dup
19:40:22 <bsmnt_bot> !cat ~dup !cat ~dup
19:40:26 <EgoBot> ~dup !cat ~dup
19:40:26 <bsmnt_bot> !cat ~dup !cat ~dup
19:40:30 <EgoBot> ~dup !cat ~dup
19:40:30 <bsmnt_bot> !cat ~dup !cat ~dup
19:40:34 <EgoBot> ~dup !cat ~dup
19:40:34 <bsmnt_bot> !cat ~dup !cat ~dup
19:40:37 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
19:40:39 <EgoBot> ~dup !cat ~dup
19:40:50 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~dup (.*)", lambda x,y: bot.raw("PRIVMSG #esoteric :%s %s" % (y.group(1), y.group(1))))
19:41:11 <bsmntbombdood> ~dup !dup ~dup
19:41:11 <bsmnt_bot> !dup ~dup !dup ~dup
19:41:14 <EgoBot> Huh?
19:41:29 <bsmntbombdood> huh?
19:41:35 <bsmntbombdood> !ps a
19:41:38 <EgoBot> 4 bsmntbombdood: ps
19:41:49 <bsmntbombdood> !daemon dup bf ++++[->++++++++<]>>+[->,----------[>,----------]<[++++++++++<]>[.>]<[<]<.>>[.>]++++++++++.[<]+]
19:41:56 <bsmntbombdood> ~dup !dup ~dup
19:41:56 <bsmnt_bot> !dup ~dup !dup ~dup
19:41:58 <EgoBot> ~dup !dup ~dup ~dup !dup ~dup
19:41:58 <bsmnt_bot> !dup ~dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup
19:42:00 <EgoBot> ~dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup
19:42:00 <bsmnt_bot> ~dup !dup ~dup !dup ~dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup
19:42:07 <bsmntbombdood> :(
19:42:16 <bsmntbombdood> !dog
19:42:43 <bsmntbombdood> !dog !god pud~
19:42:46 <EgoBot> ~dup dog!
19:42:46 <bsmnt_bot> dog! dog!
19:42:55 <bsmntbombdood> !dog god! pud~
19:42:58 <EgoBot> ~dup !dog
19:42:58 <bsmnt_bot> !dog !dog
19:43:02 <EgoBot> god!
19:43:07 <bsmntbombdood> lol
19:43:41 <bsmntbombdood> ~dup !dog pud~
19:43:42 <bsmnt_bot> !dog pud~ !dog pud~
19:43:44 <EgoBot> ~dup god! ~dup
19:43:44 <bsmnt_bot> god! ~dup god! ~dup
19:43:57 <bsmntbombdood> ~dup dog! pud~
19:43:57 <bsmnt_bot> dog! pud~ dog! pud~
19:45:28 * SimonRC wibbles:   http://video.google.com/videoplay?docid=-4024457809967804989&hl=en
19:45:34 <bsmntbombdood> !dog !dog god! pud~
19:45:38 <EgoBot> ~dup !dog god!
19:45:38 <bsmnt_bot> !dog god! !dog god!
19:45:42 <EgoBot> !dog god! !dog
19:46:45 <bsmntbombdood> !bf_txtgen ~dup !dup ~dup
19:47:33 <EgoBot> 116 ++++++++++++++[>+++++++++>+++++++>++++++++>++<<<<-]>.>++.<---------.>>.>++++.+.<<.<.>>.>-.<++++++++++++++.<.<.-----. [171]
19:47:47 <bsmntbombdood> !daemon foo bf ++++++++++++++[>+++++++++>+++++++>++++++++>++<<<<-]>.>++.<---------.>>.>++++.+.<<.<.>>.>-.<++++++++++++++.<.<.-----.
19:47:50 <EgoBot> ~dup !dup ~dup
19:47:50 <bsmnt_bot> !dup ~dup !dup ~dup
19:47:54 <EgoBot> ~dup !dup ~dup ~dup !dup ~dup
19:47:54 <bsmnt_bot> !dup ~dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup
19:47:58 <EgoBot> ~dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup
19:47:58 <bsmnt_bot> ~dup !dup ~dup !dup ~dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup ~dup ~dup !dup ~dup !dup ~dup ~dup !dup ~dup
19:48:04 <bsmntbombdood> !foo
19:48:25 <bsmntbombdood> meh
19:49:42 <bsmntbombdood> ~exec print message
19:50:28 <bsmntbombdood> ~exec print self.message_re.match(message).group("message")
19:51:42 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~quine(.*)", lambda x : bot.raw("PRIVMSG #esoteric :%s" % bot.message_re.match(x).group("message")))
19:51:46 <bsmntbombdood> ~quine
19:51:46 <bsmnt_bot> ~quine
19:51:49 <bsmntbombdood> ~quine foo
19:51:49 <bsmnt_bot> ~quine foo
19:53:44 <ihope> Quines are fun
19:53:49 <ihope> Except when they cheat. Cheater.
19:53:54 <bsmntbombdood> heh
19:54:07 <bsmntbombdood> I've never written a real quine :/
19:54:17 <ihope> Write one in ///
19:54:26 <bsmntbombdood> //?
19:54:38 <ihope> In that language, you can write something that's both a Hello, world! program and a quine.
19:54:42 <ihope> !help
19:55:03 <ihope> Well?
19:55:05 <ihope> !help
19:55:10 <ihope> Bleh.
19:58:35 <bsmntbombdood> import inspect
19:58:35 <bsmntbombdood> class quine:
19:58:35 <bsmntbombdood>     pass
19:58:35 <bsmntbombdood> print open(inspect.getsourcefile(quine)).read()
19:58:43 <bsmntbombdood> :P
20:00:15 <ihope> Hmm...
20:00:24 <ihope> It's not especially obvious how to make EgoBot.
20:01:07 <ihope> Hmm...
20:03:00 <ihope> Okay, here we go.
20:03:15 <bsmntbombdood> ?
20:04:00 <ihope> Or not...
20:05:31 <ihope> Oh, right.
20:06:03 <bsmntbombdood> I need to write a quine in my oisc
20:06:59 <GregorR> ihope: ??
20:07:07 <GregorR> As in, how to compile it?
20:07:15 <ihope> I think I figured it out.
20:08:56 <GregorR> Well, first you type `make` :P
20:09:06 <GregorR> Then you pray that you have the compendium of compilers necessary.
20:11:29 <ihope> I thought I might have had to type something, seeing as how there's big delays near the beginning and it's possible to type something.
20:12:31 <bsmntbombdood> EgoBot is slow
20:12:52 <GregorR> ihope: egobotIRC.sh
20:13:15 <GregorR> bsmntbombdood: For the last fucking time, EgoBot is not slow, it's THROTTLED.
20:13:20 <bsmntbombdood> I know
20:13:31 * ihope throttles EgoBot
21:29:30 -!- CakeProphet has joined.
21:29:31 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
21:29:48 -!- EgoBot has joined.
21:37:38 <bsmntbombdood> ~cat foo
21:37:38 <bsmnt_bot> foo
21:38:16 <bsmntbombdood> ~cat !dup ~cat
21:38:16 <bsmnt_bot> !dup ~cat
21:38:19 <EgoBot> Huh?
21:39:18 <bsmntbombdood> !daemon cat bf ,[.,]
21:39:30 <bsmntbombdood> !cat ~dup !cat
21:39:33 <EgoBot> ~dup !cat
21:39:33 <bsmnt_bot> !cat !cat
21:39:37 <EgoBot> !cat
21:39:51 <bsmntbombdood> ~cat !dup !dup cat
21:39:52 <bsmnt_bot> !dup !dup cat
21:39:55 <EgoBot> Huh?
21:40:13 <bsmntbombdood> !cat ~dup !dup ~cat
21:40:17 <EgoBot> ~dup !dup ~cat
21:40:17 <bsmnt_bot> !dup ~cat !dup ~cat
21:40:21 <EgoBot> Huh?
21:40:37 <bsmntbombdood> !daemon dup bf ++++[->++++++++<]>>+[->,----------[>,----------]<[++++++++++<]>[.>]<[<]<.>>[.>]++++++++++.[<]+]
21:40:41 <bsmntbombdood> !cat ~dup !cat
21:40:45 <EgoBot> ~dup !cat
21:40:45 <bsmnt_bot> !cat !cat
21:40:49 <EgoBot> !cat
21:41:12 <bsmntbombdood> ~quine
21:41:12 <bsmnt_bot> ~quine
21:45:26 <bsmntbombdood> ~exec self.print_callbacks()
21:45:55 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
21:46:28 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG #esoteric :~quine(.*)", lambda x : bot.raw("PRIVMSG #esoteric :!%s" % bot.message_re.match(x).group("message")[1:]))
21:46:32 <bsmntbombdood> ~quine
21:46:32 <bsmnt_bot> !quine
21:46:36 <EgoBot> Huh?
21:46:49 <bsmntbombdood> !bf_txtgen ~quine
21:47:16 <EgoBot> 83 ++++++++++++++[>+++++++++>++++++++>++++++++><<<<-]>.>+.++++.------------.>--.<----. [334]
21:47:31 <bsmntbombdood> !deamon quine bf ++++++++++++++[>+++++++++>++++++++>++++++++><<<<-]>.>+.++++.------------.>--.<----.
21:47:34 <EgoBot> Huh?
21:47:41 <bsmntbombdood> !daemon quine bf ++++++++++++++[>+++++++++>++++++++>++++++++><<<<-]>.>+.++++.------------.>--.<----.
21:47:45 <EgoBot> ~quine
21:47:45 <bsmnt_bot> !quine
21:47:54 <bsmntbombdood> ...
21:48:16 <bsmntbombdood> !quine
21:48:20 <bsmntbombdood> ~quine
21:48:20 <bsmnt_bot> !quine
21:48:30 <bsmntbombdood> !daemon !quine bf ++++++++++++++[>+++++++++>++++++++>++++++++><<<<-]>.>+.++++.------------.>--.<----.
21:48:46 <bsmntbombdood> !ps a
21:49:05 <bsmntbombdood> ...
21:53:55 * bsmntbombdood frobnicates
22:02:22 * bsmntbombdood reads the mapreduce paper
22:07:16 -!- oerjan has joined.
22:09:07 <bsmntbombdood> hmmm
22:09:09 <bsmntbombdood> interesting
22:10:37 <CakeProphet> hmmm
22:10:58 * bsmntbombdood doesn't quite understand
22:21:56 <bsmntbombdood> What possessed them to write it in a language like C++
22:26:20 <bsmntbombdood> I want a MapReduce cluster now
22:32:08 <ihope> !ping GregorR
22:32:18 <ihope> Hmm.
22:32:24 * ihope frobnicates, whatever that means
22:32:43 <oerjan> http://catb.org/jargon/html/F/frobnicate.html
22:32:57 <bsmntbombdood> ihope: memfrob(3)
22:33:01 <ihope> Oh.
22:33:37 <ihope> What a useless function.
22:33:45 <ihope> :-P
22:34:03 <bsmntbombdood> yeah really
22:57:34 -!- CakeProphet_ has joined.
23:07:00 -!- CakeProphet has quit (Read error: 113 (No route to host)).
23:10:19 -!- CakeProphet__ has joined.
23:10:22 -!- CakeProphet__ has changed nick to CakeProphet.
23:12:56 <GregorR> ihope: RAAAR
23:13:32 <ihope> How do you work EgoBot? socat seems to be mad at me.
23:14:25 <GregorR> I've only used netcat :P
23:16:29 <ihope> netcat might well work.
23:18:12 <GregorR>  /opt/netcat/bin/netcat -e egobotIRC.sh
23:18:43 <GregorR> I predict: socat EXEC:./egobotIRC.sh TCP4:irc.freenode.net:6667
23:18:52 <GregorR> But I haven't used socat for it ;)
23:20:41 -!- ihope has changed nick to i.
23:20:46 -!- i has changed nick to ihope.
23:20:57 <ihope> Well, I certainly didn't expect that.
23:20:59 * oerjan wonders, given this discussion, if he is doing something wrong by connecting IrpBot just with the Haskell Network module.
23:21:31 -!- tgwizard has quit (Remote closed the connection).
23:24:52 -!- FabioNET has quit (Client Quit).
23:25:12 <oklofok> my bot connects with winsock!
23:25:17 -!- oklofok has changed nick to oklopol.
23:25:22 <bsmntbombdood> oerjan: What's IrpBot?
23:25:38 <oklopol> #irp
23:25:42 <oerjan> The bot I made for the #irp channel.
23:26:05 <ihope> And that command isn't really working, even--
23:26:10 <GregorR> I was too lazy to use BSD sockets, so I just made it communicate over stdin/stdout :P
23:26:11 * ihope suddenly decides to use netcat
23:26:20 * bsmntbombdood wrote his bot with sockets
23:26:29 <GregorR> A concept which ihope seems to be having problems with :P
23:26:43 -!- CakeProphet_ has quit (Success).
23:26:44 <ihope> Well, I don't have netcat, exactly.
23:26:52 <oerjan> Right, so socat/netcat is for wrapping standard I/O?
23:27:12 <ihope> Just wait 3.141592653589 seconds and I'll get back to you on that.
23:27:28 <GregorR> oerjan: Yes.
23:27:32 <oerjan> I just used what came with the example bot source on the haskell wiki.
23:38:17 <ihope> make's telling me to stop!
23:38:25 <ihope> How rude.
23:39:57 <ihope> You know, it just said "Stop." Just like that.
23:40:17 <oerjan> I know.  Just give it a good beating.
23:41:32 -!- tgwizard has joined.
23:54:03 <bsmntbombdood> ~dup !cat ~dup
23:54:04 <bsmnt_bot> !cat ~dup !cat ~dup
23:54:54 <bsmntbombdood> ...
23:55:15 <bsmntbombdood> ~exec __import__("time").sleep(300)
23:55:26 <bsmntbombdood> ~cat I'm alive!
23:55:26 <bsmnt_bot> I'm alive!
23:55:29 <bsmntbombdood> woo
23:58:26 <bsmntbombdood> ~exec __import__("time").sleep(60); self.raw("PRIVMSG #esoteric :foo")
23:59:26 <bsmnt_bot> foo

2007-01-05:

00:04:33 -!- EgoBot has quit (Read error: 54 (Connection reset by peer)).
00:04:46 -!- EgoBot has joined.
00:05:18 <bsmntbombdood> EgoBot: EgoBot EgoBot EgoBot EgoBot EgoBot EgoBot EgoBot EgoBot 
00:09:34 <yoshibot> dude, is bsmnt_bot running on netcat?
00:09:38 <yoshibot> that's awesome
00:09:45 <bsmntbombdood> no
00:09:52 <yoshibot> ah, k
00:09:55 <bsmntbombdood> sockets
00:10:00 <yoshibot> awesome.
00:15:31 -!- bsmnt_bot has quit (Remote closed the connection).
00:15:37 -!- bsmnt_bot has joined.
00:15:48 <bsmntbombdood> ~raw PRIVMSG #esoteric :good
00:15:49 <bsmnt_bot> good
00:16:07 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :good")
00:16:08 <bsmnt_bot> good
00:16:57 <bsmntbombdood> ~ctcp #esoteric ACTION is awesome
00:16:57 <bsmnt_bot> ACTION
00:17:02 <bsmntbombdood> or not
00:18:15 <oerjan> bsmntbombdood: You might want to add something to save your list of added patterns to a file to be performed on startup.
00:18:27 <bsmntbombdood> yeah
00:18:46 * bsmntbombdood wonders if you can pickle functions
00:19:13 <oerjan> I was thinking just of the command text.
00:19:51 <bsmntbombdood> pickle.PicklingError: Can't pickle <function <lambda> at 0xb7bcc5dc>: it's not found as __main__.<lambda>
00:20:17 -!- bsmnt_bot has quit (Remote closed the connection).
00:21:10 -!- bsmnt_bot has joined.
00:21:19 <bsmntbombdood> ~ctcp #esoteric ACTION tests
00:21:19 <bsmnt_bot> ACTION
00:21:30 <oerjan> It would also be a good idea to make it a text file so you can edit out patterns if something goes horribly wrong. :)
00:21:52 -!- bsmnt_bot has quit (Remote closed the connection).
00:21:59 * jix is in love :)
00:21:59 <ihope> bsmntbombdood: function pickling?
00:22:06 <bsmntbombdood> yes
00:22:11 -!- bsmnt_bot has joined.
00:22:14 <bsmntbombdood> ~ctcp #esoteric ACTION tests
00:22:14 <bsmnt_bot> ACTION
00:22:30 <ihope> Is that when you have an injective mapping from a function into brine?
00:22:44 <bsmntbombdood> pickle is the python object serializer
00:22:45 <oerjan> I believe the ACTION is surrounded by \001 characters.
00:22:54 <bsmntbombdood> oerjan: yeah
00:23:11 <ihope> And you should send the word "tests" as well.
00:23:30 <bsmntbombdood> no shit
00:23:34 <bsmntbombdood> r".* PRIVMSG \S* :%sctcp (.*) (.*)" % self.COMMAND_CHAR
00:23:38 <ihope> Also, make doesn't seem to have left behind a binary called "netcat".
00:23:52 -!- bsmnt_bot has quit (Remote closed the connection).
00:23:58 -!- bsmnt_bot has joined.
00:24:00 <bsmntbombdood> ~ctcp #esoteric ACTION tests
00:24:01 <bsmnt_bot> ACTION
00:24:09 <ihope> Woot.
00:24:13 -!- CakeProphet has quit (No route to host).
00:24:23 -!- bsmnt_bot has quit (Remote closed the connection).
00:24:29 -!- bsmnt_bot has joined.
00:24:31 <bsmntbombdood> ~ctcp #esoteric ACTION tests
00:24:31 * bsmnt_bot 
00:24:49 -!- bsmnt_bot has quit (Remote closed the connection).
00:24:59 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
00:25:07 -!- bsmnt_bot has joined.
00:25:10 <bsmntbombdood> ~ctcp #esoteric ACTION tests
00:25:11 * bsmnt_bot tests
00:25:14 <bsmntbombdood> finally
00:25:27 <bsmntbombdood> \S instead of .
00:25:41 <ihope> Buh?
00:25:54 <bsmntbombdood> Buh?
00:26:02 <ihope> What?
00:26:10 <bsmntbombdood> what?
00:26:24 <ihope> \S goes where?
00:26:29 <oerjan> Is there an echo here?
00:26:37 <bsmntbombdood> r".* PRIVMSG \S* :%sctcp (\S+) (.+)" % self.COMMAND_CHAR
00:26:44 <bsmntbombdood> is what the ctcp regex should be
00:27:32 -!- bsmnt_bot has quit (Remote closed the connection).
00:27:36 <ihope> I see.
00:27:45 -!- bsmnt_bot has joined.
00:27:50 <bsmntbombdood> ~ctcp #esoteric ACTION is awesome
00:27:51 * bsmnt_bot is awesome
00:27:55 <bsmntbombdood> mmk
00:28:27 <ihope> ~ctcp #esoteric ACTION is awesome
00:28:27 * bsmnt_bot is awesome
00:29:29 -!- RodgerTheGreat has quit.
00:29:39 <ihope> !ctcp ##quantum ACTION is awesome
00:29:43 <EgoBot> Huh?
00:29:47 <ihope> ~ctcp ##quantum ACTION is awesome
00:29:53 <ihope> Awesome.
00:29:58 <bsmntbombdood> did it?
00:30:16 <ihope> Yep.
00:30:24 <ihope> Of course, ##quantum was -n'd.
00:32:05 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG \S+ :~join (.*)", lambda x, y : bot.raw("JOIN :%s" % y.group(1)))
00:32:23 <bsmntbombdood> ~raw PART ##quantum :bye bye
00:32:32 <bsmntbombdood> er
00:32:39 <bsmntbombdood> ~join ##quantum 
00:33:07 <bsmntbombdood> ~raw
00:33:30 <ihope> I somehow feel plain old ~raw won't do much.
00:33:41 <bsmntbombdood> you are correct
00:33:53 <bsmntbombdood> ~raw POKE ihope 
00:34:00 <bsmntbombdood> :kornbluth.freenode.net 421 bsmnt_bot POKE :Unknown command
00:35:41 <ihope> Yay.
00:36:29 <bsmntbombdood> ~ctcp ihope POKE hard
01:05:16 <bsmntbombdood> I wonder how MapReduce is used for machine learning
01:06:31 <yoshibot> battlin' bots
01:07:49 <bsmntbombdood> ?
01:43:01 -!- tgwizard has quit (Remote closed the connection).
01:52:47 -!- ihope_ has joined.
01:54:48 -!- CakeProphet__ has joined.
01:54:52 -!- CakeProphet__ has changed nick to CakeProphet.
02:00:23 -!- ihope has quit (Read error: 145 (Connection timed out)).
02:05:50 <bsmntbombdood> woot, I wrote a quine in python
02:06:03 <bsmntbombdood> source = 'source = %r\nprint source %% source\n'
02:06:03 <bsmntbombdood> print source % source
02:07:30 <oerjan> what does % do?
02:07:38 <bsmntbombdood> like printf
02:08:00 <bsmntbombdood> print "%s" % "foo" === printf("%s", "foo")
02:08:24 <oerjan> i don't think your quine quite works.
02:08:44 <bsmntbombdood> ?
02:08:51 <oerjan> have you tested it?
02:08:54 <bsmntbombdood> yeah
02:09:06 <oklopol> %r?
02:10:15 <bsmntbombdood> %r uses repr() instead of str()
02:10:25 -!- CakeProphet__ has joined.
02:10:36 <oerjan> ah, i confused the \n before ' and the actual newline after
02:10:48 <bsmntbombdood> $ python quine.py > output
02:10:48 <bsmntbombdood> $ diff -u quine.py output
02:10:48 <bsmntbombdood> $
02:11:18 -!- CakeProphet has quit (Read error: 113 (No route to host)).
02:11:19 -!- CakeProphet__ has changed nick to CakeProphet.
02:13:08 * bsmntbombdood feels leet
02:26:50 <bsmntbombdood> ~join #awos
02:28:03 * bsmnt_bot is better than fatso
02:28:28 <bsmntbombdood> oops
02:30:00 <oerjan> main = putStr s >> putStrLn (show s) where s = "main = putStr s >> putStrLn (show s) where s = "
02:30:41 * oerjan feels leet too
02:36:17 -!- ihope_ has quit (Read error: 131 (Connection reset by peer)).
02:37:32 <oerjan> although the %r in Python and show in Haskell make quines in those languages almost too easy.
02:38:18 <oerjan> ah, that's right.
02:38:41 <oerjan> main = putStr s >> print s where s = "main = putStr s >> print s where s = "
02:40:27 <bsmntbombdood> print (lambda s : s+repr(s)+')')("print (lambda s : s+repr(s)+')')(")
02:40:49 <CakeProphet> or..
02:41:41 <CakeProphet> print (lambda x:x%x)("(lambda x:x%%x)(%r)")
02:41:47 <CakeProphet> Same thing.
02:41:54 <CakeProphet> just neater looking :D
02:42:07 <oerjan> you forgot the print in the string.
02:42:59 <bsmntbombdood> and, you fail
02:43:02 <CakeProphet> ah.
02:43:17 <CakeProphet> print (lambda x:x%x)("print (lambda x:x%%x)(%r)")
02:43:28 <bsmntbombdood> s/"/'/
02:44:02 <CakeProphet> print (lambda x:x%x)('"print (lambda x:x%%x)(%r)"')   :P
02:44:15 <CakeProphet> >.>
02:44:17 <CakeProphet> ait..
02:44:20 <CakeProphet> why single-quotes?
02:44:32 <bsmntbombdood> because that's what repr uses
02:44:44 <CakeProphet> repr doesn't specifically use repr.
02:44:45 <CakeProphet> er...
02:44:47 <CakeProphet> single-quote
02:44:51 <CakeProphet> it defaults to single.
02:44:52 <CakeProphet> but not always.
02:45:01 <bsmntbombdood> (lambda x:x%x)("print (lambda x:x%%x)(%r)") == "print (lambda x:x%x)('print (lambda x:x%%x)(%r)')"
02:45:14 <bsmntbombdood> no quinage
02:49:14 <bsmntbombdood> print open(__import__("inspect").getsourcefile(lambda : 0)).read()
02:49:23 <bsmntbombdood> :P
02:49:33 <CakeProphet> pfft
02:51:17 * CakeProphet refuses to use single quotes unless absolutely nessicary.
02:51:24 <CakeProphet> They feel strange.
02:52:36 <CakeProphet> !dup haskhd
02:52:40 <EgoBot> Huh?
02:52:55 <CakeProphet> !help daemon
02:52:58 <EgoBot> Use: daemon <daemon> <daemon-command>  Function: start a daemon process.
02:53:28 <bsmntbombdood> CakeProphet: They are never absolutely neccisary
02:53:46 <bsmntbombdood> except in quines
02:54:07 <bsmntbombdood> s/quines/that quine/
02:54:07 <oerjan> only short quines.
02:57:41 <bsmntbombdood> make a quine in python shorter than:
02:57:49 <bsmntbombdood> x='x=%r\nprint x%%x\n';print x%x
02:57:53 <bsmntbombdood> (30 chars)
02:58:13 <bsmntbombdood> erm
02:58:48 <bsmntbombdood> x='x=%r;print x%%x\n';print x%x
03:01:19 <CakeProphet> pfft... I don't consider it a disqualification if the quote is selected arbitrarily by the interpreter based on the innards of the string.
03:01:30 <CakeProphet> It's the essence, not the output.  :P
03:02:07 <bsmntbombdood> make that x='x=%r;print x%%x';print x%x
03:02:19 <bsmntbombdood> 29 chars
03:17:32 <CakeProphet> !daemon lol glass {M[m(_o)O!(_i)I! (_i)i.? " " 1 (_o)o.?(_o)o.?(_o)o.?]}
03:17:37 <CakeProphet> !lol hahahahahaha
03:17:38 -!- EgoBot has quit (Read error: 54 (Connection reset by peer)).
03:17:41 <CakeProphet> :P
03:17:48 -!- EgoBot has joined.
03:18:09 <oklopol> heyy!
03:18:14 <oklopol> i made a quine too :DDD
03:18:26 <oklopol> def a(b):
03:18:27 <oklopol>     print b+b[4:6]+chr(34)+chr(34)+chr(34)+b[:103]+"+')'"+chr(92)+'n'+chr(34)+chr(34)+chr(34)+')'
03:18:27 <oklopol> a("""def a(b):
03:18:27 <oklopol>     print b+b[4:6]+chr(34)+chr(34)+chr(34)+b[:103]+"+')'"+chr(92)+'n'+chr(34)+chr(34)+chr(34)+')'\n""")
03:18:32 <oklopol> a long one
03:18:33 <CakeProphet> Making a quine in ORK would be super difficult.
03:18:41 * CakeProphet likesshort quines.
03:18:46 <CakeProphet> I suck at making quines though.
03:19:04 <oklopol> yeah, but i couldn't think of a new short way to make a quine
03:19:09 <oklopol> and that's my first
03:19:36 <oklopol> i tried to make one in c++ tho, but it get's very big since a c++ program has lot
03:19:41 <oklopol> 's of code overhead
03:24:29 <CakeProphet> Like Glass :D
03:24:52 <CakeProphet> In glass... you have to instantiate and get and call a bunch of crap to do just the simplest of things  :P
03:31:36 <oerjan> compared to brainfuck or unlambda this is all peanuts, of course.
03:37:33 <GregorR> I wrote a quine in ORK.
03:39:37 <GregorR> http://www.codu.org/eso/ < I have recreated my esopage, including ORK readme and the likes.
03:42:18 <bsmntbombdood> GregorR: What do you get when you execute that page?
03:42:44 <GregorR> Hello, World!
03:42:51 <bsmntbombdood> that's it?
03:42:55 <GregorR> The only program I ever wrote in 2L :P
03:42:59 <GregorR> 2L is really difficult X_X
03:43:15 <bsmntbombdood> awfully long for a hello world...
03:43:34 <GregorR> Feel free to read the 2L readme.
03:44:44 <bsmntbombdood> :(){ :|:&};:
03:45:38 <bsmntbombdood> while 1: __import__("os").fork()
03:45:47 <oerjan> Why is c and d of the ORK quine split in two? Is there a length limit on strings?
03:46:24 -!- digital_me_ has joined.
03:46:36 <oerjan> I suppose that goes for b,c,d as a whole.
03:47:02 <GregorR> No, there's no length limit. I have no idea why I did it like that :P
03:47:21 <bsmntbombdood> ~cat fooey
03:47:37 <bsmntbombdood> ~exec self.print_callbacks()
03:49:07 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~cat (.*)", lambda x,y : bot.raw("PRIVMSG %s :%s" % (y.group(1), y.group(2))))
03:49:10 <bsmntbombdood> ~cat fooey
03:49:10 <bsmnt_bot> fooey
03:58:26 -!- digital_me_ has quit ("leaving").
04:47:53 -!- CakeProphet has quit (Read error: 110 (Connection timed out)).
07:46:43 -!- digital_me has quit ("Lost terminal").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:36:44 -!- oerjan has quit ("Good night").
08:47:07 -!- oklofok has joined.
08:47:20 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
08:51:52 -!- oklopol has joined.
08:51:53 -!- oklofok has quit (Read error: 54 (Connection reset by peer)).
09:01:07 -!- oklofok has joined.
09:01:53 -!- oklopol has quit (Read error: 131 (Connection reset by peer)).
11:14:18 -!- tgwizard has joined.
12:22:10 -!- jix has joined.
12:32:47 -!- jix__ has joined.
12:42:10 -!- jix has quit (Read error: 110 (Connection timed out)).
13:50:40 -!- oklofok has quit (Read error: 60 (Operation timed out)).
15:10:57 -!- ihope has joined.
15:11:12 <ihope> The nice thing about ##quantum is you can tell who's identified and who's not.
15:11:19 <ihope> Sort of.
15:11:40 <ihope> The identified people are opped, the unidentified people aren't.
15:11:49 <ihope> Except the only unidentified person is bsmnt_bot.
15:12:02 <ihope> Now, let's see here...
15:12:03 <ihope> !help
15:12:06 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
15:12:08 <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
15:12:11 <ihope> Yay, it works.
16:03:45 <jix__> ~cat test
16:03:45 <bsmnt_bot> test
16:06:24 <jix__> !rhotor x/"test"
16:06:25 <EgoBot> rhotor-hi: ./Parser.hs:(29,0)-(46,39): Non-exhaustive patterns in function tokenize
16:06:34 <jix__> !rhotor <x/"test">
16:06:37 <EgoBot> rhotor-hi: ./Parser.hs:(29,0)-(46,39): Non-exhaustive patterns in function tokenize
16:07:54 <jix__> !rhotor x/%"test"
16:07:57 <EgoBot> tes
16:09:03 <jix__> !rhotor http://rafb.net/p/K3yUA865.txt
16:09:05 <EgoBot> tes
16:10:24 <jix__> !rhotor http://files.method-missing.org/evil.rho
16:10:29 <EgoBot> rhotor-hi: ./Parser.hs:(29,0)-(46,39): Non-exhaustive patterns in function tokenize
16:10:38 -!- ihope has quit (Read error: 110 (Connection timed out)).
16:10:48 <jix__> !rhotor http://files.method-missing.org/evil.rho
16:10:55 <EgoBot> ~cat !rhotor http://files.method-missing.org/evil.rho
16:10:55 <bsmnt_bot> !rhotor http://files.method-missing.org/evil.rho
16:10:59 <EgoBot> ~cat !rhotor http://files.method-missing.org/evil.rho
16:10:59 <bsmnt_bot> !rhotor http://files.method-missing.org/evil.rho
16:11:05 <EgoBot> ~cat !rhotor http://files.method-missing.org/evil.rho
16:11:05 <bsmnt_bot> !rhotor http://files.method-missing.org/evil.rho
16:11:13 <EgoBot> ~cat !rhotor http://files.method-missing.org/evil.rho
16:11:14 <bsmnt_bot> !rhotor http://files.method-missing.org/evil.rho
16:11:18 <jix__> hrhr bots are stupid
16:11:19 <EgoBot> ~cat !rhotor http://files.method-missing.org/evil.rho
16:11:19 <bsmnt_bot> !rhotor http://files.method-missing.org/evil.rho
16:11:27 <EgoBot> ~cat !rhotor http://files.method-missing.org/evil.rho
16:11:27 <bsmnt_bot> !rhotor http://files.method-missing.org/evil.rho
16:11:31 <EgoBot> ~cat !rhotor http://files.method-missing.org/evil.rho
16:11:31 <bsmnt_bot> !rhotor http://files.method-missing.org/evil.rho
16:11:35 <EgoBot> ~cat !rhotor http://files.method-missing.org/evil.rho
16:11:35 <bsmnt_bot> !rhotor http://files.method-missing.org/evil.rho
16:11:39 <EgoBot> rhotor-hi: Prelude.head: empty list
16:12:22 -!- digital_me has joined.
16:12:34 <SimonRC> *** SchtBAMPF! ***
16:12:55 <jix__> ??
16:13:13 <SimonRC> That was a cool teleporting noise.
16:13:32 <SimonRC> anyway, I was going to share this:  http://imgs.xkcd.com/comics/youtube.png
16:13:45 <jix__> old......
16:16:46 -!- jix__ has changed nick to jix.
16:23:17 <SimonRC> I just recognised the art style and looked at the URL.
16:23:21 <SimonRC> D'oh.
17:03:42 -!- oklopol has joined.
17:08:59 -!- feoh has joined.
17:09:30 -!- feoh has left (?).
17:17:32 -!- ihope has joined.
17:36:09 -!- RodgerTheGreat has joined.
18:03:33 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
19:55:08 <ihope> !help
19:55:12 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
19:55:13 <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
19:55:16 <ihope> Yep, still working.
19:55:17 <bsmntbombdood> !fooof
19:55:22 <EgoBot> Huh?
19:55:23 <bsmntbombdood> what is?
19:55:28 <ihope> EgoBot.
19:55:36 <bsmntbombdood> ~foo
19:55:44 <bsmntbombdood> ~cat !dup ~cat
19:55:45 <bsmnt_bot> !dup ~cat
19:55:47 <EgoBot> Huh?
19:55:59 <ihope> !cat ~dup !cat
19:56:01 <EgoBot> Huh?
19:56:14 <bsmntbombdood> !daemon cat bf ,[.,]
19:56:28 -!- gnidan has joined.
20:09:14 -!- RodgerTheGreat_ has joined.
20:25:43 -!- RodgerTheGreat has quit (Read error: 110 (Connection timed out)).
20:30:31 -!- RodgerTheGreat_ has changed nick to RodgerTheGreat.
20:48:36 <pgimeno> !ps
20:48:39 <EgoBot> 2 pgimeno: ps
20:48:44 <pgimeno> !ps d
20:48:48 <EgoBot> 1 bsmntbombdood: daemon cat bf
20:48:50 <EgoBot> 2 pgimeno: ps
20:50:32 <bsmntbombdood> !help ps
20:50:34 <EgoBot> Use: ps  Function: display the current processes
20:50:45 <bsmntbombdood> duh
20:52:03 <bsmntbombdood> ~cat EgoBot is stupid
20:52:03 <bsmnt_bot> EgoBot is stupid
20:52:11 <bsmntbombdood> pwnt
20:58:29 <ihope> ~cat !cat ~cat ~cat ~cat !cat !cat
20:58:29 <bsmnt_bot> !cat ~cat ~cat ~cat !cat !cat
20:58:32 <EgoBot> ~cat ~cat ~cat !cat !cat
20:58:33 <bsmnt_bot> ~cat ~cat !cat !cat
20:58:45 <ihope> Indeed, I didn't expect that to work.
20:59:37 <bsmntbombdood> ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
20:59:38 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
20:59:42 <EgoBot> ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
20:59:43 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
20:59:46 <EgoBot> ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
20:59:47 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
20:59:50 <EgoBot> ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
20:59:51 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
20:59:54 <EgoBot> ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
20:59:55 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
20:59:58 <EgoBot> ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
20:59:59 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
21:00:02 <EgoBot> ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
21:00:03 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
21:00:06 <EgoBot> ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
21:00:07 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
21:00:10 <EgoBot> ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
21:00:10 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
21:00:14 <EgoBot> ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
21:00:15 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
21:00:18 <EgoBot> ~cat !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
21:00:18 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat ~cat !cat
21:00:22 <EgoBot> ~cat !cat ~cat !cat ~cat !cat ~cat !cat
21:00:23 <bsmnt_bot> !cat ~cat !cat ~cat !cat ~cat !cat
21:00:26 <EgoBot> ~cat !cat ~cat !cat ~cat !cat
21:00:27 <bsmnt_bot> !cat ~cat !cat ~cat !cat
21:00:30 <EgoBot> ~cat !cat ~cat !cat
21:00:31 <bsmnt_bot> !cat ~cat !cat
21:00:34 <EgoBot> ~cat !cat
21:00:34 <bsmnt_bot> !cat
21:00:41 <bsmntbombdood> fun
21:01:06 <RodgerTheGreat> woah
21:05:26 <ihope> ~dup ~dup
21:05:30 <ihope> !dup !dup
21:05:34 <EgoBot> Huh?
21:05:37 <ihope> Mmh.
21:06:37 <bsmntbombdood> while __import__("os").fork(): __import__("os").fork()
21:12:01 -!- CakeProphet has joined.
21:15:21 <ihope> bsmntbombdood: is that really a good idea?
21:17:56 -!- pgimeno has changed nick to GatoRandi.
21:18:17 -!- GatoRandi has changed nick to pgimeno.
21:19:52 -!- pgimeno has changed nick to GatoRandi.
21:20:52 -!- GatoRandi has changed nick to pgimeno.
21:21:32 <pgimeno> (sorry)
21:22:54 <bsmntbombdood> ihope: of course
21:23:12 <ihope> What's it do, exactly?
21:23:29 <bsmntbombdood> takes your system down :)
21:23:41 <ihope> That's what I'd guessed...
21:24:18 <ihope> I just noticed, though, that that line didn't start with a ~
21:24:31 <ihope> Probably not as bad as ~exec while __import__("os").fork(): __import__("os").fork()
21:24:40 <bsmntbombdood> duh...
21:24:55 <bsmntbombdood> ~exec while __import__("os").fork(): __import__("os").fork()
21:25:23 <bsmntbombdood> the box has ulimits set correctly
21:25:23 <GregorR> while 1: __import__("os").fork()
21:25:33 <bsmntbombdood> GregorR: Mine grows faster
21:25:44 <GregorR> I doubt that.
21:26:10 <bsmntbombdood> why?
21:26:20 <GregorR> Every fourth fork of yours is wasted.
21:26:20 <bsmntbombdood> it will grow faster if the new proccesses keep forking
21:26:30 <bsmntbombdood> ?
21:26:46 <GregorR> The condition for the while. fork() returns a non-true value (0) for the child.
21:26:51 <GregorR> So that child won't fork anymore.
21:27:13 <bsmntbombdood> fine, while not __import__("os").fork(): __import__("os").fork()
21:27:22 <GregorR> Now the parent won't fork anymore.
21:27:29 <ihope> So it won't do anything?
21:27:38 <bsmntbombdood> import os
21:27:47 <bsmntbombdood> x=os.fork()
21:27:48 <GregorR> ihope: No, it'll still fork off into infinity, but a simple while-true loop will fork faster.
21:27:52 <bsmntbombdood> if x: os.fork()
21:27:55 <bsmntbombdood> else: os.fork()
21:28:14 <bsmntbombdood> no
21:28:19 <GregorR> bsmnt_bot: Now that would only fork twice :P
21:28:22 <GregorR> Erm
21:28:25 <GregorR> bsmntbombdood: ^^^
21:28:32 <bsmntbombdood> def f():
21:28:38 <bsmntbombdood>   x=os.fork()
21:28:45 <GregorR> bsmntbombdood: A simple while-true loop would fork just as fast if not faster.
21:28:46 <bsmntbombdood>   if x: os.fork()
21:28:51 <bsmntbombdood>   else: os.fork()
21:28:53 <bsmntbombdood>   f()
21:29:16 <bsmntbombdood> no
21:29:21 <bsmntbombdood> def f():
21:29:24 <bsmntbombdood>   x=os.fork()
21:29:30 <bsmntbombdood>   if x: f()
21:29:36 <bsmntbombdood>   else: f()
21:29:48 <ihope> Fork fork fork fork fork fork fork fork goto.
21:29:51 <GregorR> I'm dumbfounded by the fact that you seem to think that would be faster than a while-true loop.
21:29:54 <bsmntbombdood> meh whatever
21:30:03 <bsmntbombdood> :(){ :|:&};:
21:30:12 <ihope> +[Y]
21:30:28 <bsmntbombdood> and the brainfork!
21:30:48 <GregorR> ihope: +[Y+] will fork faster :)
21:31:04 <ihope> GregorR: it will?
21:31:18 <GregorR> Y returns 0 for the child, just like fork(), so you have every-other fork dropping out of the loop.
21:31:30 <bsmntbombdood> fork you
21:31:32 <GregorR> In fact, come to think of it, yours won't fork to any significant degree.
21:31:40 <GregorR> The children will just keep on dying.
21:31:57 <ihope> I'm going to quote you.
21:32:07 <ihope> Muahaha...
21:32:17 <GregorR> Y'know, I'm in that channel.
21:32:30 <ihope> Yes, I do.
21:34:09 <bsmntbombdood> ~exec while True: __import__("os").fork()
21:34:24 <GregorR> Haha, I win ^^
21:34:43 <bsmntbombdood> ~exec while __import__("os").fork(): __import__("os").fork()
21:35:13 <bsmntbombdood> ~cat lookey! i'm still alive!
21:35:13 <bsmnt_bot> lookey! i'm still alive!
21:36:18 <oklopol> every third fork is wasted i think
21:36:50 <oklopol> one fork in, 3 out, 1 dies
21:37:09 <GregorR> oklopol: That'd be every fourth, and that's what I told him, but he apparently won't believe me :P
21:37:31 <bsmnt_bot> fork you all
21:38:15 <ihope> Now, I take it at more than -1 of you have seen http://dnptbky.ytmnd.com/
21:38:18 <oklopol> every third fork created dies
21:38:50 <oklopol> why would that be every forth?
21:38:52 * GregorR taps his head.
21:39:01 <ihope> Tap?
21:39:11 <GregorR> ihope: Yes, I've seen that, a friend of mine made it :P
21:41:16 <bsmntbombdood> GregorR: Please respect our customers in south america
21:42:18 <GregorR> I respect them just as much as I respect everyone else. Namely, none.
21:44:54 -!- tgwizard has quit (Remote closed the connection).
21:50:55 <bsmntbombdood> ~exec pfoaf
21:52:52 <bsmntbombdood> ~exec __import__("time").sleep(300); self.raw("PRIVMSG #esoteric :%s" % "NFQS".encode("rot13"))
21:55:39 -!- tgwizard has joined.
21:57:52 <bsmnt_bot> ASDF
21:59:36 <bsmntbombdood> ~exec __import__("time").sleep(500); self.raw("PRIVMSG #esoteric :the world will end in %s days" % __import__("random").randint(66,6666))
22:07:56 <bsmnt_bot> the world will end in 5668 days
22:08:21 <bsmntbombdood> ~exec __import__("time").sleep(__import__("random").randint(500,3000)); self.raw("PRIVMSG #esoteric :blah")
22:09:04 <ihope> It's waiting...
22:09:12 <ihope> (Is it?)
22:09:17 <bsmntbombdood> ?
22:09:44 * bsmntbombdood implements ~ps
22:09:53 <ihope> Is it going to output anything?
22:10:00 <bsmntbombdood> yeah
22:10:34 <ihope> When?
22:11:08 <bsmntbombdood> in __import__("random").randint(500,3000) seconds...
22:14:01 <ihope> Seconds...
22:14:40 -!- gnidan has quit ("leaving").
22:18:39 <bsmnt_bot> blah
22:18:54 <bsmntbombdood> blah!
22:19:42 <ihope> I want a ~horriblysandboxedexec command that I can use.
22:20:07 -!- jix has joined.
22:21:21 -!- bsmnt_bot has quit (Remote closed the connection).
22:21:25 <bsmntbombdood> new code
22:21:33 -!- bsmnt_bot has joined.
22:21:48 <bsmntbombdood> ~exec __import__("time").sleep(100)
22:21:55 <bsmntbombdood> ~exec print self.commands_running
22:22:05 -!- bsmnt_bot has quit (Remote closed the connection).
22:22:21 -!- bsmnt_bot has joined.
22:22:23 <bsmntbombdood> ~exec __import__("time").sleep(100)
22:22:25 <bsmntbombdood> ~exec print self.commands_running
22:22:58 <bsmntbombdood> ~exec print [(i[0],i[2]) for i in self.commands_running]
22:23:09 <ihope> "It is recommended to backup valuable data before proceeding."
22:23:11 <bsmntbombdood> coool
22:23:17 <bsmntbombdood> ~exec print [(i[0],i[2]) for i in self.commands_running]
22:23:19 <ihope> But I don't have any valuable data! How can I do that?
22:23:37 <bsmntbombdood> ~exec print [(i[0],time.time() - i[2]) for i in self.commands_running]
22:23:47 <bsmntbombdood> now for ~ps
22:23:53 <bsmntbombdood> ~exec print [(i[0],time.time() - i[2]) for i in self.commands_running]
22:23:54 <ihope> ~ps
22:24:01 <bsmntbombdood> not implemented yet
22:24:06 <bsmntbombdood> how should I ouput it?
22:24:13 <ihope> But you said "now"...
22:24:16 <ihope> Meanie.
22:24:21 <bsmntbombdood> now to code it
22:24:24 <bsmntbombdood> ~exec print [(i[0],time.time() - i[2]) for i in self.commands_running]
22:24:55 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[2]) for i in self.commands_running])
22:24:56 <bsmnt_bot> [('self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[2]) for i in self.commands_running])', 0.00049591064453125)]
22:25:02 <bsmntbombdood> cool, eh?
22:25:30 <bsmntbombdood> ~exec __import__("time").sleep(100); print "done"
22:25:32 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[2]) for i in self.commands_running])
22:25:32 <bsmnt_bot> [('__import__("time").sleep(100); print "done"', 1.8968710899353027), ('self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[2]) for i in self.commands_running])', 0.00046992301940917969)]
22:26:15 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[2]) for i in self.commands_running])
22:26:15 <bsmnt_bot> [('__import__("time").sleep(100); print "done"', 44.46694016456604), ('self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[2]) for i in self.commands_running])', 0.00042605400085449219)]
22:26:48 <bsmntbombdood> I wonder how to implement ~kill...
22:28:11 -!- bsmnt_bot has quit (Remote closed the connection).
22:28:20 -!- bsmnt_bot has joined.
22:28:27 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[2]) for i in self.commands_running])
22:28:27 <bsmnt_bot> [('self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[2]) for i in self.commands_running])', 0.00048398971557617188)]
22:33:26 <bsmntbombdood> alas, the people in #python say there's no way to do it
22:33:54 <ihope> Everything can be done, given enough time.
22:34:32 <ihope> And remember, "forever" just means "for a really long time".
22:41:17 <bsmntbombdood> seems like there should be a way to kill a thread
22:50:33 <ihope> Have your thread check some variable every second thing it does.
22:55:10 <bsmntbombdood> It's executing the code that I give it though...
22:57:01 <ihope> Use time slicing and all that jazz.
22:57:06 <bsmntbombdood> ?
22:57:59 <bsmntbombdood> I don't want to right my own multitasking operating system, and i don't think that's even possible in python
22:58:17 <bsmntbombdood> s/right/write/
22:58:18 <CakeProphet> It is.
22:58:23 <CakeProphet> :P
22:58:34 <bsmntbombdood> how?
22:58:51 <CakeProphet> Dunno really...
22:59:11 <CakeProphet> Threads?
22:59:13 <CakeProphet> psuedothreads?
22:59:33 <ihope> Python's Turing-complete, isn't it?
22:59:37 <bsmntbombdood> It uses threads right now for ~exec
22:59:37 <ihope> Unlike C.
22:59:40 <ihope> :-)
22:59:49 <bsmntbombdood> How is c not turing complete?
23:00:06 <ihope> Finite memory.
23:00:11 <GregorR> sizeof(void *) is defined to be finite.
23:00:18 <ihope> Yeah, something like that.
23:00:19 <GregorR> Therefore no C implementation can access infinite memory.
23:00:20 <bsmntbombdood> then python isn't turing complete
23:00:30 <CakeProphet> It is.
23:00:30 <ihope> Isn't it?
23:00:40 <GregorR> The python /language/ is, the python /implementation/ is (of course) not.
23:02:11 <bsmntbombdood> I think we can consider C turing complete
23:02:36 <ihope> But it isn't, is it?
23:02:53 <bsmntbombdood> nothing can actually be turing complete
23:03:11 <ihope> Languages can be, implementations can't
23:04:01 <bsmntbombdood> Any language with pointers can't be turing complete then
23:04:06 <jix> it can
23:04:31 <jix> when the pointers can be arbitrary(wrong spelling for sure) large
23:04:49 <bsmntbombdood> which they can't be in any real language
23:04:57 <jix> define real language
23:05:06 <jix> they can't be in any implementation
23:05:12 <jix> but they can be in the specification
23:05:32 <ihope> jix: that'd be "arbitrarily".
23:05:52 <jix> ihope: thx
23:05:55 -!- yoshibot has quit.
23:06:08 <ihope> And pointers can be arbitrarily large, if you have infinite memory.
23:09:55 <GregorR> C plus the concept of infinity is TC, since sizeof(void *) could be infinity.
23:11:04 <ihope> C plus ordinal numbers!

2007-01-06:

00:12:36 -!- tgwizard has quit (Remote closed the connection).
00:47:30 -!- Sgeo has joined.
00:53:59 -!- CakeProphet has quit (Read error: 104 (Connection reset by peer)).
01:16:47 -!- anonfunc has joined.
01:19:50 -!- Sukoshi has quit ("仮���出る�����を���る��。１�分��待��。��も。").
01:24:03 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
01:31:19 -!- CakeProphet has joined.
01:57:43 <bsmntbombdood> ~cat foo
01:57:52 <bsmntbombdood> ummm
01:58:12 <bsmntbombdood> ~exec self.print_callbacks()
01:58:16 <bsmntbombdood> oh
01:59:16 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :(.*)", lambda x,y : bot.raw("PRIVMSG %s :%s" % (y.group(1), y.group(2))))
01:59:22 <bsmntbombdood> ~cat foo
01:59:22 <bsmnt_bot> ~cat foo
01:59:55 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
01:59:55 <bsmnt_bot> ~exec self.raw_regex_queue.pop()
02:00:03 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~cat (.*)", lambda x,y : bot.raw("PRIVMSG %s :%s" % (y.group(1), y.group(2))))
02:00:07 <bsmntbombdood> ~cat foo
02:00:07 <bsmnt_bot> foo
02:02:28 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[2]) for i in self.commands_running])
02:02:28 <bsmnt_bot> [('self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[2]) for i in self.commands_running])', 0.00041484832763671875)]
02:02:37 <bsmntbombdood> urgh, I want ~kill
02:07:44 -!- bsmnt_bot has quit (Remote closed the connection).
02:07:47 -!- bsmnt_bot has joined.
02:07:50 <bsmntbombdood> ~ps
02:08:04 <bsmntbombdood> ~exec __import__("time").sleep(100)
02:08:06 <bsmntbombdood> ~ps
02:08:06 -!- bsmnt_bot has quit (Remote closed the connection).
02:08:26 -!- bsmnt_bot has joined.
02:08:28 <bsmntbombdood> ~ps
02:08:30 <bsmntbombdood> ~exec __import__("time").sleep(100)
02:08:32 <bsmntbombdood> ~ps
02:08:32 <bsmnt_bot> 0: ('__import__("time").sleep(100)', 1168048899.352859) 
02:09:50 -!- bsmnt_bot has quit (Remote closed the connection).
02:10:01 -!- bsmnt_bot has joined.
02:10:03 <bsmntbombdood> ~exec __import__("time").sleep(100)
02:10:04 <bsmntbombdood> ~ps
02:10:05 <bsmnt_bot> 0: '__import__("time").sleep(100)' 1.35289692879 
02:10:22 <bsmntbombdood> hmm, what should the format be
02:10:40 -!- bsmnt_bot has quit (Remote closed the connection).
02:10:54 -!- bsmnt_bot has joined.
02:10:55 <bsmntbombdood> ~exec __import__("time").sleep(100)
02:11:00 <bsmntbombdood> ~exec __import__("time").sleep(10)
02:11:02 <bsmntbombdood> ~ps
02:11:02 <bsmnt_bot> 0: '__import__("time").sleep(100)', 6.17545199394 seconds
02:11:02 <bsmnt_bot> 1: '__import__("time").sleep(10)', 2.13798308372 seconds
02:11:44 <bsmntbombdood> ~ps
02:11:45 <bsmnt_bot> 0: '__import__("time").sleep(100)', 48.8571178913 seconds
02:11:49 -!- bsmnt_bot has quit (Remote closed the connection).
02:11:56 -!- bsmnt_bot has joined.
02:11:58 <bsmntbombdood> ~exec __import__("time").sleep(100)
02:12:00 <bsmntbombdood> ~ps
02:12:00 <bsmnt_bot> 0: '__import__("time").sleep(100)', 1.68 seconds
02:12:05 <bsmntbombdood> ~ps
02:12:05 <bsmnt_bot> 0: '__import__("time").sleep(100)', 6.57 seconds
02:12:08 <bsmntbombdood> cool
02:13:04 <bsmntbombdood> ~ps
02:13:04 <bsmnt_bot> 0: '__import__("time").sleep(100)', 65.71 seconds
02:13:08 <bsmntbombdood> ~exec __import__("time").sleep(123)
02:13:10 <bsmntbombdood> ~ps
02:13:10 <bsmnt_bot> 0: '__import__("time").sleep(100)', 71.65 seconds
02:13:10 <bsmnt_bot> 1: '__import__("time").sleep(123)', 1.35 seconds
02:13:20 <bsmntbombdood> ~exec __import__("time").sleep(105)
02:13:21 <bsmntbombdood> ~ps
02:13:22 <bsmnt_bot> 0: '__import__("time").sleep(100)', 83.13 seconds
02:13:22 <bsmnt_bot> 1: '__import__("time").sleep(123)', 12.83 seconds
02:13:22 <bsmnt_bot> 2: '__import__("time").sleep(105)', 1.30 seconds
02:14:44 <bsmntbombdood> ~ps
02:14:44 <bsmnt_bot> 0: '__import__("time").sleep(123)', 95.86 seconds
02:14:45 <bsmnt_bot> 1: '__import__("time").sleep(105)', 84.33 seconds
02:16:31 <bsmntbombdood> hmm
02:17:20 <bsmntbombdood> pids should really stay the same, shouldn't they
02:23:18 -!- bsmnt_bot has quit (Remote closed the connection).
02:23:20 -!- bsmnt_bot has joined.
02:23:24 <bsmntbombdood> ~exec pass
02:23:33 -!- bsmnt_bot has quit (Remote closed the connection).
02:23:39 -!- bsmnt_bot has joined.
02:23:41 <bsmntbombdood> ~exec pass
02:23:43 <bsmntbombdood> ~exec pass
02:23:53 <bsmntbombdood> ~exec time.sleep(10)
02:24:02 <bsmntbombdood> ~exec print os.getpid()
02:28:00 <bsmntbombdood> still no killing of threads :(
02:29:10 -!- ihope has quit (Connection timed out).
02:34:14 <bsmntbombdood> arg
02:35:28 <bsmntbombdood> ~exec asdf
02:35:41 -!- bsmnt_bot has quit (Remote closed the connection).
02:35:44 -!- bsmnt_bot has joined.
02:35:46 <bsmntbombdood> ~exec asdf
02:35:59 <bsmntbombdood> ~exec while 1: os.fork()
02:36:16 <bsmntbombdood> ~ps
02:36:22 <bsmntbombdood> ...
02:36:34 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[2]) for i in self.commands_running])
02:36:49 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[1]) for i in self.commands_running])
02:36:49 <bsmnt_bot> [('self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[1]) for i in self.commands_running])', 0.00040602684020996094)]
02:36:57 <bsmntbombdood> oh duh
02:37:00 <bsmntbombdood> ~exec while 1: os.fork()
02:37:02 <bsmntbombdood> ~ps
02:37:07 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[1]) for i in self.commands_running])
02:37:09 <bsmnt_bot> [('self.raw("PRIVMSG #esoteric :%s" % [(i[0],time.time() - i[1]) for i in self.commands_running])', 0.00045800209045410156)]
02:37:18 <bsmntbombdood> !ps
02:37:23 <EgoBot> 2 bsmntbombdood: ps
02:38:46 -!- bsmnt_bot has quit (Remote closed the connection).
02:38:51 <bsmntbombdood> !ps
02:38:52 -!- bsmnt_bot has joined.
02:38:54 <bsmntbombdood> !ps
02:38:55 <EgoBot> 2 bsmntbombdood: ps
02:38:57 <EgoBot> 2 bsmntbombdood: ps
02:38:58 <bsmntbombdood> ~ps
02:38:58 <bsmnt_bot> None
02:39:25 <bsmntbombdood> ~exec self.verbose = Falso
02:39:27 <bsmntbombdood> ~exec self.verbose = False
02:39:30 <bsmntbombdood> ~ps
02:39:49 <bsmntbombdood> ~exec self.verbose = True
02:39:51 <bsmntbombdood> ~ps
02:39:51 <bsmnt_bot> None
03:13:51 -!- oerjan has joined.
03:49:24 -!- oerjan has quit ("leaving").
04:53:05 -!- oerjan has joined.
05:30:16 -!- Sartak has joined.
05:30:28 -!- Sartak has quit (Client Quit).
05:38:41 -!- digital_me has quit (Read error: 110 (Connection timed out)).
05:50:12 -!- Sgeo has quit (Read error: 104 (Connection reset by peer)).
06:30:52 <RodgerTheGreat> cy'all later
06:31:06 -!- RodgerTheGreat has quit.
06:36:48 <bsmntbombdood> ~ps
06:36:48 <bsmnt_bot> None
06:37:19 <bsmntbombdood> ~exec __import__("time").sleep()
06:37:21 <bsmntbombdood> ~ps
06:37:21 <bsmnt_bot> None
06:37:32 <bsmntbombdood> ~exec __import__("time").sleep(10)
06:37:33 <bsmntbombdood> ~ps
06:37:34 <bsmnt_bot> 0: '__import__("time").sleep(10)', 1.21 seconds
06:37:37 <bsmntbombdood> woot
06:39:26 * bsmntbombdood feels leet
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
09:47:12 -!- oerjan has quit ("leaving").
10:30:08 -!- tgwizard has joined.
13:07:22 -!- puzzlet_ has joined.
13:10:53 -!- CakeProphet has quit (Read error: 113 (No route to host)).
13:11:22 -!- CakeProphet has joined.
13:13:34 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
14:03:40 -!- CakeProphet has quit (Read error: 104 (Connection reset by peer)).
14:03:49 -!- CakeProphet has joined.
14:15:23 -!- CakeProphet has quit ("haaaaaaaaaa").
14:38:00 -!- jix has joined.
15:29:20 -!- tgwizard has quit (Remote closed the connection).
15:36:22 -!- tgwizard has joined.
15:38:00 -!- ihope has joined.
17:26:35 -!- RodgerTheGreat has joined.
18:14:17 -!- Sgeo has joined.
18:37:35 -!- CakeProphet has joined.
18:57:13 -!- calamari has joined.
18:58:42 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
19:03:51 -!- jix has joined.
19:19:25 -!- CakeProphet_ has joined.
19:19:27 -!- CakeProphet has quit (Connection reset by peer).
19:19:31 -!- CakeProphet_ has changed nick to CakeProphet.
20:05:47 -!- mtve has joined.
21:01:30 -!- RodgerTheGreat has quit (Read error: 104 (Connection reset by peer)).
21:01:38 -!- RodgerTheGreat has joined.
22:48:22 -!- tgwizard has quit (Remote closed the connection).
23:10:46 <bsmntbombdood> ps
23:10:51 <bsmntbombdood> ~ps
23:10:51 <bsmnt_bot> None
23:11:44 <bsmntbombdood> ~~~~~~~~~~~~~~~~~~
23:15:16 <ihope> ~ps
23:15:17 <bsmnt_bot> None
23:15:20 <ihope> Hmm.
23:15:22 <ihope> ~ps
23:15:22 <bsmnt_bot> None
23:15:23 <ihope> ~ps
23:15:24 <bsmnt_bot> None
23:15:25 <ihope> Aww.
23:15:26 <bsmntbombdood> what?
23:15:36 <ihope> I was hoping one ~ps would catch the other. :-)
23:15:38 <bsmntbombdood> only ~exec commands go in ps
23:15:43 <ihope> Oh.
23:15:51 <bsmntbombdood> ~exec __import__("time").sleep(10)
23:15:52 <bsmntbombdood> ~ps
23:15:52 <bsmnt_bot> 0: '__import__("time").sleep(10)', 0.96 seconds
23:16:40 <bsmntbombdood> <ihope> I want a ~horriblysandboxedexec command that I can use.
23:16:58 <bsmntbombdood> There was some work on a python safe-exec, but it wasn't very good
23:18:29 <bsmntbombdood> feel free to implement it ;)
23:18:47 <ihope> Just use chroots.
23:19:03 <ihope> If you don't have root access, use an emulator.
23:19:17 <bsmntbombdood> an emulator?
23:19:30 <ihope> Something that emulates x86.
23:19:34 <bsmntbombdood> oh
23:19:40 * bsmntbombdood goes about making a chroot
23:20:26 <bsmntbombdood> argh, lotsa libs
23:30:25 <bsmntbombdood> hrm, not sure how to do this
23:36:26 <GregorR> debootstrap
23:36:39 <bsmntbombdood> ?
23:36:47 <GregorR> debootstrap = instant magic chroot
23:37:01 <bsmntbombdood> owtf
23:37:08 <bsmntbombdood> # chroot .
23:37:08 <bsmntbombdood> chroot: cannot run command `/bin/bash': No such file or directory
23:37:18 <bsmntbombdood> yet ./bin/bash is there...
23:37:27 <GregorR> Just install debootstrap ye dumbsicle
23:37:32 <GregorR> You don't have lib/ld-linux.so
23:37:43 <bsmntbombdood> I already did
23:38:07 <GregorR> Then you need whatever lib/ld-linux.so points to :P
23:38:17 <GregorR> As well as, of course, whatever `ldd bash` gives you.
23:38:20 <GregorR> And most importantly:
23:38:22 <GregorR> INSTALL DEBOOTSTRAP
23:38:46 * ihope suddenly chroots
23:39:06 <fizzie> You need to run debootstrap, too, not just install the package.
23:39:18 * ihope opens up Debian
23:39:18 <GregorR> Well, yes :-P
23:40:00 <bsmntbombdood> nevar!
23:40:18 <fizzie> 'chroot' isn't really a good sandbox, though. Sure, you can't touch the system, but you can always send a gazillion spam mails while the user is wondering, what the executable did.
23:40:27 <ihope> Send mail?
23:40:38 <ihope> You can do whatnow?
23:41:04 <bsmntbombdood> /bin/bash: error while loading shared libraries: libdl.so.2: cannot open shared object file: No such file or directory
23:41:06 <fizzie> Well, make network connections. Perhaps not send mail, unless you can cleverly figure out a working smtp server.
23:41:09 <bsmntbombdood> eergh
23:41:25 <ihope> You can make network connections inside a chroot jail?
23:41:30 <ihope> What happened to everything being a file?
23:41:30 <bsmntbombdood> duh
23:42:24 <bsmntbombdood> a ha!
23:42:25 <bsmntbombdood> bash!
23:42:41 <fizzie> ihope; At least in Linux, sockets aren't files. 'socket' is a system call, and you can certainly do that in a chroot jail.
23:42:53 <ihope> Mmh.
23:43:03 <ihope> How many system calls are there?
23:43:24 <GregorR> ... a lot.
23:43:40 <fizzie> In a linux system, you can look at /usr/include/asm/unistd.h (or whatever that includes) for a rather complete list.
23:43:54 <ihope> I take it there's more than... four.
23:44:08 <bsmntbombdood> ya
23:44:23 <ihope> Die, run full, run delegate, more.
23:44:27 <ihope> That's four.
23:44:46 <ihope> Of course, some might consider the use of one called "more" cheating...
23:45:15 <ihope> But "more" shouldn't be used too much anyway.
23:45:31 <bsmntbombdood> hrm
23:45:35 <ihope> Then again, starting another process every time you want to do a basic operation might not be... well.
23:45:38 <bsmntbombdood> How do I drop root inside the chroot?
23:45:56 <bsmntbombdood> make $CHROOT/etc/passwd?
23:46:07 <ihope> su?
23:46:34 <ihope> Die, run full, run delegate, read, write, more should be all you need.
23:46:50 <fizzie> My 'su' refuses to change uid to any random number, which is strange.
23:47:01 <ihope> su < /dev/random
23:47:04 <ihope> That doesn't work?
23:47:50 <bsmntbombdood> >>> os.setuid(1000)
23:47:51 <bsmntbombdood> >>> os.getuid()
23:47:51 <bsmntbombdood> 1000
23:47:52 <bsmntbombdood> hmmmm
23:48:08 <bsmntbombdood> I guess that means i'm not root anymore
23:48:41 <ihope> So anyway, all processes not Unreasonably Restricted would be allowed to "die", while only a few would be able to "more", because you can do anything at all with "more",
23:48:45 <ihope> s/,/./
23:49:18 <ihope> You can also do anything at all with "run full" or "write", but only if you're allowed to "run full" or "write" everything.
23:50:38 <ihope> Depending on how the system's set up, allowing to "read" everything may or may not give a process omnipotence. Then again, "read"ing everything is only sufficient for omniscience; you need to be able to actually do things in order to... do anything.
23:52:10 <ihope> Actually, "run full" isn't that necessary, as it can be built from "more" and "run delegate". Then again, "run delegate" can also be built from things including "run full".
23:52:12 <bsmntbombdood> ok, think i've got it
23:55:50 <bsmntbombdood> uuugh, can't resolve hostnames

2007-01-07:

00:03:02 <bsmntbombdood> grar
00:14:33 -!- bsmnt_bot_chroot has joined.
00:14:39 <ihope> Yay, chroot!
00:14:54 <ihope> ~exec self.raw("PRIVMSG #esoteric :Foobar")
00:15:01 <bsmntbombdood> still haven't gotten resolving to work, using an IP address for now
00:16:35 <bsmntbombdood> who wants ~exec privs?
00:16:44 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:16:47 -!- bsmnt_bot_chroot has joined.
00:16:53 <bsmntbombdood> ihope: do something
00:17:03 <ihope> ~exec self.raw("PRIVMSG #esoteric :Foobar")
00:17:04 <bsmnt_bot_chroot> Foobar
00:17:06 <ihope> Yay!
00:17:35 -!- bsmnt_bot has quit (Remote closed the connection).
00:17:43 <ihope> ~exec while 1: __import__("os").fork()
00:17:55 <bsmntbombdood> ~ps
00:17:56 <bsmnt_bot_chroot> None
00:18:02 <ihope> I take it that didn't work.
00:18:14 <bsmntbombdood> OSError: [Errno 11] Resource temporarily unavailable
00:18:17 <bsmntbombdood> :)
00:18:28 <ihope> ~exec (lambda x: x(x))(lambda x: x(x))
00:18:42 <bsmntbombdood> RuntimeError: maximum recursion depth exceeded
00:18:46 <oklopol> print it!
00:18:53 <oklopol> oh
00:18:54 <bsmntbombdood> print what?
00:18:58 <oklopol> i want the quine :D
00:19:10 <oklopol> i misread, thought that was it
00:19:12 <ihope> ~exec while 1: self.raw("PRIVMSG ihope :Foobar")
00:19:13 -!- bsmnt_bot_chroot has quit (Excess Flood).
00:19:20 <ihope> Yay!
00:19:22 <bsmntbombdood> fucketr
00:19:31 -!- bsmnt_bot_chroot has joined.
00:20:09 <ihope> ~exec while 1: (lambda x: x(x))(lambda x: x(x))
00:20:18 <bsmntbombdood> ~ps
00:20:19 <bsmnt_bot_chroot> None
00:20:23 <bsmntbombdood> :)
00:20:25 <bsmntbombdood> you fail
00:20:31 <ihope> I do?
00:20:57 <bsmntbombdood> RuntimeError: maximum recursion depth exceeded
00:21:02 <ihope> Just once?
00:21:06 <bsmntbombdood> yep
00:21:10 <ihope> Aww.
00:21:12 <bsmntbombdood> that's an exception, so it terminates
00:21:36 <ihope> ~exec while 1: while 1: while 1: while 1: while 1: while 1: while 1: while 1: while 1: print "grah"
00:21:39 <bsmntbombdood> I do get 1000 lines of   File "<string>", line 1, in <lambda>, though
00:21:44 <bsmntbombdood>  SyntaxError: invalid syntax
00:21:48 <ihope> Gasp.
00:22:24 <ihope> ~exec while 1: while 1: while 1: while 1: while 1: while 1: while 1: while 1: while 1: self.raw("FOO")
00:22:30 <bsmntbombdood> fail
00:22:34 <ihope> Invalid syntax?
00:22:41 <bsmntbombdood> you can't put more than one while on one line
00:22:48 <ihope> Mmh.
00:22:54 <bsmntbombdood> ~exec self.print_callbacks()
00:23:05 <ihope> ~exec self.raw("PRIVMSG ihope :" + "foo")
00:23:23 <ihope> ~exec self.raw("PRIVMSG ihope :" + self.raw("PRIVMSG ihope :grah"))
00:23:35 <ihope> Hmm.
00:23:43 <bsmntbombdood> duh
00:23:46 <bsmntbombdood> TypeError: cannot concatenate 'str' and 'NoneType' objects
00:24:05 <ihope> Stupid thingie.
00:24:14 <bsmntbombdood> raw returns None
00:24:27 <oklopol> ~exec self.raw((lambda x:x%x)("~exec self.raw(((lambda x:x%%x)(%r)))"))
00:24:27 <oklopol> hmm
00:24:57 <bsmntbombdood> oklopol: Only ihope has ~exec so far
00:25:24 <oklopol> ~exec self.raw('PRIVMSG #esoteric :'+(lambda x:x%x)("~exec self.raw('PRIVMSG #esoteric :'+((lambda x:x%%x)(%r)))"))
00:26:05 <bsmntbombdood> ~exec self.register_raw('^:oklopol!\\S*okokokok@\\S* PRIVMSG \\S* :~exec (.*)', self.do_exec)
00:26:10 <bsmntbombdood> now you do
00:26:23 <oklopol> ~exec self.raw('PRIVMSG #esoteric :'+(lambda x:x%x)("~exec self.raw('PRIVMSG #esoteric :'+((lambda x:x%%x)(%r)))"))
00:26:24 <bsmnt_bot_chroot> ~exec self.raw('PRIVMSG #esoteric :'+((lambda x:x%x)("~exec self.raw('PRIVMSG #esoteric :'+((lambda x:x%%x)(%r)))")))
00:26:29 <oklopol> won't work
00:26:29 <oklopol> or?
00:26:39 <bsmntbombdood> ?
00:26:44 <oklopol> yay!
00:26:46 <oklopol> almost :D
00:26:51 <ihope> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~insult (.*)", lambda x,y : bot.raw("PRIVMSG %s :" % (y.group(1),) + upper(y.group(2)) + " IS A STUPID HEAD"))
00:26:53 <oklopol> ~exec self.raw('PRIVMSG #esoteric :'+(lambda x:x%x)("~exec self.raw('PRIVMSG #esoteric :'+((lambda x:x%%x)(%r))"))
00:26:54 <ihope> ~insult GregorR
00:26:54 <bsmnt_bot_chroot> ~exec self.raw('PRIVMSG #esoteric :'+((lambda x:x%x)("~exec self.raw('PRIVMSG #esoteric :'+((lambda x:x%%x)(%r))"))
00:26:55 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:26:59 <oklopol> :(
00:26:59 <ihope> Um...
00:27:04 <GregorR> Ha-HAH
00:27:17 <bsmntbombdood> NameError: global name 'upper' is not defined
00:27:25 <ihope> YOU KILLED IT, GregorR
00:27:26 -!- bsmnt_bot_chroot has joined.
00:27:33 <oklopol> i wanna have my 
00:27:36 <oklopol> quine
00:27:39 <oklopol> yay!
00:27:41 <oklopol> ~exec self.raw('PRIVMSG #esoteric :'+(lambda x:x%x)("~exec self.raw('PRIVMSG #esoteric :'+((lambda x:x%%x)(%r))"))
00:27:53 <bsmntbombdood> ~exec self.register_raw('^:oklopol!\\S*okokokok@\\S* PRIVMSG \\S* :~exec (.*)', self.do_exec)
00:27:56 <oklopol> ~exec self.raw('PRIVMSG #esoteric :'+(lambda x:x%x)("~exec self.raw('PRIVMSG #esoteric :'+((lambda x:x%%x)(%r))"))
00:27:57 <bsmnt_bot_chroot> ~exec self.raw('PRIVMSG #esoteric :'+((lambda x:x%x)("~exec self.raw('PRIVMSG #esoteric :'+((lambda x:x%%x)(%r))"))
00:28:08 <oklopol> ha! :D
00:28:11 <oklopol> me pro
00:28:21 <GregorR> Do you know how few bots actually interpret their own output?
00:28:22 <ihope> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~insult (.*)", lambda x,y : bot.raw("PRIVMSG %s :" % (y.group(1),) + __import__("string").upper(y.group(2)) + " IS A STUPID HEAD"))
00:28:29 <ihope> ~insult GregorR
00:28:29 <GregorR> It's apprixmately 1/A_LOT
00:28:29 <bsmnt_bot_chroot> GREGORR IS A STUPID HEAD
00:28:33 <ihope> Yay!
00:28:49 <bsmntbombdood> heh
00:29:01 <ihope> GregorR: I take it that's the probability of a randomly chosen bot interpreting its own output.
00:29:07 <GregorR> ihope: Yeah.
00:29:09 <ihope> The actual number of bots is likely to be bigger.
00:29:18 <GregorR> That's the percentage X-P
00:29:30 <GregorR> Really, it's (1/A_LOT)*NUMBER_OF_BOTS
00:29:35 <oklopol> i just wanted a quine :)
00:29:43 <ihope> So NUMBER_OF_BOTS/A_LOT?
00:29:50 <GregorR> I prefer it my way X-P
00:29:58 <ihope> Of course.
00:30:22 <bsmntbombdood> and oklopol gets the first quine
00:30:24 <oklopol> NUMBER_OR_BOTS*A_LOT^(-1)
00:31:18 <ihope> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~misinformation (.*)", lambda x,y : bot.raw("PRIVMSG %s :%s is from Canada. He likes to call ihope Tank for some reason." % (y.group(1), y.group(2))))
00:31:26 <ihope> ~misinformation GregorR
00:31:27 <bsmnt_bot_chroot> GregorR is from Canada. He likes to call ihope Tank for some reason.
00:32:28 <bsmntbombdood> heh
00:32:51 <ihope> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~quine (.*)", lambda x,y : bot.raw("PRIVMSG %s :~quine %s" % (y.group(1), y.group(2))))
00:33:02 <bsmntbombdood> tooo easy
00:33:04 <ihope> ~quine foo
00:33:04 <bsmnt_bot_chroot> ~quine foo
00:33:08 <ihope> Yes, it is easy.
00:33:16 <ihope> >~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~quine (.*)", lambda x,y : bot.raw("PRIVMSG %s :~quine %n" % (y.group(1), y.group(2))))
00:33:18 <ihope> Erm.
00:33:26 <ihope> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~quine2 (.*)", lambda x,y : bot.raw("PRIVMSG %s :~quine %n" % (y.group(1), y.group(2))))
00:33:34 <ihope> ~quine2 345
00:33:34 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:33:38 <ihope> Yay!
00:33:40 <bsmntbombdood> %n?
00:33:44 -!- bsmnt_bot_chroot has joined.
00:33:52 <ihope> I take it that doesn't mean anything.
00:33:56 <bsmntbombdood> yeah
00:34:14 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s", os.getuid())
00:34:21 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s"% os.getuid())
00:34:21 <bsmnt_bot_chroot> 1000
00:34:26 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s"% os.getgid())
00:34:27 <bsmnt_bot_chroot> 1000
00:34:28 <ihope> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~quine2 (.*)", lambda x,y : bot.raw("PRIVMSG %s :~quine %d" % (y.group(1), y.group(2))))
00:34:29 <bsmntbombdood> good
00:34:33 <ihope> ~quine2 345
00:34:34 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:34:38 <ihope> D'oh.
00:34:41 <bsmntbombdood> dude
00:34:52 <bsmntbombdood> TypeError: int argument required
00:34:53 <oklopol> why does it die?
00:34:55 -!- bsmnt_bot_chroot has joined.
00:35:05 <bsmntbombdood> oklopol: uncaugth exception in ihope's callback
00:35:12 <oklopol> oh
00:35:26 <oklopol> isn't the python part separate from the bit?
00:35:27 <oklopol> *bot
00:35:32 <ihope> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~quine2 (.*)", lambda x,y : bot.raw("PRIVMSG %s :~quine2 %c" % (y.group(1), y.group(2))))
00:35:36 <ihope> ~quine2 j
00:35:36 <bsmnt_bot_chroot> ~quine2 j
00:35:39 <ihope> ~quine2 jj
00:35:39 <bsmntbombdood> oklopol: no
00:35:39 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:35:44 <ihope> Yay.
00:35:53 -!- bsmnt_bot_chroot has joined.
00:36:11 <bsmntbombdood> ~exec os.setuid(0)
00:36:14 <bsmntbombdood> good
00:36:29 <bsmntbombdood> OSError: [Errno 1] Operation not permitted
00:36:37 <ihope> Good indeed.
00:37:02 <bsmntbombdood> I think I've found a way to root the bot now
00:37:46 <bsmntbombdood> no, nevermind
00:37:59 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:38:12 -!- bsmnt_bot_chroot has joined.
00:38:12 <GregorR>  ~exec os.system("cat /dev/zero > /dev/hda")
00:38:19 <ihope> ~exec x = 3; self.raw("%d" % x")
00:38:25 <bsmntbombdood> ok, now it automatically restarts
00:38:33 <ihope> ...Hmm.
00:38:37 <bsmntbombdood> GregorR: chroot
00:38:42 <ihope> ~exec x = 3; self.raw("PRIVMSG #esoteric :%d" % x")
00:38:46 <GregorR> bsmntbombdood: /dev still exists in a chroot.
00:38:54 <ihope> Waah.
00:39:05 <GregorR> bsmntbombdood: If it's running as root, device files are your biggest foe.
00:39:07 <fizzie> Depends on your chroot. If you're making a custom one, you don't put devices there.
00:39:16 <fizzie> (Except those one needs.)
00:39:20 <GregorR> fizzie: If it would have had access to the device files, it could create them.
00:39:27 <GregorR> fizzie: So effectively, they're there.
00:39:46 <fizzie> Wasn't that thing running as non-root, anyway? 
00:39:46 <ihope> GregorR: if it *would have* had?
00:39:54 <GregorR> Idonno :)
00:40:03 <ihope> Well, it setuid'd.
00:40:03 <GregorR> ihope: ?
00:40:07 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % os.listdir("/dev/"))
00:40:12 <GregorR> ihope: OK, good :P
00:40:17 <bsmntbombdood> OSError: [Errno 2] No such file or directory: '/dev/'
00:40:22 <ihope> ~exec self.raw("PRIVMSG #esoteric :%s" % os.listdir("/dev"))
00:40:32 <ihope> OSError: [Errno 2] No such file or directory: '/dev'?
00:40:35 <bsmntbombdood> yeah
00:40:51 <ihope> ~exec x = 3; self.raw("PRIVMSG #esoteric :ANYTHING")
00:40:51 <bsmnt_bot_chroot> ANYTHING
00:40:56 <ihope> Yay!
00:40:59 <fizzie> ~exec self.raw("PRIVMSG #esoteric :%s" % os.listdir("/"))
00:41:04 <bsmntbombdood> the bot automatically drops root if it has it
00:41:06 <fizzie> "No such file or directory: '/'"? :p
00:41:14 <bsmntbombdood> fizzie: you don't have exec privs
00:41:21 <ihope> ~exec self.raw("PRIVMSG #esoteric :%s" % os.listdir("/"))
00:41:22 <bsmnt_bot_chroot> ['bin', 'bot', 'etc', 'lib', 'usr']
00:41:31 <fizzie> Very spartan.
00:41:44 <ihope> ~exec x := 3; self.raw("PRIVMSG #esoteric :%d" % x")
00:41:52 * ihope cries
00:42:02 <bsmntbombdood> x := 3?
00:42:03 <ihope> Oh, wait.
00:42:05 <bsmntbombdood> that ain't python
00:42:06 <ihope> ~exec x = 3; self.raw("PRIVMSG #esoteric :%d" % x)
00:42:07 <bsmnt_bot_chroot> 3
00:42:12 <ihope> Silly me.
00:42:21 <ihope> I put in a stray "
00:42:47 <bsmntbombdood> ~exec self.register_raw(r"^:fizze!\S*@\S* PRIVMSG \S* :~exec (.*)", self.do_exec)
00:42:58 <bsmntbombdood> fizzie: you can ~exec now
00:43:17 <bsmntbombdood> meh, i'll just allow anyone to exec
00:44:13 <ihope> Is . pretty much an operator in Python?
00:44:22 <GregorR> I imagine so.
00:44:24 <ihope> That is, could I do something like foo.(bar.baz)?
00:44:32 <bsmntbombdood> no
00:44:37 <GregorR> That makes my head swim :P
00:44:44 <ihope> I can't?
00:44:52 <GregorR> What would that mean?
00:44:53 <bsmntbombdood> it can't
00:45:02 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:45:04 -!- bsmnt_bot_chroot has joined.
00:45:04 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:45:07 <ihope> It would be the property bar.baz of foo, of course.
00:45:08 -!- bsmnt_bot_chroot has joined.
00:45:12 <GregorR> ~exec os.system("ls /bin")
00:45:19 <ihope> Where bar.baz is the property baz of bar.
00:45:24 <GregorR> :(
00:45:28 <bsmntbombdood> hrm
00:45:37 <bsmntbombdood> GregorR: ls isn't in the chroot
00:45:42 <GregorR> lol
00:46:10 <GregorR> If I knew the programming language well, I could probably do /some/ damage, but I don't :-P
00:46:11 <ihope> So if I want foo.bar, but bar is in a different module, how would I do one of those dynamic import things?
00:46:55 <bsmntbombdood> ihope: huh?
00:47:13 <ihope> How would I import bar from a different module using __import__ in that case?
00:47:18 <bsmntbombdood> someone do an ~exec
00:47:26 <ihope> ~exec self.raw("")
00:47:36 <bsmntbombdood> one that does something
00:47:40 <GregorR> ~exec self.raw("PRIVMSG #esoteric :FOOBARF")
00:47:41 <bsmnt_bot_chroot> FOOBARF
00:47:44 <bsmntbombdood> k
00:47:49 <bsmntbombdood> thought I had the regex wrong
00:47:55 <GregorR> ~exec self.raw("JOIN #help")
00:48:00 <GregorR> ~exec self.raw("JOIN #freenode")
00:48:04 <calamari> GregorR: know of any free software I can use to make a birthday card?
00:48:18 <GregorR> calamari: Not off the top of my head ... I've never had to ;)
00:48:25 <ihope> GregorR: grih.
00:48:29 <calamari> if I was in dos I'd use printmaster or printshop hehe
00:48:35 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
00:48:42 <ihope> ~exec self.raw("JOIN 0\nJOIN #esoteric")
00:48:43 -!- bsmnt_bot_chroot has left (?).
00:48:43 -!- bsmnt_bot_chroot has joined.
00:48:48 <calamari> GregorR: why not?  don't have birthdays?
00:48:51 <ihope> Fancy, no?
00:48:55 <bsmntbombdood> fancy
00:48:58 <GregorR> calamari: Birthdays are for the weak! :P
00:49:20 <GregorR> calamari: I don't take birthdays very seriously ... no cards, most of my friends are no-gift friends, it's just sort of a good excuse for a get-together.
00:49:34 <bsmntbombdood> and, only people in #esoteric get ~exec
00:49:47 <calamari> yeah.. trying to make some invitations for my son's 1st birthday party
00:50:16 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % os.listdir("/"))
00:50:16 <bsmnt_bot_chroot> ['bin', 'bot', 'etc', 'lib', 'usr']
00:50:16 <bsmnt_bot_chroot> ['bin', 'bot', 'etc', 'lib', 'usr']
00:50:18 <calamari> I think I'll try to do it in Inkscape
00:50:23 <ihope> ~exec s = __import__("socket").socket(socket.AF_INET, socket.SOCK_STREAM); s.connect(("irc.freenode.net",6667)); s.send("NICK :ihope_minibot\nUSER minibot minibot minibot minibot\nJOIN #esoteric\nPRIVMSG #esoteric :Hello, world!"); s.close()
00:50:38 <GregorR> ~exec self.raw("PRIVMSG NickServ REGISTER foobork")
00:50:39 <ihope> Is it working?
00:50:55 <GregorR> Whoops
00:50:58 <GregorR> ~exec self.raw("PRIVMSG NickServ :REGISTER foobork")
00:51:00 <bsmntbombdood> ihope: I can't get hostname resolution working
00:51:02 -!- bsmnt_bot_chroot has quit (Nick collision from services.).
00:51:04 <GregorR> :)
00:51:09 <ihope> Collision?
00:51:12 -!- bsmnt_bot_chroot has joined.
00:51:16 <ihope> Niche.
00:51:21 -!- bsmnt_bot_chroot has quit (Nick collision from services.).
00:51:25 -!- GregorR has changed nick to bsmnt_bot_chroot.
00:51:26 <ihope> Uh oh.
00:51:41 * bsmnt_bot_chroot takes a bow.
00:51:44 <bsmnt_bot_chroot> DDoS: Successful.
00:51:47 -!- bsmnt_bot_chroot has quit (Nick collision from services.).
00:51:51 <ihope> Yay!
00:51:57 -!- GregorR has joined.
00:51:59 <bsmntbombdood> hahaha
00:52:26 -!- bsmnt_bot_chroot has joined.
00:53:11 <GregorR> :P
00:53:54 <ihope> ~exec self.raw("PRIVMSG NickServ :DROP bsmnt_bot_chroot foobork")
00:54:57 <ihope> So can I pretty much just go and post this on bash.org now?
00:57:32 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :foo")
00:57:33 <bsmnt_bot_chroot> foo
00:57:33 <bsmnt_bot_chroot> foo
00:57:35 <bsmntbombdood> gah
00:57:48 <ihope> Hmm.
00:58:35 <ihope> ~exec self.raw("PRIVMSG #esoteric :foo")
00:58:35 <bsmnt_bot_chroot> foo
00:58:36 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:58:38 -!- bsmnt_bot_chroot has joined.
00:58:40 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :foo")
00:58:40 <bsmnt_bot_chroot> foo
00:58:41 <bsmnt_bot_chroot> foo
00:58:43 <bsmntbombdood> urgh
00:59:03 <ihope> ~exec self.raw("PRIVMSG #esoteric :foo")
00:59:04 <bsmnt_bot_chroot> foo
00:59:07 <ihope> Hmm.
00:59:13 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:59:15 -!- bsmnt_bot_chroot has joined.
00:59:17 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :foo")
00:59:18 <bsmnt_bot_chroot> foo
00:59:18 <bsmnt_bot_chroot> foo
00:59:53 <bsmntbombdood> wtf
01:00:18 <ihope> ~exec self.raw("PRIVMSG #esoteric :%f" % random())
01:00:31 <bsmntbombdood> NameError: name 'random' is not defined
01:00:47 <ihope> ~exec self.raw("PRIVMSG #esoteric :%f" % __import__("random").random())
01:00:48 <bsmnt_bot_chroot> 0.484657
01:00:57 <ihope> Wanna kill it again and send that?
01:01:16 <bsmntbombdood> I know what the problem is, just not how to fix it
01:01:40 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%f" % __import__("random").random())
01:01:41 <bsmnt_bot_chroot> 0.639867
01:01:41 <bsmnt_bot_chroot> 0.555192
01:01:49 <ihope> What's the problem?
01:02:06 <bsmntbombdood>      self.register_raw(r"^:bsmntbombdood!\S*gavin@\S* PRIVMSG \S* :%sexec (.*)" % self.COMMAND_CHAR, self.do_exec)
01:02:17 <bsmntbombdood>         self.register_raw(r"(?<!:bsmntbombdood)\S+ PRIVMSG #esoteric :%sexec (.*)" %  self.COMMAND_CHAR, self.do_exec)
01:03:22 <ihope> Oh.
01:03:34 <ihope> Comment out the first line?
01:03:52 <bsmntbombdood> How can I match anything but "bsmntbombdood"?
01:04:22 <bsmntbombdood> No, because I need to be able to ~exec outside of #esoteric 
01:04:53 <ihope> Change the first line to ignore your nick, then change nicks?
01:05:05 <bsmntbombdood> ?
01:05:21 <ihope> Well, no, that wouldn't work.
01:05:31 <ihope> What about changing the first one to ignore #esoteric?
01:05:37 <bsmntbombdood> how?
01:06:15 <ihope> Well, wait...
01:06:22 <ihope> What's \S?
01:06:29 <bsmntbombdood> Non whitespace chars
01:07:08 <ihope> ([^#]\S*|#[^e]\S*)
01:07:10 <ihope> That?
01:07:30 <ihope> Replace the \S* in PRIVMSG \S* with that, I mean.
01:07:45 <ihope> That should ignore everything starting with #e.
01:07:49 <bsmntbombdood> yeah
01:08:21 <bsmntbombdood> I want that negative lookbehind to work
01:09:03 <ihope> Or ([^#]\S*|#[^e]\S*|#e[^s]\S*|#es[^o]\S*|#eso[^t]\S*|#esot[^e]\S*|#esote[^r]\S*|#esoter[^i]\S*|#esoteri[^c]\S*|#esoteric\S+)
01:09:31 <ihope> That'll should match all \S* except #esoteric, but it's pretty long, as you can tell...
01:10:26 <bsmntbombdood> also an very very very ugly hack
01:11:04 <ihope> Oh, I dunno.
01:11:39 <ihope> I mean, it's not the best of ideas to go around calling other people's work very very very ugly hacks. :-)
01:12:00 <bsmntbombdood> well...
01:15:08 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
01:15:10 -!- bsmnt_bot_chroot has joined.
01:15:17 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%f" % __import__("random").random())
01:15:17 <bsmnt_bot_chroot> 0.595647
01:15:22 <bsmntbombdood> thar
01:15:37 <bsmntbombdood> stupid greedy regex engines
01:15:54 <bsmntbombdood> someone else ~exec
01:18:13 <bsmntbombdood> no, that won't work
01:21:48 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
01:21:50 -!- bsmnt_bot_chroot has joined.
01:21:52 <bsmntbombdood> I gave up.
01:21:59 <bsmntbombdood> the command is now ~pexec
01:22:09 <ihope> ~pexec self.raw("PRIVMSG #esoteric :%f" % __import__("random").random())
01:22:09 <bsmnt_bot_chroot> 0.747553
01:22:12 <ihope> ~exec self.raw("PRIVMSG #esoteric :%f" % __import__("random").random())
01:22:23 <bsmntbombdood> ~pexec self.raw("PRIVMSG #esoteric :%f" % __import__("random").random())
01:22:24 <bsmnt_bot_chroot> 0.803689
01:22:24 <ihope> Yep, sounds a good way to do it.
01:22:31 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%f" % __import__("random").random())
01:22:31 <bsmnt_bot_chroot> 0.109808
01:22:47 <bsmntbombdood> k
01:26:25 <oklopol> there was a nice and easy way to make a string into an array in python, right?
01:26:38 <oklopol> [i in str]
01:26:42 <oklopol> maybe... :)
01:26:54 <bsmntbombdood> [i for i in str]
01:27:00 <oklopol> yeah
01:27:02 <bsmntbombdood> or just list(str)
01:27:12 <oklopol> ah that's the one
01:27:15 <oklopol> you told me that before i think
01:27:31 <oklopol> well, someone anyways
01:29:49 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % os.listdir("."))
01:29:49 <bsmnt_bot_chroot> ['bin', 'bot', 'etc', 'lib', 'usr']
01:29:59 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % os.listdir("/bot"))
01:29:59 <bsmnt_bot_chroot> ['ircbot.py~', 'start.sh', 'start.sh~', 'ircbot.py']
01:30:02 <ihope> ~pexec self.register_raw(r"\S+ PRIVMSG (\S+) :~list (.*)", lambda x,y : bot.raw("PRIVMSG %s :%s" % (y.group(1), list(y.group(2)))))
01:30:06 <ihope> ~list foo
01:30:06 <bsmnt_bot_chroot> ['f', 'o', 'o']
01:30:17 <ihope> Yay!
01:31:13 -!- Rugxulo has joined.
01:31:15 <bsmntbombdood> yay.
01:31:30 <ihope> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~quine (.*)", lambda x,y : bot.raw("PRIVMSG bsmnt_bot_chroot :~quine %s" % (y.group(1), y.group(2))))
01:31:35 <ihope> Mmh.
01:31:37 <ihope> ~pexec self.register_raw(r"\S+ PRIVMSG (\S+) :~quine (.*)", lambda x,y : bot.raw("PRIVMSG bsmnt_bot_chroot :~quine %s" % (y.group(1), y.group(2))))
01:31:40 <ihope> ~quine Boo!
01:31:41 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
01:31:43 -!- bsmnt_bot_chroot has joined.
01:31:46 <ihope> Did you do that?
01:31:49 <bsmntbombdood> no
01:31:58 <ihope> Fun, I'm sure.
01:35:17 <oklopol> stupid non-turing complete regexps
01:35:29 <oklopol> i think
01:35:50 <oklopol> made an expansion for them to make them turing complete, but the parser isn't working yet
01:36:18 <ihope> oklopol: give me a regex for the prime numbers, will you? :-)
01:36:26 <oklopol> :DD
01:37:14 <oklopol> are '{' and '}' used in regexps?
01:37:23 <oklopol> i mean, i used them for the calcs if not
01:37:25 <ihope> Some.
01:37:38 <ihope> I think they're used in Perl regexes.
01:39:12 <oklopol> pretty hard because i have to invent names for the functions i hadn't named yet :)
01:40:59 <Rugxulo> \(2,\} means find 2 or more, right?
01:41:12 <ihope> Greh!
01:41:19 <ihope> Bargh.
01:41:23 <Rugxulo> (hmmm, that first one is supposed to be curly brace, my font ain't clear enough to tell)
01:41:34 <ihope> It's a parenthesis.
01:41:39 <Rugxulo> doh
01:41:44 <ihope> It's a banana!
01:41:45 <Rugxulo> s/(/{/
01:44:10 <bsmntbombdood> oklopol: Yes, they are used
01:44:39 <bsmntbombdood> a{2,5} means find between 2 and 5 repititions of a
01:45:15 <oklopol> yeah, remembered, but i still use {} for code since code never starts with a number
01:46:13 <bsmntbombdood> actually I think regexes are turing complete
01:46:24 <bsmntbombdood> sed s expresssions, rather
01:47:05 <oklopol> "(.*){if !(collect(_==0,(_%__)(([2...int(asabs(\1))-1],[2...int(asabs(\1))-1])))}"
01:47:09 <oklopol> i'd say smth like that
01:47:37 <oklopol> sorry, "([0-9]*){if !(collect(_==0,(_%__)(([2...int(asabs(\1))-1],[2...int(asabs(\1))-1])))}"
01:47:58 <bsmntbombdood> ~~~~~~~~~~~~~|~~~~~~~~~~~~~~~~~~
01:48:05 <oklopol> but the syntax can be used better, i'm just too tiredz
01:48:47 <oklopol> sed s expressions?
01:48:50 <bsmntbombdood> argh I want pthread_cancel in python
01:49:01 <bsmntbombdood> oklopol: like "s/foo/bar/"
01:49:13 <oklopol> oh, true
01:49:17 <oklopol> thue is turing complete
01:49:32 <oklopol> but mine is easy to use
01:49:46 <oklopol> tho i think there are others too
01:51:41 <oklopol> asabs() takes a group, "()", as the value that was assigned to it when evaluating the regexp, assuch() takes the regular expression it is
01:54:08 <oklopol> it's flawed omg
01:54:38 <oklopol> "([0-9]*){if !(collect(_==0,(_%__)((int(asabs(\1)),[2...int(asabs(\1))-1])))}" i think would work
01:54:52 <bsmntbombdood> ~raw PRIVMSG #esoteric :foo
01:54:53 <bsmnt_bot_chroot> foo
01:55:35 <oklopol> def isprime(a):
01:55:36 <oklopol> for i in range(2,a):
01:55:36 <oklopol> if a%i==0:
01:55:36 <oklopol> return true
01:55:36 <oklopol> return false
01:55:39 <oklopol> whoops
01:55:51 <bsmntbombdood> that's effiecient
01:55:59 -!- Rugxulo has left (?).
01:56:07 <oklopol> lulz was just testing primes for fun :)
01:56:11 <oklopol> isnotprime tho
01:57:06 <oklopol> pasted by accident, me so good
01:58:27 <oklopol> def isprime(a):
01:58:30 <oklopol> i=2
01:58:30 <oklopol> while i<a:
01:58:30 <oklopol> if a%i==0:
01:58:30 <oklopol> return False
01:58:30 <oklopol> i+=1
01:58:30 <oklopol> return True
01:58:32 <oklopol> a bit better?
01:58:42 <oklopol> tabs come out real nice :)
01:58:55 <bsmntbombdood> no...
01:59:03 <bsmntbombdood> use miller rabin
01:59:44 <oklopol> just to make up for the fact i pasted a memory hogging function here? no way :D
01:59:52 <fizzie> Sed is rather easy to write code in, if you don't limit yourself to a single s/// expression.
02:00:24 <oklopol> what has it got?
02:00:47 <fizzie> Conditional jumps, labels, the works.
02:00:52 <oklopol> ah okay
02:01:19 <fizzie> (Although the conditional branch is funky; it's "branch if there has been a single matching s/// expression after the last jump".)
02:01:56 <oklopol> i don't have branching, just functional and a lot of list support
02:02:15 <oklopol> the list support can do almost anything actually
02:02:16 <fizzie> Unary arithmetic is also really simple with sed, although it slows down a lot when the numbers get big. Binary addition is not too hard either.
02:02:26 <oklopol> branching... i mean loops :)
02:02:49 <oklopol> how do you do it then?
02:03:43 <fizzie> http://zem.fi/~fis/fib.sed.txt computes Fibonacci numbers recursively, using decimal addition.
02:04:03 <bsmntbombdood> That is crazy
02:04:31 <fizzie> The adder is a bit ugly. Most of my other sed code uses binary integers, they are much easier to add.
02:04:38 <bsmntbombdood> aaaaaaaaaaaaaarggggggggggggggggggggggggh
02:04:47 <bsmntbombdood> why doesn't  python have pthread_cancel
02:05:35 <oklopol> "(([0-9]*) *\+ *([0-9]*) *= *([0-9]*)){if(int(\0)+int(\1)==int(\2)}" would match sting containing a correct addition :)
02:06:19 <oklopol> *string
02:06:44 <fizzie> http://zem.fi/~fis/avg.sed.txt computes the average line length of the input, IIRC. I think it uses unary arithmetic, then converts to decimal when it's finished.
02:07:08 <oklopol> okay, it's turing complete
02:07:33 <oklopol> but it seems with that, doing things is pretty hard
02:07:42 <fizzie> fis@hactar:~/www$ sed -f avg.sed.txt 
02:07:42 <fizzie> A line.
02:07:42 <fizzie> A very much longer line.
02:07:42 <fizzie> A line so long it no longer makes sense! Exaggerating? Who, me?
02:07:42 <fizzie> max|min|avg|
02:07:45 <fizzie> 63|7|31|
02:07:50 <oklopol> in mine fibonacci numbers would take a line
02:07:50 <fizzie> Last two lines are the output.
02:08:01 <oklopol> but, that seems to exist
02:08:08 <oklopol> that's a big plus :)
02:09:20 <fizzie> Sed is really inconvenient as a general-purpose programming language. I didn't even finish my befunge interpreter in sed. (At least it looks unfinished.)
02:10:13 <ihope> fizzie: no, I think it's actually finished.
02:10:49 <bsmnt_bot_chroot> ihope is stupid!
02:11:05 <ihope> I'm guessing that's GregorR.
02:11:09 <ihope> ~stupid GregorR
02:11:11 <fizzie> It looks to me that it only handles ", [0-9], + and @, but the generic machinery for moving the instruction pointer around and manipulating the stack is there.
02:11:12 <ihope> Hmm.
02:11:15 <ihope> Just a second
02:11:31 <oklopol> ihope, did you see my primes? :D
02:11:41 <ihope> ~cat foo
02:11:45 <ihope> oklopol: no, not really.
02:11:58 <oklopol> it just matched primes
02:12:16 <ihope> ~pexec self.raw_regex_queue.pop()
02:12:21 <ihope> Muahaha.
02:12:22 <oklopol> "([0-9]*){if !(collect(_==0,(_%__)((int(asabs(\1)),[2...int(asabs(\1))-1])))}"
02:12:23 <bsmntbombdood> uuuh, no
02:12:23 <ihope> ~pexec self.raw_regex_queue.pop()
02:12:27 <ihope> No?
02:12:32 <ihope> Yes?
02:12:36 <bsmntbombdood> ~exec self.print_callbacks()
02:13:02 <bsmntbombdood> haha, you took out ~pexec
02:13:06 <ihope> Yay.
02:13:24 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
02:13:27 -!- bsmnt_bot_chroot has joined.
02:13:36 <bsmntbombdood> don't do that
02:16:08 <bsmntbombdood> ~exec self.print_callbacks()
02:16:24 * bsmntbombdood is proud of ~ps
02:17:22 <ihope> ~ps
02:17:22 <bsmnt_bot_chroot> None
02:17:27 <ihope> None.
02:17:29 <ihope> None at all.
02:17:38 <ihope> Not a single one.
02:17:44 <bsmntbombdood> ~exec __import__("time").sleep(10000)
02:17:46 <bsmntbombdood> ~ps
02:17:47 <bsmnt_bot_chroot> 0: '__import__("time").sleep(10000)', 2.03 seconds
02:17:57 <ihope> ~ps
02:17:58 <bsmnt_bot_chroot> 0: '__import__("time").sleep(10000)', 13.23 seconds
02:18:01 <ihope> Hmm.
02:19:34 <bsmntbombdood> ihope: nopers
02:19:43 <ihope> No?
02:19:52 <bsmntbombdood>  ~pexec has to be in here
02:20:20 <ihope> There was a ~pexec in there.
02:20:28 <ihope> ...Oh.
02:20:35 <ihope> You... yeah.
02:20:35 <bsmntbombdood> yeah
02:20:42 <bsmntbombdood> heh
02:20:44 <ihope> Meanie.
02:20:45 <ihope> ~pexec while 1: self.raw("PRIVMSG #esoteric :Tick!"); __import__("time").sleep(10)
02:20:45 <bsmnt_bot_chroot> Tick!
02:20:55 <bsmnt_bot_chroot> Tick!
02:21:00 <bsmntbombdood> ~ps
02:21:01 <bsmnt_bot_chroot> 0: '__import__("time").sleep(10000)', 196.36 seconds
02:21:01 <bsmnt_bot_chroot> 1: 'while 1: self.raw("PRIVMSG #esoteric :Tick!"); __import__("time").sleep(10)', 15.42 seconds
02:21:05 <bsmnt_bot_chroot> Tick!
02:21:16 <bsmnt_bot_chroot> Tick!
02:21:19 <bsmntbombdood> There's no way to kill it :((
02:21:22 <ihope> :-)
02:21:26 <bsmnt_bot_chroot> Tick!
02:21:35 <bsmnt_bot_chroot> Tick!
02:21:42 <ihope> Wonderful.
02:21:45 <bsmnt_bot_chroot> Tick!
02:21:55 <ihope> Just a second, lemme do another GregorR...
02:21:56 <bsmnt_bot_chroot> Tick!
02:22:05 <bsmnt_bot_chroot> Tick!
02:22:15 <bsmnt_bot_chroot> Tick!
02:22:18 <ihope> ~pexec self.raw("PRIVMSG NickServ :REGISTER foobork")
02:22:25 <bsmnt_bot_chroot> Tick!
02:22:32 <ihope> Uh oh.
02:22:35 <bsmnt_bot_chroot> Tick!
02:22:43 <ihope> morp.
02:22:45 <bsmnt_bot_chroot> Tick!
02:22:47 <bsmntbombdood> ihope: interrupt on the terminal would work ;)
02:22:48 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
02:22:50 -!- bsmnt_bot_chroot has joined.
02:22:52 <ihope> s/m/M/
02:22:55 <ihope> Yes, it would.
02:23:59 <bsmntbombdood> ARrRrRrRGH!
02:24:06 <bsmntbombdood> I want my pthread_cancel!
02:25:04 <ihope> Is it not available with a chroot jail?
02:25:14 <bsmntbombdood> It's not available in python at all
02:26:40 <ihope> Hmm...
02:26:41 <bsmntbombdood> It's the only way I can come up with to implement ~kill
03:01:11 <ihope> ~pexec while 1: self.raw("PRIVMSG #esoteric :Tick!"); __import__("time").sleep(3600)
03:01:12 <bsmnt_bot_chroot> Tick!
03:01:46 -!- ihope has quit ("http://tunes.org/~nef/logs/esoteric/06.08.09").
03:02:05 -!- ihope has joined.
03:05:05 <GregorR> bsmnt_bot_chroot: Um ... how about just kill?
03:05:32 <GregorR> Damn it
03:05:35 <GregorR> bsmntbombdood: ^^^
03:08:40 <GregorR> ihope: What's the significance of the log in your quit message?
03:09:21 <ihope> GregorR: oh, it probably contains some stuff that's important somehow.
03:09:40 <GregorR> Ah yes ... I see ...
03:09:52 <fizzie> 18:23:44 <ihope_> Well, I've temporarily immortalized this goal of ours in my quit message.
03:10:02 <GregorR> Ahhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
03:10:05 <fizzie> Maybe it's a sneaky reference to that quit message there.
03:10:10 <ihope> Yep.
03:10:19 <ihope> Assuming that message is in the log in my quit message.
03:11:55 <ihope> And I think that goal of ours was to make an esoteric programming language. A certain kind, I mean, of course.
03:13:32 <fizzie> 18:20:11 <ihope_> Well, the goal here seems to be "to create the most memory using language in existence.... so needlessly complex and unstructured that it makes absolutely no sense."
03:13:46 <fizzie> It's clipped at "-- abs" in the actual quit message.
03:16:21 <ihope> What is the actual quit message?
03:17:01 <bsmntbombdood> GregorR: ?
03:17:40 <bsmntbombdood> GregorR: They run in threads
03:20:59 <bsmntbombdood> pthread_kill would work too, but python doesn't expose that either
03:23:33 <bsmntbombdood> ~exec poor python
03:23:44 <bsmntbombdood> unexpected EOF while parsing!!
03:25:18 <ihope> ~pexec
03:27:02 <CakeProphet> bsmnt what runs in threads?
03:28:15 * CakeProphet should like... finish that ORK interpreter.
03:39:37 <fizzie> bsmntbombdood; I am very much not a Pythoner, but can't you use "settrace" in the new threads you create (before starting the user code) to some function which checks a "should I die" condition variable and exit()s if necessary? 
03:39:52 <bsmntbombdood> CakeProphet: ~exec
03:39:55 <fizzie> Uh, sys.settrace, I mean.
03:40:02 <bsmntbombdood> fizzie: I'll look that up
03:40:24 <fizzie> At least based on http://docs.python.org/lib/debugger-hooks.html the trace function seems to be called quite often.
03:42:01 <fizzie> To sleep; 0535 am here. ->
03:44:35 <bsmntbombdood> fizzie: I think that will work nicely
03:44:38 <CakeProphet> bsmnt why thread exec???
03:44:47 <bsmntbombdood> CakeProphet: ?
03:45:03 <CakeProphet> What's the benefit?
03:45:18 <bsmntbombdood> More than one can run at a time
03:45:35 <bsmntbombdood> The bot can function regularly while an ~exec is running
03:45:46 <CakeProphet> You could do that with subprocesses.
03:45:50 <CakeProphet> threading is too much of a hassle.
03:46:00 <bsmntbombdood> subproccesses are more of a hassle
03:46:13 <CakeProphet> ...than threading?
03:46:24 <bsmntbombdood> yeah
03:46:31 <bsmntbombdood> Shared memory...
03:54:10 * bsmntbombdood codes it
04:01:10 <bsmnt_bot_chroot> Tick!
04:03:32 <bsmntbombdood> heh
04:08:56 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:08:59 -!- bsmnt_bot_chroot has joined.
04:09:08 <bsmntbombdood> wow, no exceptions
04:09:47 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:10:11 -!- bsmnt_bot_chroot has joined.
04:10:27 <bsmntbombdood> foo
04:10:31 <bsmntbombdood> hot damn
04:10:33 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:11:10 -!- bsmnt_bot_chroot has joined.
04:11:15 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:11:18 -!- bsmnt_bot_chroot has joined.
04:11:27 <bsmntbombdood> ~exec print "hi"
04:11:30 <bsmntbombdood> argggh
04:12:04 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:12:28 -!- bsmnt_bot_chroot has joined.
04:12:31 <bsmntbombdood> ~exec print "hi"
04:13:03 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:13:58 -!- bsmnt_bot_chroot has joined.
04:14:05 <bsmntbombdood> ~exec print "hi"
04:15:11 <bsmntbombdood> gah
04:15:24 <CakeProphet> Did you rig it up so that stdout is the "current" channel?
04:15:31 <bsmntbombdood> no
04:15:40 <bsmntbombdood> I'm looking at the terminal
04:16:03 <bsmntbombdood> It is suppose to give me a message that it knows the we are ~exec in somethine
04:17:42 <bsmntbombdood> argh
04:18:17 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:20:01 <CakeProphet> I think subprocesses would work better in the long run... I mean... if you're going that route like EgoBot.
04:20:29 <bsmntbombdood> I'm not
04:22:04 <CakeProphet> just fork off the process with a pipe for stdout and stdin... and just reroute stderr to stdout if you don't care much about error handling.
04:22:08 <CakeProphet> much less management than threads.
04:22:43 <bsmntbombdood> Then I wouldn't be able to do all the cool stuff I do with ~exec now
04:23:00 <CakeProphet> Sure you could.
04:23:10 <CakeProphet> Just dump the globals into the exec.
04:23:21 <CakeProphet> then retrieve them... and update the globals of the main process.
04:23:23 -!- bsmnt_bot_chroot has joined.
04:23:27 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:24:17 <bsmntbombdood> hmm
04:24:20 * CakeProphet wishes OSes had more support for interconnected stuff like that...
04:24:45 <CakeProphet> They tend to just... seal off processes as independent units..
04:24:54 <CakeProphet> when a lot of potential power could be had by making them all transparent.
04:25:08 -!- bsmnt_bot_chroot has joined.
04:25:15 <bsmntbombdood> ~exec print "hi"
04:25:18 <bsmntbombdood> damnit
04:25:36 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:25:42 -!- bsmnt_bot_chroot has joined.
04:25:47 <bsmntbombdood> ~exec print "hi"
04:26:04 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:26:38 <bsmntbombdood> ah ha
04:27:48 -!- bsmnt_bot_chroot has joined.
04:27:51 <bsmntbombdood> ~exec print "hi"
04:28:07 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:28:12 -!- bsmnt_bot_chroot has joined.
04:28:15 <bsmntbombdood> ~exec print "hi"
04:28:40 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:28:50 <bsmntbombdood> shit
04:31:04 -!- bsmnt_bot_chroot has joined.
04:31:07 <bsmntbombdood> ~exec print "hi"
04:31:09 <bsmntbombdood> yes
04:31:20 <oklopol> will you make the stdout thingie?
04:31:25 <bsmntbombdood> ?
04:31:32 <oklopol> stdout is here
04:31:35 <oklopol> i mean
04:31:52 <bsmntbombdood> I don't really feel like writting a wrapper class
04:32:04 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:32:09 -!- bsmnt_bot_chroot has joined.
04:32:14 <bsmntbombdood> ~exec print "hi"
04:32:56 <CakeProphet> sys.stdout = socket.makefile()
04:33:02 <bsmntbombdood> no
04:33:10 <CakeProphet> no wrapper class.  ;)
04:33:30 <bsmntbombdood> "PRIVMSG #esoteric :%s"
04:35:00 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:35:00 <CakeProphet> socket.write = lambda x: socket.send("PRIVMSG #esoteric :%s" % x
04:35:03 -!- bsmnt_bot_chroot has joined.
04:35:13 <bsmntbombdood> ~exec print "hi"
04:35:14 <oklopol> well, off to sleep, hopefully it uses stdout so i can make a new quine when i wake up yay!
04:35:31 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:35:35 -!- bsmnt_bot_chroot has joined.
04:35:37 <bsmntbombdood> ~exec print "hi"
04:36:22 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:36:27 -!- bsmnt_bot_chroot has joined.
04:36:28 <CakeProphet> no wait...
04:36:29 <bsmntbombdood> ~exec print "hi"
04:36:41 <CakeProphet> socket.write = lambda self, x: self.send("PRIVMSG #esoteric :%s" % x
04:36:59 <oklopol> self.raw?
04:37:06 <CakeProphet> sys.stdout = socket
04:37:09 <CakeProphet> yeah
04:37:13 <CakeProphet> whatever you use to write.
04:37:25 <oklopol> socket.write = lambda self, x: self.raw("PRIVMSG #esoteric :%s" % x)
04:37:40 <bsmntbombdood> not quite
04:37:57 <CakeProphet> Anything you give to stdout that has a write method counts as a 
04:38:01 <CakeProphet> "file-like object"
04:38:12 <bsmntbombdood> uh huh
04:38:19 <CakeProphet> yay duck typing!
04:38:23 <bsmntbombdood> indeed
04:38:47 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:38:50 -!- bsmnt_bot_chroot has joined.
04:38:52 <bsmntbombdood> ~exec print "hi"
04:39:08 <CakeProphet> What's the problem exactly?
04:39:14 <CakeProphet> something in the threads?
04:39:26 * CakeProphet has an inherent disdain for threads.
04:39:42 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:39:44 -!- bsmnt_bot_chroot has joined.
04:39:46 <bsmntbombdood> ~exec print "hi"
04:40:31 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:40:36 -!- bsmnt_bot_chroot has joined.
04:40:45 <bsmntbombdood> CakeProphet: I'm working on ~kill
04:40:48 <bsmntbombdood> ~exec print "hi"
04:42:19 <bsmntbombdood> argh
04:42:37 <bsmntbombdood> diddling in low level python isn't fun
04:42:42 <bsmntbombdood> well, it is fun
04:43:20 <bsmntbombdood> ~exec print "hi";print "hi"
04:44:29 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:44:34 -!- bsmnt_bot_chroot has joined.
04:44:36 <bsmntbombdood> ~exec print "hi";print "hi"
04:45:19 <bsmntbombdood> the stuff I need is out of scope :/
04:45:42 <CakeProphet> did you do
04:45:53 <CakeProphet> exec "blah" in globaldict, localdict  ?
04:46:02 <bsmntbombdood> that's not what I mean
04:46:52 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:46:59 -!- bsmnt_bot_chroot has joined.
04:47:02 <bsmntbombdood> ~exec print "hi";print "hi"
04:48:05 <bsmntbombdood> Out of scope in the trace function
04:50:12 <CakeProphet> ah.
04:50:29 <CakeProphet> the traceback?  or is "trace function" some terminology I've never heard of?
04:50:54 <bsmntbombdood> the latter
04:51:25 <bsmntbombdood> http://www.python.org/doc/current/lib/debugger-hooks.html#debugger-hooks
04:51:42 <CakeProphet> ah.
04:51:46 <CakeProphet> trace function.
04:51:50 <CakeProphet> yeah.
04:52:34 <bsmntbombdood> ~exec for i in range(3): print "hi"
04:53:36 <bsmntbombdood> The trace function is given the globals and locals for print, but it needs an object from next up function
04:56:07 <bsmntbombdood> maybe a global threading.local object
04:57:49 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:57:52 -!- bsmnt_bot_chroot has joined.
04:58:10 <bsmntbombdood> ~exec print "hi"
04:58:35 <bsmntbombdood> a ha!
04:59:59 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
05:00:01 -!- bsmnt_bot_chroot has joined.
05:00:04 <bsmntbombdood> ~exec print "hi"
05:00:21 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
05:00:24 -!- bsmnt_bot_chroot has joined.
05:00:26 <bsmntbombdood> ~exec print "hi"
05:00:56 <bsmntbombdood> ~exec __import__("time").sleep(10000)
05:00:58 <bsmntbombdood> ~ps
05:00:58 <bsmnt_bot_chroot> 0: '__import__("time").sleep(10000)', 2.14 seconds
05:01:23 <bsmntbombdood> ~exec self.commands_running[0][3].set()
05:01:25 <bsmntbombdood> ~ps
05:01:26 <bsmnt_bot_chroot> 0: '__import__("time").sleep(10000)', 29.76 seconds
05:01:30 <bsmntbombdood> damn
05:02:10 <bsmntbombdood> ~exec __import__("time").sleep(10); self.raw("PRIVMSG #esoteric :no")
05:02:14 <bsmntbombdood> ~exec self.commands_running[1][3].set()
05:02:15 <bsmntbombdood> ~ps
05:02:16 <bsmnt_bot_chroot> 0: '__import__("time").sleep(10000)', 79.73 seconds
05:02:16 <bsmnt_bot_chroot> 1: '__import__("time").sleep(10); self.raw("PRIVMSG #esoteric :no")', 5.25 seconds
05:02:24 <bsmntbombdood> ~ps
05:02:25 <bsmnt_bot_chroot> 0: '__import__("time").sleep(10000)', 88.61 seconds
05:02:27 <bsmntbombdood> WOOOOOOOOOOOOOOOT
05:02:47 <bsmntbombdood> WINNNNNNNNNNNNAAAAAAAAGEEEEEEE
05:05:14 <bsmntbombdood> I win
05:05:18 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
05:05:22 -!- bsmnt_bot_chroot has joined.
05:05:42 <bsmntbombdood> ~exec __import__("time").sleep(50); self.raw("PRIVMSG #esoteric :fail")
05:05:43 <bsmntbombdood> ~exec __import__("time").sleep(50); self.raw("PRIVMSG #esoteric :fail")
05:05:45 <bsmntbombdood> ~ps
05:05:46 <bsmnt_bot_chroot> 0: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :fail")', 3.69 seconds
05:05:46 <bsmnt_bot_chroot> 1: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :fail")', 2.59 seconds
05:05:54 <bsmntbombdood> ~quit
05:05:55 -!- bsmnt_bot_chroot has quit (Client Quit).
05:05:58 -!- bsmnt_bot_chroot has joined.
05:06:07 <bsmntbombdood> ~exec __import__("time").sleep(50); self.raw("PRIVMSG #esoteric :fail number zero")
05:06:10 <bsmntbombdood> ~exec __import__("time").sleep(50); self.raw("PRIVMSG #esoteric :fail number one")
05:06:14 <bsmntbombdood> ~ps
05:06:14 <bsmnt_bot_chroot> 0: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :fail number zero")', 6.71 seconds
05:06:15 <bsmnt_bot_chroot> 1: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :fail number one")', 3.51 seconds
05:06:33 <bsmntbombdood> ~exec self.commands_running[0][3].set()
05:06:52 <bsmntbombdood> ~ps
05:06:53 <bsmnt_bot_chroot> 0: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :fail number zero")', 45.36 seconds
05:06:53 <bsmnt_bot_chroot> 1: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :fail number one")', 42.16 seconds
05:07:01 <bsmnt_bot_chroot> fail number one
05:07:05 <bsmntbombdood> sweet!
05:09:23 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
05:10:10 -!- bsmnt_bot_chroot has joined.
05:10:19 <bsmntbombdood> ~exec __import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number zero")
05:10:22 <bsmntbombdood> ~exec __import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number one")
05:10:23 <bsmntbombdood> ~ps
05:10:24 <bsmnt_bot_chroot> 0: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number zero")', 4.76 secondsTrue
05:10:24 <bsmnt_bot_chroot> 1: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number one")', 1.42 secondsTrue
05:10:33 <bsmntbombdood> ~exec self.commands_running[0][3].set()
05:10:35 <bsmntbombdood> ~ps
05:10:35 <bsmnt_bot_chroot> 0: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number zero")', 16.19 secondsTrue
05:10:36 <bsmnt_bot_chroot> 1: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number one")', 12.86 secondsTrue
05:10:40 <bsmntbombdood> arggh
05:11:03 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
05:11:09 -!- bsmnt_bot_chroot has joined.
05:11:16 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
05:11:31 -!- bsmnt_bot_chroot has joined.
05:11:33 <bsmntbombdood> ~exec __import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number zero")
05:11:37 <bsmntbombdood> ~exec __import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number one")
05:11:39 <bsmntbombdood> ~ps
05:11:39 <bsmnt_bot_chroot> 0: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number zero")', 5.29 seconds, killed: False
05:11:39 <bsmnt_bot_chroot> 1: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number one")', 1.94 seconds, killed: False
05:11:45 <bsmntbombdood> ~exec self.commands_running[0][3].set()
05:11:47 <bsmntbombdood> ~ps
05:11:47 <bsmnt_bot_chroot> 0: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number zero")', 13.39 seconds, killed: True
05:11:47 <bsmnt_bot_chroot> 1: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number one")', 10.03 seconds, killed: False
05:11:57 <bsmntbombdood> :)
05:12:27 <bsmnt_bot_chroot> number one
05:12:27 <bsmntbombdood> ~ps
05:12:28 <bsmnt_bot_chroot> None
05:12:33 <bsmntbombdood> yay
05:13:14 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
05:13:18 -!- bsmnt_bot_chroot has joined.
05:13:25 <bsmntbombdood> ~exec __import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number zero")
05:13:26 <bsmntbombdood> ~ps
05:13:27 <bsmnt_bot_chroot> 0: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number zero")', 1.40 seconds
05:13:32 <bsmntbombdood> ~exec self.commands_running[0][3].set()
05:13:37 <bsmntbombdood> ~ps
05:13:37 <bsmnt_bot_chroot> 0: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number zero")', 12.04 seconds, killed
05:14:06 <bsmntbombdood> ~ps
05:14:06 <bsmnt_bot_chroot> 0: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number zero")', 41.06 seconds, killed
05:14:54 <bsmntbombdood> ~ps
05:14:55 <bsmnt_bot_chroot> None
05:16:13 * bsmntbombdood did it
05:21:19 <CakeProphet> !ps
05:21:21 <EgoBot> 2 CakeProphet: ps
05:21:22 <CakeProphet> ~ps
05:21:22 <bsmnt_bot_chroot> None
05:22:20 <CakeProphet> ~exec import time self.raw("PRIVMSG #esoteric: " + time.asctime()) 
05:22:24 <CakeProphet> ...
05:22:27 <bsmntbombdood> CakeProphet: ~pexec
05:22:34 <CakeProphet> ~pexec import time; self.raw("PRIVMSG #esoteric: " + time.asctime()) 
05:23:02 <CakeProphet> why pexec?
05:23:06 <CakeProphet> !ps
05:23:09 <CakeProphet> ~ps
05:23:09 <bsmnt_bot_chroot> None
05:23:10 <EgoBot> 2 CakeProphet: ps
05:23:11 <bsmntbombdood> s/#esoteric:/#esoteric : /
05:23:26 <CakeProphet> ~pexec import time; self.raw("PRIVMSG #esoteric : " + time.asctime()) 
05:23:26 <bsmnt_bot_chroot>  Sun Jan  7 05:17:16 2007
05:23:43 <CakeProphet> ~pexec while True: print "AAAAAAAAAAAH"
05:23:48 <CakeProphet> ~ps
05:23:49 <bsmntbombdood> ~ps
05:23:54 <CakeProphet> quine
05:23:56 <bsmntbombdood> ...
05:23:59 <bsmntbombdood> crap
05:24:07 <CakeProphet> hehe
05:24:11 <bsmnt_bot_chroot> 0: 'while True: print "AAAAAAAAAAAH"', 26.36 seconds
05:24:12 <bsmnt_bot_chroot> 0: 'while True: print "AAAAAAAAAAAH"', 26.36 seconds
05:24:12 <CakeProphet> so much for concurency
05:24:15 <CakeProphet> ah.
05:24:22 <bsmntbombdood> ~exec self.commands_running[0][3].set()
05:24:34 <bsmntbombdood> finally
05:24:40 <CakeProphet> What took it so long?
05:24:55 <bsmntbombdood> Your thread didn't block
05:25:03 <CakeProphet> pfft... threading.
05:25:14 <CakeProphet> forking a process with a global dictionary would be so much easier  :P
05:25:16 <bsmntbombdood> heh
05:25:23 <bsmntbombdood> no it wouldn't
05:25:54 <CakeProphet> I can't even comprehend how thread management could be considered simply than using subprocesses.
05:26:07 <CakeProphet> simpler
05:26:56 <CakeProphet> It's like..
05:27:29 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
05:27:32 -!- bsmnt_bot_chroot has joined.
05:28:01 <bsmntbombdood> ~exec __import__("time").sleep(25); self.raw("PRIVMSG #esoteric :oops")
05:28:03 <bsmntbombdood> ~ps
05:28:03 <bsmnt_bot_chroot> 0: '__import__("time").sleep(25); self.raw("PRIVMSG #esoteric :oops")', 0.99 seconds
05:28:06 <bsmntbombdood> ~kill 0
05:28:08 <bsmntbombdood> ~ps
05:28:09 <bsmnt_bot_chroot> 0: '__import__("time").sleep(25); self.raw("PRIVMSG #esoteric :oops")', 6.84 seconds, killed
05:28:14 <bsmntbombdood> sweet
05:28:31 <bsmntbombdood> ~ps
05:28:31 <bsmnt_bot_chroot> None
05:28:34 <CakeProphet> process history?
05:28:37 <CakeProphet> oh.
05:29:03 <bsmntbombdood> It can't be killed until the current statement finishes executing
05:29:34 <CakeProphet> with what?
05:29:49 <bsmntbombdood> Some very hacky code
05:30:02 <bsmntbombdood> uses trace functions
05:30:18 <bsmntbombdood> s/current statement finishes executing/trace function gets called/
05:30:19 <CakeProphet> killing a subprocess would be like....   os.kill(sub.pid)
05:30:26 <CakeProphet> :P
05:30:42 <bsmntbombdood> with a subproccess you wouldn't be able to do
05:30:54 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :this")
05:30:54 <bsmnt_bot_chroot> this
05:31:24 <CakeProphet> hmmm..
05:31:49 <bsmntbombdood> Not without shared memory, and I don't think python can do that
05:33:16 <CakeProphet> is concureent exec really that important though?
05:33:24 <bsmntbombdood> No, not really
05:33:46 * CakeProphet would only use threading if it were absolutely nessicary for the construction of the bot.
05:33:54 <bsmntbombdood> Would I have been doing anything better with my time? no
05:33:55 <CakeProphet> which it wouldn' ever be.
05:34:09 <bsmntbombdood> I don't see what you have against threading
05:34:18 <CakeProphet> threading isn't fun programming... it's painful
05:34:28 <bsmntbombdood> No, it's fun
05:34:42 <CakeProphet> I just think... most of the time there's an easier solution.
05:34:49 <CakeProphet> ...that isn't so prone to fuck you over.
05:35:26 <bsmntbombdood> <CakeProphet> killing a subprocess would be like....   os.kill(sub.pid)
05:36:01 <bsmntbombdood> If it was in c, you could just do pthread_cancel(threads[pid]);
05:36:17 <bsmntbombdood> Well, if it was C, there could be no ~exec
05:37:58 <CakeProphet> can you just delete the thread object?
05:38:39 <bsmntbombdood> or even use pthread_kill(threads[pid], SIGTERM); and let the thread use its own signal handler
05:38:50 <bsmntbombdood> There is no thread object
05:39:23 <CakeProphet> ...how are you doing threading?
05:39:38 <CakeProphet> All of Python's threading stuff usually has a "thread object" of some sort.
05:40:04 <bsmntbombdood> thread.start_new_thread
05:40:34 <bsmntbombdood> returns an int
05:42:57 <CakeProphet> If you can only kill a thread between statements... that sorta defeats the purpose of threading really...
05:43:05 <bsmntbombdood> no...
05:43:42 <bsmntbombdood> I've never seen when threads needed to be killed except my hacky irc bot
05:44:12 <CakeProphet> I mean... it defeats -your- purpose of threading.
05:44:22 <CakeProphet> not... the general purpose of threading (whatever the hell that is.)
05:44:57 <bsmntbombdood> ~exec while True: self.raw("PRIVMSG #esoteric :kill me"); __import__("time").sleep(2)
05:44:58 <bsmnt_bot_chroot> kill me
05:45:00 <bsmnt_bot_chroot> kill me
05:45:02 <bsmnt_bot_chroot> kill me
05:45:03 <bsmntbombdood> ~kill 0
05:45:18 <bsmntbombdood> Doesn't need to kill in between statements
05:45:51 <CakeProphet> Python is kinda hard to do in one line though.
05:46:15 <CakeProphet> it can't wrap up all nice and snug like other languages... because of its indentation syntax.
05:46:20 <bsmntbombdood> yeah :(
05:46:29 <bsmntbombdood> I hate python's indentation
05:46:59 <CakeProphet> I find the benefits outweigh the drawbacks usually.
05:47:07 <bsmntbombdood> What benefits?
05:47:13 <CakeProphet> no more fucking curly braces.  >.<
05:47:17 <bsmntbombdood> hmm
05:47:40 <CakeProphet> in most sane programming environments... it works like a charm.
05:48:25 <CakeProphet> it would be nice if it had an optional "condensed mode"... for places where indentation just doesn't settle right.
05:48:40 <bsmntbombdood> I've had times when I'm reading code, I accidently hit tab, now everything is screwed up and it can't be fixed unless you know where that indent was
05:51:13 <CakeProphet> >.>   undo? :P
05:51:26 <bsmntbombdood> yeah, it
05:51:34 <bsmntbombdood> 's easy to not notice it though
05:53:08 -!- Sgeo has quit (Remote closed the connection).
06:05:22 <RodgerTheGreat> g'night, everyone
06:05:42 -!- RodgerTheGreat has quit.
06:33:56 <bsmntbombdood> ~ps
06:33:56 <bsmnt_bot_chroot> None
06:33:59 <bsmntbombdood> ~kill 0
06:33:59 <bsmnt_bot_chroot> Proccess 0 does not exist
06:34:06 <bsmntbombdood> ~kill asfd
06:34:07 <bsmnt_bot_chroot> Argument to kill must be a number
06:35:19 -!- violot has joined.
06:36:10 <bsmntbombdood> ~exec __import__("time").sleep(100);self.raw("PRIVMSG #esoteric :100")
06:36:25 <bsmntbombdood> ~exec __import__("time").sleep(50);self.raw("PRIVMSG #esoteric :50")
06:36:30 <bsmntbombdood> ~exec __import__("time").sleep(10);self.raw("PRIVMSG #esoteric :10")
06:36:31 <bsmntbombdood> ~[s
06:36:35 <bsmntbombdood> ~ps
06:36:36 <bsmnt_bot_chroot> 0: '__import__("time").sleep(100);self.raw("PRIVMSG #esoteric :100")', 25.79 seconds
06:36:36 <bsmnt_bot_chroot> 1: '__import__("time").sleep(50);self.raw("PRIVMSG #esoteric :50")', 11.05 seconds
06:36:36 <bsmnt_bot_chroot> 2: '__import__("time").sleep(10);self.raw("PRIVMSG #esoteric :10")', 5.72 seconds
06:36:40 <bsmnt_bot_chroot> 10
06:36:43 <bsmntbombdood> ~kill 1
06:36:46 <bsmntbombdood> ~ps
06:36:46 <bsmnt_bot_chroot> 0: '__import__("time").sleep(100);self.raw("PRIVMSG #esoteric :100")', 36.39 seconds
06:36:47 <bsmnt_bot_chroot> 1: '__import__("time").sleep(50);self.raw("PRIVMSG #esoteric :50")', 21.65 seconds, killed
06:37:06 <bsmntbombdood> ~ps
06:37:07 <bsmnt_bot_chroot> 0: '__import__("time").sleep(100);self.raw("PRIVMSG #esoteric :100")', 56.70 seconds
06:37:07 <bsmnt_bot_chroot> 1: '__import__("time").sleep(50);self.raw("PRIVMSG #esoteric :50")', 41.96 seconds, killed
06:37:17 <bsmntbombdood> ~ps
06:37:18 <bsmnt_bot_chroot> 0: '__import__("time").sleep(100);self.raw("PRIVMSG #esoteric :100")', 67.62 seconds
06:37:49 <bsmntbombdood> ~exec print thread_info.info
06:37:50 <bsmnt_bot_chroot> 100
06:37:59 <bsmntbombdood> ~exec print thread_info.info[:2]
06:38:06 <bsmntbombdood> ~exec print thread_info.info[:2]
06:38:16 <bsmntbombdood> ~exec print thread_info.info[:2]
06:38:29 <bsmntbombdood> ~exec print thread_info.info[:2] #ff
06:38:34 <bsmntbombdood> ~exec print thread_info.info[:2] #fa
06:38:43 <bsmntbombdood> goooood
06:39:29 <bsmntbombdood> :)
06:40:50 -!- violot has left (?).
06:41:03 <bsmntbombdood> ~ps
06:41:04 <bsmnt_bot_chroot> None
06:42:14 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
06:42:19 -!- bsmnt_bot_chroot has joined.
06:42:30 <bsmntbombdood> ~exec __import__("time").sleep(10);self.raw("PRIVMSG #esoteric :10")
06:42:32 <bsmntbombdood> ~kill 0
06:42:34 <bsmntbombdood> ~ps
06:42:34 <bsmnt_bot_chroot> 0: '__import__("time").sleep(10);self.raw("PRIVMSG #esoteric :10")', 4.14 seconds, killed
06:42:43 <bsmntbombdood> ~ps
06:42:43 <bsmnt_bot_chroot> None
06:44:23 <bsmntbombdood> heh, there are almost no comments in the code
06:52:37 -!- calamari has left (?).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
10:25:31 -!- kotrin has joined.
10:25:43 <kotrin> 'elo
11:34:05 -!- jix has joined.
12:27:06 -!- puzzlet_ has quit (Read error: 104 (Connection reset by peer)).
12:27:17 -!- puzzlet has joined.
12:31:41 -!- jix__ has joined.
12:41:40 -!- jix has quit (Read error: 110 (Connection timed out)).
13:18:40 -!- tgwizard has joined.
14:37:39 <ihope> No comments?
14:37:43 <ihope> Sheesh.
14:42:57 <ihope> ~pexec self.register_raw('(.*)', lambda x: self.raw("PRIVMSG #esoteric %s" % x))
14:43:08 <ihope> This is gonna be spammy.
14:43:08 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
14:43:12 <ihope> Or not.
14:43:23 <kotrin> lol
14:52:25 <oklopol> i always insert comments afterwards
14:52:28 <oklopol> i see no use in them
14:59:34 -!- tgwizard has quit (Read error: 110 (Connection timed out)).
15:04:25 <kotrin> comments
15:04:27 <kotrin> yay
15:19:00 <ihope> Come back, bsmnt_bot!
15:20:47 <kotrin> wish really hard
15:20:54 <kotrin> it will come true
15:21:38 <ihope> I don't know if I can wish that hard.
15:22:41 <kotrin> oh well...we'll use disney magic then?
15:24:35 <ihope> Sounds good.
15:24:53 <kotrin> do you have yours? i ran out of mine
15:25:07 <ihope> Um, I think I left it somewhere else and... eh.
15:26:32 <kotrin> oh well
15:27:08 <ihope> Let's try Xanth magic.
15:27:11 <ihope> What's your talent?
15:28:44 <kotrin> i have no clue
15:29:00 <ihope> Oh.
15:29:17 <ihope> There's Harry Potter magic... except Harry Potter magic can't raise the dead.
15:29:51 <ihope> How about NetHack magic? We might be able to work that one
15:29:59 <kotrin> hmm
15:30:01 <kotrin> possibly
15:30:04 <kotrin> possibly...
15:37:11 -!- ihope_ has joined.
15:39:53 <ihope_> Okay. Do you know the "turn undead" spell?
15:40:18 <kotrin> sadley i do not
15:40:22 <kotrin> sadly*
15:42:42 <ihope_> Nor do I...
15:42:59 <ihope_> And I don't have any spellbooks. Do you?
15:44:14 <kotrin> hmmm...let me check
15:44:44 <fizzie> And what good would the "turn undead" spell (which pacifies and/or destroys undead creatures) be in getting a bot back? 
15:47:38 <ihope_> That can revive corpses, can't it?
15:48:43 <fizzie> Oh, right.
15:49:42 <ihope_> Does a quit message count as a corpse?
15:53:06 <kotrin> i say it does
15:54:05 -!- ihope has quit (Connection timed out).
15:56:34 -!- RodgerTheGreat has joined.
16:01:46 <ihope_> Mmh.
16:02:12 <ihope_> Wake up, bsmntbombdood! It's 10 AM!
16:10:05 <kotrin> 8am here
16:13:35 <ihope_> 11 AM here.
16:13:41 <ihope_> And 10 AM there.
16:20:12 <kotrin> word
16:44:18 <oklopol> 18:38 here
16:44:19 <fizzie> 6 PM here. (Half-past, now.)
16:44:20 <oklopol> 6 pm
16:44:25 <oklopol> oh yeah finnish :)
17:05:34 -!- oerjan has joined.
17:07:42 <kotrin> huzzah
17:38:18 -!- Sgeo has joined.
17:39:53 <kotrin> wake up peeps
17:43:48 * ihope_ wakes up
17:43:54 <ihope_> !help
17:43:58 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
17:44:00 <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
17:44:03 <ihope_> Yay, an EgoBot.
17:44:09 * oerjan is already awake (barely)
17:45:20 <ihope_> So I couldn't get socat working, and I couldn't get netcat working either.
17:45:24 <ihope_> I'll try socat again.
17:47:19 <kotrin> what for ihope_
17:48:02 <oerjan> Everybody wants their own bot nowadays :)
17:48:29 <ihope_> Yep.
17:48:37 <ihope_> Darn you, GregorR.
17:49:28 <oerjan> At this rate, it would probably be easier using sockets.
17:50:01 <kotrin> heh bots
17:50:23 <ihope_> Maybe my operating system will have an IRC bot built in.
17:50:40 <kotrin> just download one?
17:50:56 <ihope_> I downloaded a bot, and I'm trying to get it working.
17:51:04 <kotrin> what language
17:51:33 <ihope_> C or C++ or something.\
17:51:41 <kotrin> heh
17:51:42 <ihope_> I'll compromise and say it's written in C+.
17:51:46 <kotrin> get a perl one
17:51:54 <ihope_> Are they better?
17:51:58 <kotrin> by far
17:52:01 <kotrin> imo
17:52:27 <kotrin> what os are you on?
17:52:44 -!- oklobot2 has joined.
17:52:45 <ihope_> I'm trying to get it going under Linux.
17:52:50 <oklopol> :)
17:53:01 <ihope_> Oh great.
17:53:40 -!- ihope_bot has joined.
17:54:00 <ihope_> So what's oklobot2 do?
17:55:07 <ihope_> My bot does nothing at all.
17:55:14 <ihope_bot> I do too do something!
17:55:15 <kotrin> add to it
17:55:20 <ihope_> Except that.
17:55:24 <oerjan> Ah, a ZenBot :)
17:55:26 <ihope_bot> And this.
17:55:31 <ihope_> ZenBot?
17:55:49 <oerjan> just sits and meditates.
17:55:50 <kotrin> ihope_ do you not know any scripting language or programming language?
17:55:59 <ihope_> I know some.
17:56:06 <oklopol> !exec "I"" do " " a few things."AddAddPrntNl
17:56:09 <oklobot2> I do  a few things.
17:56:09 <EgoBot> Huh?
17:56:12 <oklopol> whoops
17:56:17 <ihope_> Yay!
17:56:37 <oklopol> !eval +4 3
17:56:38 <oklobot2> +4 3=7
17:56:40 <EgoBot> Huh?
17:56:44 -!- ihope_bot has quit (Remote closed the connection).
17:56:48 <oklopol> !print Hello, world!
17:56:50 <oklopol> that's all
17:56:50 <oklobot2> Hello, world!
17:56:52 <EgoBot> Huh?
17:56:55 <oklopol> well...
17:56:58 <oklopol> !colors
17:57:02 <oklopol> !print oso
17:57:02 <EgoBot> Huh?
17:57:05 <oklobot2> oso
17:57:06 <EgoBot> Huh?
17:57:09 <oklopol> !print oso
17:57:10 <oklopol> !print oso
17:57:11 <oklobot2> oso
17:57:12 <EgoBot> Huh?
17:57:12 <oklobot2> oso
17:57:13 <oklopol> !colors
17:57:14 <EgoBot> Huh?
17:57:16 <EgoBot> Huh?
17:57:18 <ihope_> EgoBot's clueless.
17:57:20 <oklopol> :DD
17:59:32 <oklopol> oerjan, if i make a Chr function to convert a number to a character (string) that has the same ascii value, will you try a quine? :D
17:59:56 <oklopol> because it's too easy with escapes
18:01:22 * SimonRC reads
18:01:45 <oerjan> whoops. i guess so.
18:02:05 <oklopol> :DD
18:02:37 <kotrin> someone make an interactive bot that only respondes in BF
18:03:05 <oerjan> _in_ BF? that could be awkward.
18:03:40 <kotrin> :)
18:03:42 <kotrin> yep
18:03:49 <kotrin> then have another bot in here the interprets it
18:03:51 <kotrin> lol
18:04:05 <kotrin> or better yet, a whitespace bot
18:04:12 <oerjan> well we already have EgoBot.
18:04:15 <ihope_> Let's have a channel containing every bot on Freenode.
18:04:44 <oerjan> And let's call it #skynet.
18:05:11 <oerjan> just to make the aspirations clear. :)
18:05:29 <SimonRC> kotrin: wsbot would be a PITA because of the significance of NL
18:05:32 -!- oklobot2 has quit (Read error: 104 (Connection reset by peer)).
18:05:49 <kotrin> SimonRC: exactly
18:05:53 -!- oklobot2 has joined.
18:06:05 <oklopol> a bf bot could auto-interpret all data it gets :)
18:06:23 <oklopol> !exec 65ChrPrntNl
18:06:27 <oklobot2> A
18:06:28 <EgoBot> Huh?
18:06:31 <oklopol> yay!
18:06:49 <kotrin> !exec 32CharPrntNl
18:06:52 <EgoBot> Huh?
18:06:52 <SimonRC> bsmntbombdood: Maybe you kill python threads by forcing them to throw an uncatchable exception?
18:06:53 <kotrin> aww
18:07:03 <oklopol> don't break it, please :) it's very fragile
18:07:11 <oerjan> !exec 33ChrPrntNl
18:07:14 <EgoBot> Huh?
18:07:16 <oklobot2> !
18:07:20 <EgoBot> Huh?
18:07:22 <oerjan> !exec 34ChrPrntNl
18:07:24 <oklobot2> "
18:07:26 <EgoBot> Huh?
18:07:33 <kotrin> !exec 43ChrPrntNl
18:07:35 <EgoBot> Huh?
18:07:36 <oklobot2> +
18:07:44 <ihope_> !daemon exec bf +[,[-]+]
18:07:48 <ihope_> Shut up.
18:08:47 <oklopol> 65[DblChrPrntNlDrp1AddDbl80Les]
18:09:06 <oklopol> !exec 65[DblChrPrntNlDrp1AddDbl80Les]
18:09:07 <oklopol> good...
18:09:08 <oklopol> :D
18:09:09 <oklobot2> A
18:09:12 <oklobot2> B
18:09:20 <oklobot2> C
18:09:20 <oklobot2> D
18:09:24 <oklopol> eh, 15 letters... why? :O
18:09:24 <oklobot2> E
18:09:29 <oklobot2> F
18:09:32 <ihope_> Uh oh
18:09:33 <oklobot2> G
18:09:34 <oklopol> too much, stop it
18:09:36 <oklobot2> H
18:09:41 <oklobot2> I
18:09:45 <oklobot2> J
18:09:49 <oklobot2> K
18:09:53 <oklobot2> L
18:09:58 <oklobot2> M
18:10:00 <ihope_> Can arbitrary strings be printed?
18:10:00 <oklobot2> N
18:10:04 <SimonRC> oklopol: what lang is that?
18:10:05 <oklobot2> O
18:10:13 <oklopol> i don't have a name for it
18:10:18 <oklopol> just made it with the bot
18:10:28 <oklopol> i call the lang oklobot too
18:10:35 <SimonRC> do you have any kind of definition for it?
18:10:41 <ihope_> SimonRC: yes, the bot.
18:10:42 <ihope_> :-)
18:10:45 <oklopol> i should make one... maybe now
18:10:49 <oklopol> well, yeah :)
18:11:05 <oklopol> it's not open source tho, it's unbelievably bad code
18:11:12 <SimonRC> oklopol: named after the 2billion-year-old nuclear reactor?
18:11:27 <oklopol> is there one called that? :D
18:11:39 <oklopol> oklopol->oklobot, named after that
18:11:46 <SimonRC> no, it was found at Oklo
18:11:50 <SimonRC> ah, ok
18:12:01 <oklopol> oklo?
18:12:11 <SimonRC> yeah
18:13:01 <SimonRC> see The Repositor Of All Huma Knowlage for more details
18:13:11 <SimonRC> *Repositary
18:13:16 <SimonRC> *Reposatory
18:13:19 <SimonRC> *Reposetory
18:13:22 <SimonRC> *Repository
18:13:42 <oklopol> *human?
18:13:47 <SimonRC> yeah
18:13:54 <SimonRC> d'oh
18:15:43 <oklopol> ihope_, they can
18:15:56 <oklopol> !exec "AAA"65ChrAddPrntNl
18:15:59 <oklobot2> AAAA
18:16:35 <ihope_> Can you print newlines and carriage returns that way?
18:17:44 <oerjan> !exec 3PrntPrnt
18:17:59 <oerjan> !exec "3"PrntPrnt
18:18:07 <oerjan> !exec PrntNl
18:18:08 <oklobot2> 3PRIVMSG #esoteric :3PRIVMSG #esoteric :3PRIVMSG #esoteric :3
18:18:22 <kotrin> !exec !exec
18:18:23 <oerjan> Right, that problem.
18:18:53 <kotrin> !exec "$_"PrintNl
18:19:04 <kotrin> !exec "$_"65ChrAddPrintNl
18:19:12 <kotrin> :(
18:19:51 <oerjan> !exec 3PrntPrntNl
18:19:56 <oklobot2> 3PRIVMSG #esoteric :3
18:20:07 <ihope_> !exec Nl
18:20:56 <CakeProphet> !exec 343534534545345PrintPrintPrintPrintPrintPrintPrintPrintPrintNl
18:21:27 <ihope_> CakeProphet: evil.
18:21:29 <oklopol> :DD
18:21:36 <oklopol> Prnt, not Print
18:21:42 <CakeProphet> ...
18:21:59 <oklopol> hmm
18:22:04 <oklopol> !eval /1 0
18:22:05 <oklopol> :D
18:22:07 <EgoBot> Huh?
18:22:08 <CakeProphet> !exec 343534534545345PrntPrntPrntPrntPrntPrntPrntPrntPrntPrntPrntNl
18:22:08 -!- oklobot2 has quit (Read error: 104 (Connection reset by peer)).
18:22:12 <CakeProphet> :D
18:22:12 <ihope_> Yay!
18:22:13 <oklopol> i knew it½!
18:22:14 <oklopol> :DDDDD
18:22:33 <oklopol> good, let's call that a feature.
18:22:42 -!- oklobot2 has joined.
18:22:45 <ihope_> !daemon eval bf +[,[-]+]
18:22:47 <oklopol> !exec 1 0Div
18:22:55 <oklopol> !exec 1 0Div
18:23:01 <oklopol> !exec 1 0DivPrntNl
18:23:03 <oklobot2> 0
18:23:05 <ihope_> !exec 0 1Div
18:23:12 <ihope_> !exec 0 1DivPrintNl
18:23:17 <ihope_> Hmm.
18:23:23 <oklopol> 1/0 is 0 it seems :)
18:23:24 <ihope_> !eval /1 0
18:23:40 <kotrin> !exec 2+#
18:23:42 <ihope_> I think it became immune to division by zero.
18:23:43 -!- oklobot2 has quit (Read error: 104 (Connection reset by peer)).
18:23:46 <oklopol> !exec 0 1DivPrntNl
18:23:48 <oklopol> you killed it
18:23:50 <oklopol> that's all :)
18:23:56 <ihope_> What's 2+#?
18:23:56 <oklopol> !exec 0 1DivPrntNl
18:24:02 <oklopol> exec doesn't fail
18:24:15 <oklopol> just eval, which i did in the summer in 2 hours
18:24:19 <kotrin> !eval 1 + 2
18:24:26 <ihope_> oklopol: ...hmm?
18:24:28 <kotrin> !eval
18:24:32 <kotrin> EgoBot
18:24:34 -!- oklobot2 has joined.
18:24:35 <ihope_> Guys, it won't work without the bot.
18:24:46 <kotrin> what does egobot do?
18:24:47 <oklopol> ihope: ...huh?
18:24:58 <kotrin> !exec 2+#
18:25:07 <oklopol> !exec +2 #
18:25:09 <oerjan> !help
18:25:10 <kotrin> k, wasn't me that killed it
18:25:13 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
18:25:16 <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
18:25:17 <oklopol> www.answers.com/polish%20notation
18:25:27 <oklopol> !exec +2 5
18:25:36 <oklopol> !eval +2 5
18:25:39 <oklobot2> +2 5=7
18:25:43 <oklopol> goodz.
18:25:51 <kotrin> !eval +4 e
18:25:54 <CakeProphet> !daemon glassf glass {M[m(_o)O!(_i)I!(_e)(BF)!/<1>(_i)i.?(_e)(BF).?\]}
18:25:57 <oklobot2> +4 e=
18:26:09 <CakeProphet> !glassf +.
18:26:15 <ihope_> !glassf +[.+]
18:26:22 <CakeProphet> ...
18:26:38 <ihope_> ?
18:26:45 <kotrin> !bf_textgen
18:26:55 <CakeProphet> !daemon glassf glass {M[m(_o)O!(_i)I!(_e)(BF)!/<1>(_i)i.?(_e)(BF).?(_o)o.?\]}
18:27:00 <kotrin> hmm
18:27:08 <CakeProphet> !glassf +.
18:27:10 <kotrin> !eval +4 $_
18:27:13 <oklobot2> +4 $_=
18:27:17 <ihope_> !glassf +[.+]
18:27:23 <kotrin> what language is oklobot written in?
18:27:43 <CakeProphet> !daemon glassf glass {M[m(_o)O!(_i)I!(_e)(BF)!/<1>(_i)i.?(_e)(bf).?(_o)o.?\]}
18:27:47 <CakeProphet> !glassf +.
18:28:02 <kotrin> !eval *2148 13985632964986718967296872098672069872506987256098247690824673459086376392045873490847649580674
18:28:05 <oklopol> c++
18:28:05 <oklobot2> *2148 13985632964986718967296872098672069872506987256098247690824673459086376392045873490847649580674=785619656
18:28:11 <oklopol> oklobot is
18:28:13 <oklopol> in c++
18:28:20 <oklopol> kotrin, long
18:28:21 <kotrin> yeah
18:28:38 <oklopol> !eval -4 10
18:28:39 <CakeProphet> !daemon glassf glass {M[m(_o)O!(_i)I!(_e)(BF)!/<1>(_i)i.?(_e)(bf).?\]}
18:28:40 <oklobot2> -4 10=6_
18:28:42 <CakeProphet> !glassf +.
18:28:43 <kotrin> !eval *********************************************************************
18:28:46 <oklobot2> *********************************************************************=
18:28:53 <oklopol> !eval + 5_ 3
18:28:56 <oklobot2> + 5_ 3=2_
18:29:00 <oklopol> :O
18:29:03 <oklopol> wtf
18:29:13 <kotrin> c++ ftl
18:29:23 <CakeProphet> !daemon glassf glass {M[m(_o)O!(_i)I!(_e)(BF)!\<1>(_i)i.?(_e)(bf).?/]}
18:29:27 <CakeProphet> !glassf +.
18:29:31 <oklopol> okay, i'm not complaining if i've done that without realizing it
18:29:35 <oklopol> what's wrong with c++?
18:30:09 <kotrin> everything?
18:30:11 <kotrin> lol
18:30:25 <kotrin> for large projects it's not bad
18:30:32 <kotrin> works well with a framework as well
18:30:39 <kotrin> but small apps and sockets....*puke*
18:30:52 <oklopol> well, yeah, i always use python for converting words to hex or smth 
18:30:58 <oklopol> c++ want's me to make a project
18:31:20 <oklopol> but python sucks with it's whitespace thing, i hate ws
18:31:30 <kotrin> wtf are you talking about
18:31:44 <oklopol> about c++ in small projects
18:31:44 * CakeProphet hasn't figured out why people hate whitespace so much.
18:32:03 <kotrin> whitespace is easily the best of all esoteric languages
18:32:24 <kotrin> it's so genius
18:32:27 <oklopol> kotrin, i wasn't referring to a lang called whitespace
18:32:39 <oklopol> just whitespace
18:32:46 <kotrin> oh
18:32:47 <oklopol> if that's what confused you
18:32:50 <kotrin> no
18:33:01 <kotrin> oklopol>well, yeah, i always use python for converting words to hex or smth
18:33:04 <kotrin> that confused me
18:33:06 <CakeProphet> I just find it amusing that all whitespace programs are invisible... but I don't really think it's that genius.  :P
18:33:31 <Sgeo> Any work on that Factory language?
18:33:43 <kotrin> it's the smartest idea for a esoteris imo
18:33:48 <kotrin> esoteric*
18:33:59 <oklopol> pythons whitespace thingie makes it hard to use in one line, and one line usage is the only thing i'd like to use it for
18:34:09 <kotrin> oh
18:34:11 <kotrin> learn perl
18:34:13 <kotrin> or ruby
18:34:17 <oklopol> i should
18:34:19 <oklopol> everything
18:34:20 <kotrin> yep
18:34:21 <oklopol> but no time
18:34:29 <kotrin> there's always time for ruby
18:34:33 <kotrin> it's the best language in the world
18:34:33 <oklopol> well, there is time, but not enough for everything
18:34:38 <oklopol> doubt it
18:34:38 * Sgeo <3 Python
18:34:49 * kotrin <3's ruby more then Sgeo <3's python
18:34:55 <CakeProphet> It would be nice if Python had a one-line mode... otherwise I love python.
18:35:09 <CakeProphet> but... I hate language advocacy... so lol stfu plz kthxbai
18:35:12 <kotrin> oklopol: you're right, lisp is better than ruby
18:35:33 <oklopol> K ftw
18:35:44 <oklopol> K has the smallest sudoku solver by far
18:35:48 <Sgeo> K?
18:35:56 <oklopol> and that's pretty much all a lang needs :)
18:36:06 <oklopol> www.answers.com/K%20programming%20language
18:36:09 <oklopol> maybe
18:36:33 <kotrin> have you even used K? or are you just saying it because it's "different"
18:36:55 <Sgeo> Does anyone here have any interest in BF-RLE?
18:37:03 <oklopol> i haven't used it, but i know the syntax
18:37:15 <oklopol> i could write a prog in it if that's what you mean
18:37:20 <kotrin> sgeo: bf-rle?
18:37:26 <oklopol> it's not that different
18:37:32 <oklopol> just the best APL
18:37:34 <Sgeo> http://esoteric.voxelperfect.net/wiki/BF-RLE
18:37:39 <oklopol> and APL is nice and short
18:37:57 * Sgeo came up with it
18:38:54 <oklopol> sgeo, impressive :D
18:39:07 <Sgeo> ty
18:39:17 <Sgeo> I guess
18:40:23 -!- sp3tt has quit ("leaving").
18:40:24 <oklopol> i like the base-62 thing
18:40:29 <oklopol> since i hate 10-base
18:40:39 <kotrin> so just replace any occurs < 3 to [operator][occurence-3] ?
18:40:54 <kotrin> occurs > 3 *
18:40:54 <Sgeo> occurs > 3
18:40:55 <oklopol> >=3
18:41:01 <Sgeo> >=3 right
18:41:05 <kotrin> what's the point of that?
18:41:12 -!- sp3tt has joined.
18:41:15 <oklopol> easier to write
18:41:27 <oklopol> faster to interpret without optimizations
18:41:29 <Sgeo> If it were >=2, then +0 saves no more space than ++
18:41:51 <kotrin> makes sense
18:42:00 <Sgeo> And that means that in certain conditions, less space is saved
18:42:08 <kotrin> i just dont see the point of all the optimizations in the languages
18:42:09 <oklopol> yes, and since it's a separate lang, it guaranteed the speed bf interpreters only give you if they're good
18:42:40 <Sgeo> BRB
18:42:56 <oklopol> well, +03 is better that >++++++++[<++++++++>-]<+.
18:42:59 <oklopol> *than
18:43:03 <kotrin> i see the languages as oppurtunities to learn high level languages by mkaing compilers with optimizations
18:43:19 -!- sp3tt has quit (Remote closed the connection).
18:43:33 <oklopol> sorry, +13.
18:43:46 <oerjan> !exec "!exec ""34ChrDupRotAddDupAddRotRotAddDupAddSwapAddPrntLn"34ChrDupRotAddDupAddRotRotAddDupAddSwapAddPrntLn
18:43:47 <kotrin> how is +13 == >++++++++[<++++++++>-]<+.
18:44:26 <Sgeo> back
18:45:03 <Sgeo> !bf >++++++++[<++++++++>-]<+.
18:45:04 <oklopol> +13.
18:45:10 <Sgeo> erm
18:45:15 <oerjan> !exec 34ChrPrntLn
18:45:27 <Sgeo> How do I evaluate BF here?
18:45:35 <oerjan> oklopol: i think your bot is dead.
18:45:38 <oklopol> kotrin, what's the difference? except that the bf one needs teh next cell too
18:45:45 <oklopol> omg
18:45:50 <oklopol> eh
18:45:52 <oklopol> it's not :O
18:45:56 <oklopol> !exec 34ChrPrntLn
18:46:03 <oklopol> !exec 34ChrPrntNl
18:46:04 <oklopol> :DD
18:46:06 <oklobot2> "PRIVMSG #esoteric :"PRIVMSG #esoteric :"
18:46:08 <oerjan> aha
18:46:11 <kotrin> !bf >++++++++[<++++++++>-]<+.
18:46:16 <oklopol> i could out in both :D
18:46:23 <oklopol> *-out
18:46:28 <oerjan> !exec "!exec ""34ChrDupRotAddDupAddRotRotAddDupAddSwapAddPrntNl"34ChrDupRotAddDupAddRotRotAddDupAddSwapAddPrntNl
18:46:30 <oklopol> *+put
18:46:31 <kotrin> !help
18:46:36 <kotrin> !h
18:46:41 <kotrin> bleh
18:46:44 <kotrin> useless bots
18:47:08 <Sgeo> I guess IRP#esoteric is an illegal language now?
18:47:12 <oerjan> *sigh*
18:47:31 <oklopol> Dup->Dbp
18:47:36 <oklopol> Dbl
18:47:40 <oerjan> ah
18:47:46 <kotrin> sgeo is there a better bf-rle tutorial somewhere?
18:48:03 <oerjan> forgot a lot since Dec 27
18:48:13 <Sgeo> I can try to describe it better here
18:48:20 <oerjan> !exec "!exec ""34ChrDblRotAddDblAddRotRotAddDblAddSwapAddPrntNl"34ChrDblRotAddDblAddRotRotAddDblAddSwapAddPrntNl
18:48:34 <Sgeo> Not sure how to describe it well though
18:48:36 <oerjan> argh! i know
18:48:42 <kotrin> i think i got it
18:48:54 <oerjan> !exec "!exec ""34ChrDblRotAddDblAddRotRotAddDblAddSwpAddPrntNl"34ChrDblRotAddDblAddRotRotAddDblAddSwpAddPrntNl
18:48:54 <kotrin> have you coded an interpretor for it?
18:48:56 <oklobot2> !exec "!exec ""34ChrDblRotAddDblAddRotRotAddDblAddSwpAddPrntNl"34ChrDblRotAddDblAddRotRotAddDblAddSwpAddPrntNl
18:48:58 <Sgeo> No
18:49:01 <kotrin> why not?
18:49:02 <oerjan> finally :)
18:49:07 <Sgeo> Too lazy
18:49:22 <kotrin> heh
18:49:31 * oerjan bows.
18:49:43 <oklopol> WTF :D
18:49:45 <kotrin> are loops/output/input the same as bf?
18:50:12 <Sgeo> yes
18:50:30 <Sgeo> It's just done textually actually
18:50:46 <Sgeo> Although an interpreter could optomize for it probably
18:52:36 <SimonRC> I have been wondering...
18:52:39 <kotrin> what would the bf-rle be for ++++++++++[>+++++++>++++++++++>+++>+<<<<-]
18:54:06 <Sgeo> +6[>+4>+7>+0>+<1-]
18:54:13 <Sgeo> Translating it literally
18:56:26 <kotrin> hmmm
18:56:27 <SimonRC> I know that PROLOG predicates can do some cool things that functions can't, like going both ways, but that stops you composing the predicates, and that Joy avoids the need for almost all variables, so is there a way to conbine the advantages?
19:00:24 <kotrin> hmmmm
19:00:35 <kotrin> i might make a bf -> bf-rle 
19:00:38 <kotrin> script
19:00:41 <kotrin> out of sheer bordem
19:00:47 <Sgeo> Neat! ty
19:05:26 -!- sp3tt has joined.
19:05:50 <oklopol> i coded the interpreter
19:05:52 <oklopol> in the ide
19:05:58 <oklopol> and i crashed it
19:06:03 <oklopol> so, again i go :)
19:08:16 <kotrin> ?
19:08:23 <oklopol> BF-RLE
19:08:32 <oklopol> scribed it in python
19:09:00 <oklopol> i'll make it again noe
19:09:02 <oklopol> *w
19:09:44 <kotrin> ok
19:09:59 <oklopol> can i do "0"<"5" in python?=
19:10:02 <kotrin> not really that hard
19:10:11 <oklopol> yay
19:10:14 <oklopol> i can
19:19:43 <ihope_> bsmntbombdood's away message is still "sleep", and it's past 1 PM/
19:19:58 <oklopol> i woke up 15:00 today
19:20:04 <kotrin> its 11:14 for me
19:20:14 <ihope_> oklopol: how do you manage to do that?
19:20:14 <oklopol> 21:14 \o/
19:20:25 <oklopol> i sleep 9 hours
19:20:26 <kotrin> i havn't slept yet
19:20:39 * SimonRC nominates a candidate for the "slowest growing function" award:  the inverse of f(n) = A(n, n).
19:20:41 <ihope_> kotrin: haven't slept since yesterday?
19:20:47 <SimonRC> it tens to infinity, you know.
19:20:48 <kotrin> correct
19:20:50 <SimonRC> *tends
19:21:01 <ihope_> SimonRC: f(n) = 0 grows more slowly.
19:21:26 <ihope_> I don't want to know how fast its inverse grows.
19:22:49 <bsmntbombdood> ihope_: It's 12 here
19:23:01 -!- bsmnt_bot_chroot has joined.
19:23:03 <kotrin> sgeo, does the the rule for bf-rle apply to . and , commands?
19:23:09 <ihope_> bsmntbombdood: then fix your clock.
19:23:11 <Sgeo> yes
19:23:14 <kotrin> mkay
19:23:16 <ihope_> === CTCP time reply ``Sun Jan 7 13:13:29 2007'' from bsmntbombdood
19:23:16 <bsmntbombdood> ?
19:23:21 <bsmntbombdood> oh
19:23:25 <bsmntbombdood> heh
19:23:58 <ihope_> ~pexec self.raw("JOIN ##quantum")
19:23:59 <Sgeo> And to [ and ], although I don't know why there would be enough of those in a row to make the RLE significant..
19:24:07 <ihope_> I see the bot's not identified.
19:24:35 <bsmntbombdood> it isn't
19:24:44 <ihope_> Nor is Sgeo.
19:24:58 <bsmntbombdood> now it is
19:25:58 <oklopol> can't i use a var of the parent function in a subfunction?
19:26:07 <bsmntbombdood> ~pexec self.raw("PRIVMSG #esoteric :foo")
19:26:08 <bsmnt_bot_chroot> foo
19:26:32 <bsmntbombdood> FOO!
19:26:45 <ihope_> FOO??!?!
19:26:53 <oklopol> can't i?
19:26:54 <ihope_> OH NOES!!!!!!!!!!!!!
19:27:35 <bsmntbombdood> SimonRC: You kill a python thread by raising SystemExit exception
19:27:35 <oklopol> well... can't i?
19:28:02 <oklopol> but... can't i? :D
19:28:47 <bsmntbombdood>  <ihope>~pexec self.register_raw('(.*)', lambda x: self.raw("PRIVMSG #esoteric %s" % x))
19:28:59 <bsmntbombdood> ihope_: python uses weird scope for lambdas
19:29:07 <oklopol> no lambdas
19:29:09 <oklopol> or?
19:29:11 <oklopol> defs
19:29:12 <bsmntbombdood> ie no closures
19:29:21 <oklopol> i def new functions in functions
19:29:29 <bsmntbombdood> use the global bot object, "bot", in lambdas
19:29:29 <ihope_> ~pexec self.register_raw('(.*)', lambda x: (self.raw("PRIVMSG #esoteric %s" % x)))
19:29:37 <ihope_> bot.raw?
19:29:38 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
19:29:42 <bsmntbombdood> ha
19:29:47 -!- bsmnt_bot_chroot has joined.
19:29:47 <oklopol> bot, huh?
19:29:48 <bsmntbombdood> *ya
19:29:55 <oklopol> i'm not talking about a bot but genericly
19:29:55 <ihope_> ~pexec self.register_raw('(.*)', lambda x: bot.raw("PRIVMSG #esoteric %s" % x))
19:29:59 <oklopol> generally
19:30:00 <bsmnt_bot_chroot> oklopol!i=okokokok@194.251.102.88 PRIVMSG #esoteric :generally
19:30:04 <ihope_> Yay!
19:30:04 <bsmnt_bot_chroot> ihope_!n=foo@c-71-205-100-59.hsd1.mi.comcast.net PRIVMSG #esoteric :Yay!
19:30:07 <ihope_> Now kill it.
19:30:08 <bsmnt_bot_chroot> ihope_!n=foo@c-71-205-100-59.hsd1.mi.comcast.net PRIVMSG #esoteric :Now kill it.
19:30:21 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
19:30:21 <bsmnt_bot_chroot> bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :~exec self.raw_regex_queue.pop()
19:30:26 <ihope_> :-)
19:30:37 <bsmntbombdood> you can kill it just as easily
19:30:56 <oklopol> ddef oso(a):
19:30:57 <oklopol>      def poso():
19:30:57 <oklopol>           print a
19:30:57 <oklopol>           return a
19:30:57 <oklopol>      print poso(a)
19:31:01 <oklopol> that's illegal?
19:31:06 <bsmntbombdood> no...
19:31:08 <oklopol> -first d
19:31:17 <kotrin> Sgeo: http://pastie.caboo.se/31705
19:31:32 <ihope_> ~exec foo = "foo"
19:31:51 <Sgeo> erm, I don't know Ruby
19:32:06 <ihope_> ~exec self.raw("PRIVMSG #esoteric :" + foo)
19:32:25 <ihope_> I take it that didn't work.
19:32:27 <kotrin> sgeo: learn it :) do you have installed on your machine?
19:32:34 <Sgeo> I might
19:32:39 <Sgeo> Does it handle [[[[]]]]?
19:32:45 <kotrin> no
19:32:48 <kotrin> should it?
19:33:01 <kotrin> just add another element to the operators array
19:33:04 <kotrin> ']'
19:33:14 <kotrin> and it will
19:33:28 <Sgeo> Oh, and it's supposed to strip all comments out
19:33:29 <bsmntbombdood> ihope_: ~pexec
19:33:30 <oklopol> def oso(a):
19:33:30 <oklopol> def poso():
19:33:30 <oklopol> a+=1
19:33:30 <oklopol> poso()
19:33:30 <oklopol> print a
19:33:33 <Sgeo> (non operaters)
19:33:38 <kotrin> mkay
19:33:43 <ihope_> Oh. Right.
19:34:04 <oklopol> bsmntbombdood, this is illegal, how do i go around it?
19:34:05 <oklopol> def oso(a):
19:34:05 <oklopol>     def poso():
19:34:05 <oklopol>         a+=1
19:34:05 <oklopol>     poso()
19:34:05 <oklopol>     print a
19:34:13 <bsmntbombdood> ihope_: Did you see? I implemented ~kill
19:34:37 <ihope_> ~pexec foo = "foo"
19:34:47 <ihope_> ~pexec self.raw("PRIVMSG #esoteric :" + foo)
19:34:52 <bsmntbombdood> NameError: name 'foo' is not defined
19:34:59 <ihope_> ~pexec self.foo = "foo"
19:35:04 <ihope_> ~pexec self.raw("PRIVMSG #esoteric :" + self.foo)
19:35:05 <bsmnt_bot_chroot> foo
19:35:08 <ihope_> Yay!
19:35:39 <oklopol> bsmntbombdood, please tell me :-|
19:35:45 <oklopol> i'm desperate
19:35:50 <bsmntbombdood> ~pexec while 1: self.raw("PRIVMSG #esoteric :tick"); __import__("time").sleep(2)
19:35:50 <bsmnt_bot_chroot> tick
19:35:52 <bsmnt_bot_chroot> tick
19:35:54 <bsmnt_bot_chroot> tick
19:35:54 <bsmntbombdood> ~ps
19:35:55 <bsmnt_bot_chroot> 0: 'while 1: self.raw("PRIVMSG #esoteric :tick"); __import__("time").sleep(2)', 4.50 seconds
19:35:56 <bsmnt_bot_chroot> tick
19:35:57 <bsmntbombdood> ~kill 0
19:36:03 <bsmntbombdood> ~ps
19:36:03 <bsmnt_bot_chroot> None
19:36:14 -!- oerjan has quit ("leaving").
19:36:28 <bsmntbombdood> oklopol: you can do that
19:36:37 <oklopol> how?
19:37:21 <oklopol> or you mean that's legal code as it is?
19:37:26 <bsmntbombdood> i think so
19:37:42 <oklopol> Traceback (most recent call last):
19:37:43 <oklopol>   File "<pyshell#16>", line 1, in ?
19:37:43 <oklopol>     oso(4)
19:37:43 <oklopol>   File "<pyshell#15>", line 4, in oso
19:37:43 <oklopol>     poso()
19:37:43 <oklopol>   File "<pyshell#15>", line 3, in poso
19:37:44 <oklopol>     a+=1
19:37:46 <oklopol> UnboundLocalError: local variable 'a' referenced before assignment
19:37:59 <oklopol> nopez.
19:38:04 <bsmntbombdood> hm
19:38:27 <oklopol> i'd like to have that... assumed python'd work like that
19:38:47 <oklopol> i've now actually used an hour to make a trivial bf interpreter
19:42:52 <CakeProphet> Was "a" assigned before you did that?
19:43:09 <CakeProphet> a += 1 wouldn't work if a was never defined before that.
19:43:28 <CakeProphet> or is a a global variable?
19:44:18 <Sgeo> AFk for a bit
19:44:30 <oklopol> it's a param
19:44:32 <oklopol> def oso(a):
19:44:34 <oklopol>     def poso():
19:44:34 <oklopol>         a+=1
19:44:34 <oklopol>     poso()
19:44:34 <oklopol>     print a
19:44:42 <oklopol> but, same result if it's created in the function
19:44:49 <CakeProphet> aaah
19:45:05 <kotrin> sgeo: http://pastie.caboo.se/31707
19:46:13 <CakeProphet> yeah... that should work thanks to closures.
19:47:29 <bsmntbombdood> ~foOOOOO~!
19:48:10 <ihope_> So Saturn says to earth, "Dude, you kicked Pluto out of the Solar System! He's a tad disgruntled."
19:48:20 <ihope_> Or something like that.
19:49:41 * bsmntbombdood feels leet
19:49:45 <bsmntbombdood> ~kill 0
19:49:45 <bsmnt_bot_chroot> Proccess 0 does not exist
19:50:50 -!- digital_me has joined.
19:51:02 <bsmntbombdood> The code to kill the threads is only 14 lines, but it took like 4 hours to write
19:53:20 <ihope_> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~([a-zA-Z]*).*", lambda x,y : bot.raw("PRIVMSG %s :Error: ~%s might be an invalid command" % (y.group(1),y.group(2))))
19:53:27 <ihope_> ~oogity boogity
19:53:33 <ihope_> ~pexec self.register_raw(r"\S+ PRIVMSG (\S+) :~([a-zA-Z]*).*", lambda x,y : bot.raw("PRIVMSG %s :Error: ~%s might be an invalid command" % (y.group(1),y.group(2))))
19:53:34 <bsmntbombdood> ~pexec
19:53:34 <bsmnt_bot_chroot> Error: ~pexec might be an invalid command
19:53:40 <oklopol> CakeProphet, do you have a solution?
19:53:41 <ihope_> ~oogity boogity
19:53:41 <bsmnt_bot_chroot> Error: ~oogity might be an invalid command
19:53:46 <ihope_> ~ps
19:53:46 <bsmnt_bot_chroot> None
19:53:46 <bsmnt_bot_chroot> Error: ~ps might be an invalid command
19:53:50 <ihope_> Woot!
19:53:53 <bsmntbombdood> ...
19:54:16 <bsmntbombdood> ~
19:54:17 <bsmnt_bot_chroot> Error: ~ might be an invalid command
19:54:17 <ihope_> ~pexec self.pop_register_raw()
19:54:17 <bsmnt_bot_chroot> Error: ~pexec might be an invalid command
19:54:25 <ihope_> ~oogity boogity
19:54:25 <bsmnt_bot_chroot> Error: ~oogity might be an invalid command
19:54:31 <ihope_> Well, that sure didn't work.
19:54:43 <bsmntbombdood> ~pexec self.raw_regex_queue.pop()
19:54:43 <bsmnt_bot_chroot> Error: ~pexec might be an invalid command
19:54:47 <bsmntbombdood> ~
19:54:50 <CakeProphet> oklow well python only speaks in globals, locals. and closures.
19:54:54 <kotrin> what are you guys coding?
19:55:03 <bsmntbombdood> kotrin: irc bots~
19:55:04 <bsmntbombdood> !
19:55:11 <kotrin> oh, bleh
19:55:20 <bsmntbombdood> kotrin: this irc bot is cool
19:55:26 <kotrin> does python have an irc library?
19:55:36 <bsmntbombdood> Don't think so
19:55:55 <oklopol> CakeProphet, i have 3 vars i need to change in a subfunction
19:56:02 <oklopol> how should i do that?
19:56:23 <kotrin> make them globals?
19:56:37 <ihope_> ~pexec self.raw("JOIN ##quantum")
19:56:41 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
19:56:43 <oklopol> errrrrr.... how?
19:56:46 <oklopol> oh
19:56:47 <bsmntbombdood> Make your functions side effect free?
19:56:49 <oklopol> global a
19:57:00 -!- EgoBot has joined.
19:57:04 <oklopol> bsmntbombdood, easier this way
19:57:14 <bsmntbombdood> ~ps
19:57:15 <bsmnt_bot_chroot> None
19:57:22 <bsmntbombdood> ~exec self.print_callbacks()
19:57:26 <bsmntbombdood> ~quit
19:57:27 -!- bsmnt_bot_chroot has quit.
19:57:40 -!- bsmnt_bot_chroot has joined.
19:57:55 <bsmntbombdood> now it just restarts itself if one of you kill it
19:58:11 <oklopol> k how should i remove side-effects? i want a function that does a single brainfuck operation
19:58:12 <ihope_> ~pexec self.raw(1/0)
19:58:22 <oklopol> done on my current stack and pointers
19:58:22 <ihope_> Wow, it didn't die.
19:58:25 <bsmntbombdood> ihope_: Exceptions are caught in ~exec
19:58:47 <ihope_> ~pexec self.raw("QUIT")
19:58:47 -!- bsmnt_bot_chroot has quit (Client Quit).
19:58:55 <bsmntbombdood> AND even if they weren't, they run in a different thread, so the main thread wouldn't die
19:59:01 <ihope_> Is it restarting?
19:59:03 <bsmntbombdood> and see, there we have a problem
19:59:06 <CakeProphet> oklopol it should just simply work like you expect it to.
19:59:12 <bsmntbombdood> It doesn't know it quited
19:59:15 <ihope_> Yes, I see.
19:59:16 -!- bsmnt_bot_chroot has joined.
19:59:26 <bsmntbombdood> if we do ~quit, it does
19:59:28 <bsmntbombdood> ~qui
19:59:31 <bsmntbombdood> ~quit
19:59:31 <oklopol> you mean this should work?
19:59:31 -!- bsmnt_bot_chroot has quit (Client Quit).
19:59:31 <oklopol> def oso(a):
19:59:31 <oklopol>     def poso():
19:59:31 <oklopol>         a+=1
19:59:31 <oklopol>     poso()
19:59:31 <oklopol>     print a
19:59:33 -!- bsmnt_bot_chroot has joined.
19:59:36 <ihope_> ~pexec self.raw("PART #esoteric")
19:59:37 -!- bsmnt_bot_chroot has left (?).
19:59:47 -!- bsmnt_bot_chroot has joined.
19:59:55 <bsmntbombdood> (that was manual)
20:00:01 <ihope_> Rather tricky to so a ~pexec after PARTing it.
20:00:34 <bsmntbombdood> ~pexec self.raw("PART #esoteric")
20:00:34 -!- bsmnt_bot_chroot has left (?).
20:00:48 -!- bsmnt_bot_chroot has joined.
20:00:56 * Sgeo is back
20:01:03 <CakeProphet> oklopol, I think so.
20:01:29 * SimonRC goes
20:01:31 <bsmntbombdood> ~exec self.register_raw(":\S+ PART #esoteric :.*", lambda x : bot.raw("JOIN #esoteric"))
20:01:38 <bsmntbombdood> ~pexec self.raw("PART #esoteric")
20:01:39 -!- bsmnt_bot_chroot has left (?).
20:01:39 -!- bsmnt_bot_chroot has joined.
20:01:44 <bsmntbombdood> neat
20:01:53 <ihope_> ~pexec self.register_raw("(:\S* )PRIVMSG \S* :~emerg(.*)", lambda x,y: self.do_exec(y))
20:02:02 <ihope_> ~emerg self.raw("PRIVMSG #esoteric :Foo")
20:02:02 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
20:02:05 -!- bsmnt_bot_chroot has joined.
20:02:07 <ihope_> Yay.
20:02:12 <bsmntbombdood> you killed it
20:02:15 <oklopol> CakeProphet, well it doesn't
20:02:20 <bsmntbombdood> NameError: global name 'self' is not defined
20:02:27 <ihope_> D'oh.
20:02:31 <ihope_> ~pexec self.register_raw("(:\S* )PRIVMSG \S* :~emerg(.*)", lambda x,y: bot.do_exec(y))
20:02:33 -!- digital_me has quit ("leaving").
20:02:33 <bsmntbombdood> ~exec self.register_raw(":\S+ PART #esoteric :.*", lambda x : bot.raw("JOIN #esoteric"))
20:02:38 <ihope_> ~emerg self.raw("PRIVMSG #esoteric :Foo")
20:02:38 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
20:02:40 -!- bsmnt_bot_chroot has joined.
20:02:44 * ihope_ wins
20:02:46 -!- digital_me has joined.
20:02:57 <bsmntbombdood> TypeError: do_exec() takes exactly 3 arguments (2 given)
20:03:03 <ihope_> Three?
20:03:15 <ihope_> Really, now...
20:03:17 -!- digital_me has quit (Client Quit).
20:03:29 <CakeProphet> Yeu need one more
20:03:30 -!- digital_me has joined.
20:03:56 <bsmntbombdood> def do_exec(self, message, r)
20:04:03 <ihope_> I gave it... like, one?
20:04:16 <ihope_> What's r?
20:04:32 <CakeProphet> Methods have an implied first arg.
20:04:44 <CakeProphet> So thats two
20:04:49 <ihope_> ~pexec self.register_raw("(:\S* )PRIVMSG \S* :~emerg(.*)", lambda x,y: bot.do_exec(y,r))
20:04:54 <ihope_> Ah.
20:05:00 <bsmntbombdood> um no
20:05:06 <ihope_> ~emerg self.raw("PRIVMSG #esoteric :Foo")
20:05:07 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
20:05:09 -!- bsmnt_bot_chroot has joined.
20:05:11 <bsmntbombdood> r is the regex object
20:05:22 <ihope_> The regex?
20:05:37 <bsmntbombdood> lambda message, regex_obj
20:05:53 <bsmntbombdood> lambda x, y
20:06:18 <ihope_> ~pexec self.register_raw(":\S* PRIVMSG \S* :~emerg(.*)", lambda x,y: bot.do_exec(x,y))
20:06:22 <ihope_> All confusing, I'm sure.
20:06:30 <ihope_> ~emerg self.raw("PRIVMSG #esoteric :Foo")
20:06:46 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
20:06:56 <bsmntbombdood> ~pexec self.register_raw(":\S* PRIVMSG \S* :~emerg (.*)", lambda x,y: bot.do_exec(x,y))
20:07:06 <bsmntbombdood> python don't like leading spaces
20:07:09 <ihope_> Oh.
20:07:17 <ihope_> Right.
20:07:26 <CakeProphet> ~pexec self.raw("PRIVMSG #esoteric :" + (lambda x: (lambda closure: x)("Doop"))("Hello, World!"))
20:07:27 <bsmnt_bot_chroot> Hello, World!
20:07:37 <CakeProphet> oklopol,  It works for lambdas :D
20:07:44 <ihope_> ~exec self.raw_regex_queue.pop()
20:07:48 <ihope_> ~pexec self.register_raw(":\S* PRIVMSG \S* :~emerg(.*)", lambda x,y: bot.do_exec(x,y))
20:07:55 <ihope_> ~emergself.raw("PRIVMSG #esoteric :Foo")
20:07:55 <bsmnt_bot_chroot> Foo
20:07:59 <ihope_> :-)
20:08:08 <ihope_> ~exec self.raw_regex_queue.pop()
20:08:12 <ihope_> ~pexec self.register_raw(":\S* PRIVMSG \S* :~emerg (.*)", lambda x,y: bot.do_exec(x,y))
20:08:41 <ihope_> You know, "lambda x,y: bot.do_exec(x,y)" is actually pretty pointless.
20:08:53 <bsmntbombdood> indeed
20:10:55 <bsmntbombdood> CYCLE WASTER
20:11:04 <ihope_> CYCLE WASHER
20:12:13 <CakeProphet> ~pexec self.register_raw(":\S* PRIVMSG \S* :~emerg (.*)",  bot.do_exec)
20:12:32 <bsmntbombdood> who wants the source?
20:12:35 <bsmntbombdood> http://bsmntbombdood.mooo.com/chroot_ircbot.py
20:14:40 <ihope_> Meeeeeeeeee!
20:15:02 <ihope_> Does it require root access or anything?
20:15:27 <bsmntbombdood> Only if you chroot it
20:15:45 <bsmntbombdood> as you can see it drops root if it has it on line 256
20:16:08 <CakeProphet> bsmnt Have you considered using **args?
20:16:13 <ihope_> It drops root if it has it... what if it has something else?
20:16:14 <bsmntbombdood> for what?
20:16:19 <CakeProphet> the constructor.
20:16:27 <oklopol> oerjan went already?
20:16:34 <bsmntbombdood> CakeProphet: Probably should
20:16:37 <oklopol> well, he gets in the reference :)
20:16:50 <bsmntbombdood> CakeProphet: But that is like the least interesting part of the bt
20:17:05 <CakeProphet> def __init__(self, **args)                        IRCbot(name="whooo", ident="hahahaha")
20:17:16 <bsmntbombdood> yeah, i know
20:19:37 <bsmntbombdood> ihope_: "what if it has something else?"?
20:20:02 <ihope_> Does it do any sandboxing of itself besides root-dropping?
20:20:09 <bsmntbombdood> no
20:20:17 <ihope_> Hmm.
20:20:26 <bsmntbombdood> there's a bash start up script
20:20:28 <bsmntbombdood> chroot $CHROOT /usr/bin/python2.4 /bot/ircbot.py
20:20:34 <ihope_> Oh, who cares.
20:20:38 * ihope_ downloads
20:21:30 <CakeProphet> bsmnt You could pickle the raw_regex_queue between executions.
20:21:45 <bsmntbombdood> no, you can't pickle functions
20:21:47 <ihope_> Pickle?
20:21:59 <bsmntbombdood> ihope_: Python's way of serializing objects
20:22:09 * CakeProphet actually made a way to pickle functions.  :D
20:22:29 <CakeProphet> it was nessicary for my MUD to have pickle-able functions... since the source code is editable mid-game.
20:22:39 <bsmntbombdood> I could however, dump the regexes and ~exec source codes
20:22:48 <ihope_> The source... uh...
20:23:16 <bsmntbombdood> what?
20:23:25 <ihope_> ...is editable mid-game?
20:23:41 <CakeProphet> as in... the game has facilities for programming itself.
20:23:47 <CakeProphet> softcodedly.
20:24:35 <CakeProphet> After the initial bootstrap... most of the "physical" sourec files are no longer needed... 
20:24:36 <ihope_> Gack!
20:25:25 <ihope_> Whoa.
20:25:39 <ihope_> Note to self: don't chmod u_
20:25:41 <ihope_> Erm.
20:25:46 <ihope_> Note to self: don't chmod u+x just any old Python file.
20:26:14 <ihope_> On the other hand, I accidentally taught myself how to write a basic shell script thingy right then.
20:26:47 <ihope_> I probably got the usage stuff for import ten times or something.
20:27:27 <bsmntbombdood> ?
20:27:45 <ihope_> I chmod u+x'd that Python file and ran it.
20:27:57 <bsmntbombdood> ok?
20:28:43 <bsmntbombdood> so?
20:28:54 <ihope_> It didn't work.
20:29:11 <GregorR> CakeProphet: Congratulations, you've won the awful spelling award. "nessicary" is one of the worst spellings I've ever seen. It's "necessary". Let's give 'im a hand!
20:30:44 <oklopol> :D
20:31:14 <oklopol> o/
20:31:32 <oklopol> my reference is ready, tho it's a bit of a stub
20:32:04 <ihope_> I take it I'll want a #!/usr/bin/env python at the top of that thing.
20:32:10 <bsmntbombdood> yeah
20:32:20 <bsmntbombdood> are you going to chroot it?
20:32:26 <ihope_> No.
20:43:28 <bsmntbombdood> get it running?
20:56:16 <ihope_> Yeah, I'll do that.
21:07:29 -!- ShadowHntr has joined.
21:10:37 <bsmntbombdood> ~pexec "foo"
21:11:03 <bsmntbombdood> ~ps 
21:11:04 <bsmnt_bot_chroot> None
21:11:14 <bsmntbombdood> ~pexec while True: pass
21:11:15 <bsmntbombdood> ~ps
21:11:16 <bsmnt_bot_chroot> 0: 'while True: pass', 1.48 seconds
21:11:18 <bsmntbombdood> ~ps
21:11:18 <bsmnt_bot_chroot> 0: 'while True: pass', 4.13 seconds
21:11:20 <bsmntbombdood> ~ps
21:11:20 <bsmnt_bot_chroot> 0: 'while True: pass', 6.21 seconds
21:11:31 <bsmntbombdood> ~ps
21:11:31 <bsmnt_bot_chroot> 0: 'while True: pass', 17.08 seconds
21:11:35 <bsmntbombdood> ~ps
21:11:36 <bsmnt_bot_chroot> 0: 'while True: pass', 21.76 seconds
21:11:38 <bsmntbombdood> ~kill 0
21:11:40 <bsmntbombdood> ~ps
21:11:41 <bsmnt_bot_chroot> None
21:11:44 <bsmntbombdood> woooooo
21:15:06 <ihope_> ~exec pass
21:15:11 <ihope_> Now tell me what that does.
21:16:56 <ShadowHntr> returns true?
21:20:35 <ihope_> ~exec self.raw(pass)
21:20:41 <ihope_> ...No, not that.
21:20:46 <ihope_> ~exec self.raw("PRIVMSG #esoteric" + pass)
21:20:52 <ihope_> No, not that either.
21:20:55 <ihope_> ~exec self.raw("PRIVMSG #esoteric :" + pass)
21:20:59 <ihope_> Ere we go.
21:21:05 <ihope_> Am I spamming you with error messages?
21:21:56 -!- Sgeo has quit (Remote closed the connection).
21:26:15 -!- Sgeo has joined.
21:26:38 <bsmntbombdood> ihope_: ~pexec
21:26:51 <ihope_> Oh
21:26:57 <ihope_> ~pexec self.raw("PRIVMSG #esoteric :" + pass)
21:27:05 <bsmntbombdood>  SyntaxError: invalid syntax
21:28:12 <ihope_> ~pexec listen(self)
21:28:27 <bsmntbombdood> NameError: name 'listen' is not defined
21:28:28 <ihope_> ~pexec self.raw("PRIVMSG #esoteric :foo")
21:28:29 <bsmnt_bot_chroot> foo
21:28:31 <ihope_> What?
21:28:40 <bsmntbombdood> it's self.listen
21:28:48 <ihope_> !pexec self.listen
21:28:51 <ihope_> ~pexec self.raw("PRIVMSG #esoteric :foo")
21:28:52 <bsmnt_bot_chroot> foo
21:28:52 <EgoBot> Huh?
21:28:53 <bsmntbombdood> ()
21:28:58 <ihope_> ...
21:29:04 <ihope_> ~pexec self.listen
21:29:07 <bsmntbombdood> ()
21:29:08 <ihope_> ~pexec self.raw("PRIVMSG #esoteric :foo")
21:29:09 <bsmnt_bot_chroot> foo
21:29:13 <ihope_> ()?
21:29:16 <bsmntbombdood> I assume you are trying to call self.listen
21:29:25 <ihope_> Yes.
21:29:35 <bsmntbombdood> ~pexec self.listen()
21:29:37 <bsmntbombdood> ~ps
21:29:38 <bsmnt_bot_chroot> 0: 'self.listen()', 2.08 seconds
21:29:46 <ihope_> Oh.
21:29:57 <ihope_> Curse Python or Haskell.
21:30:45 <ihope_> ~emerg self.raw("PRIVMSG #esoteric :foo")
21:30:45 <bsmnt_bot_chroot> foo
21:30:45 <bsmnt_bot_chroot> foo
21:30:45 <bsmnt_bot_chroot> foo
21:30:50 <ihope_> Uh.
21:30:58 <ihope_> Um.
21:30:58 <bsmntbombdood> ~heh
21:31:01 <bsmntbombdood> heh
21:31:03 <bsmntbombdood> ~ps
21:31:04 <bsmnt_bot_chroot> 0: 'self.listen()', 88.13 seconds
21:31:07 <bsmntbombdood> ~kill 0
21:31:11 <bsmntbombdood> ~ps
21:31:11 <bsmnt_bot_chroot> 0: 'self.listen()', 95.64 seconds, killed
21:31:23 <ihope_> ~emerg self.raw("PRIVMSG #esoteric :foo")
21:31:23 <bsmnt_bot_chroot> foo
21:31:24 <bsmnt_bot_chroot> foo
21:31:24 <bsmnt_bot_chroot> foo
21:31:29 <ihope_> Hmm.
21:31:43 <bsmntbombdood> hmm
21:31:59 <bsmntbombdood> ~ps
21:32:00 <bsmnt_bot_chroot> 0: 'self.listen()', 143.97 seconds, killed
21:32:06 <bsmntbombdood> DIE DAMN YOU
21:33:15 <ihope_> ~pexec self.do_callbacks(":bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :~exec self.raw('PRIVMSG #esoteric :foo')")
21:33:15 <bsmnt_bot_chroot> foo
21:33:19 <ihope_> Yay!
21:33:25 <bsmntbombdood> heh
21:33:48 <bsmntbombdood> ~exec self.print_callbacks()
21:33:56 <bsmntbombdood> duh you dumb shit
21:34:06 <bsmntbombdood> you put ~emerg in there 4 times
21:34:17 <ihope_> That's nice.
21:34:23 <bsmntbombdood> ~exec for i in range(4): self.raw_regex_queue.pop()
21:34:26 <bsmntbombdood> ~exec self.print_callbacks()
21:34:33 <bsmntbombdood> ~ps
21:34:33 <bsmnt_bot_chroot> 0: 'self.listen()', 297.63 seconds, killed
21:35:52 <ihope_> ~pexec self.raw("PRIVMSG #esoteric :" + [(i[0].pattern, i[1].__name__) for i in self.raw_regex_queue])
21:36:14 <bsmntbombdood> TypeError: cannot concatenate 'str' and 'list' objects
21:36:19 <ihope_> Pah.
21:36:23 <bsmntbombdood> use %s
21:36:45 <ihope_> ~pexec self.raw("PRIVMSG #esoteric :%s" % [(i[0].pattern, i[1].__name__) for i in self.raw_regex_queue])
21:36:46 <bsmnt_bot_chroot> [('^PING.*$', 'pong'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG \\S* :~quit ?(.*)', 'do_quit'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG \\S* :~raw (.*)', 'do_raw'), ('^\\S+ PRIVMSG \\S+ :~ctcp (\\S+) (.+)', 'do_ctcp'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG \\S* :~exec (.*)', 'do_exec'), ('\\S+ PRIVMSG #esoteric :~pexec (.*)', 'do_exec'), ('\\S+ PRIVMSG \\S+ :~ps', 'do_ps'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG \\S* :~kill (.*)', 'do_kill'
21:36:48 -!- oklobot2 has quit (Read error: 104 (Connection reset by peer)).
21:36:50 <ihope_> Fun.
21:37:22 <bsmntbombdood> indeed
21:38:09 <ihope_> ~pexec self.esoteric = lambda x: self.raw("PRIVMSG #esoteric :%s" % x)
21:38:14 <ihope_> ~pexec self.esoteric(3)
21:38:36 <bsmntbombdood> NameError: global name 'self' is not defined
21:38:39 <ihope_> ~pexec self.esoteric = lambda self, x: self.raw("PRIVMSG #esoteric :%s" % x)
21:38:44 <ihope_> ~pexec self.esoteric(3)
21:38:56 <bsmntbombdood> ~pexec self.esoteric = lambda self, x: bot.raw("PRIVMSG #esoteric :%s" % x)
21:39:06 <bsmntbombdood> ~pexec self.esoteric(3)
21:39:07 <ihope_> ~pexec self.esoteric(3)
21:39:26 <bsmntbombdood> one sec
21:39:27 <ihope_> You figure it out.
21:39:36 <bsmntbombdood> ~pexec self.raw_regex_queue.pop()\
21:39:44 <bsmntbombdood> ~pexec self.raw_regex_queue.pop()
21:40:06 <bsmntbombdood> ~pexec self.esoteric = lambda x: bot.raw("PRIVMSG #esoteric :%s" % x)
21:40:17 <bsmntbombdood> ~exec self.esoteric(3)
21:40:17 <bsmnt_bot_chroot> 3
21:40:21 <bsmntbombdood> odd
21:41:30 <ihope_> ~exec self.esoteric(self.esoteric)
21:41:52 <bsmntbombdood> ~pexec self.esoteric(self.esoteric)
21:41:53 <bsmnt_bot_chroot> <function <lambda> at 0xb7c609cc>
21:42:06 -!- Sgeo has quit (Remote closed the connection).
21:42:26 * ihope_ slaps himself
21:42:34 * ihope_ slaps GregorR, too, just because
21:43:32 <ihope_> ~pexec self.esoteric(1/0)
21:43:40 <bsmntbombdood> no
21:43:44 <ihope_> No?
21:43:47 <bsmntbombdood> 1/0 doesn't have a result
21:43:56 <ihope_> Did that give an error?
21:44:07 <bsmntbombdood> raises an except before self.esoteric is called
21:44:53 <bsmntbombdood> ZeroDivisionError: integer division or modulo by zero
21:45:29 <ihope_> I take it putting a catch in self.esoteric won't work.
21:45:44 <bsmntbombdood> nope, self.esoteric is never called
21:46:24 <ihope_> Thunk, then?
21:46:35 <bsmntbombdood> ?
21:46:48 <ihope_> Can I declare a lambda that takes no arguments?
21:46:56 <bsmntbombdood> think so
21:47:04 <ihope_> How?
21:47:12 <bsmntbombdood> lambda : 1
21:47:28 <ihope_> ~pexec self.esoteric = lambda x: bot.raw("PRIVMSG #esoteric :%s" % x())
21:47:37 <ihope_> ~pexec self.esoteric(lambda: "foo")
21:47:38 <bsmnt_bot_chroot> foo
21:47:47 <ihope_> Wonderful.
21:48:34 <ihope_> How do I declare a function that can take a variable number of arguments?
21:49:19 <bsmntbombdood> lambda *x : x
21:49:29 <bsmntbombdood> type(x) == list
21:49:30 <CakeProphet> x being a tuple
21:49:37 <bsmntbombdood> er, yeah
21:49:47 <CakeProphet> that's for positional arguments though.
21:49:54 <CakeProphet> to do keyword arguments use  **x
21:49:58 <CakeProphet> x being a dictionary.
21:50:04 <ihope_> Positional'll work.
21:51:37 <ihope_> And how would I take the first element of that list and apply it to the rest of the elements?
21:51:45 <bsmntbombdood> heh
21:52:01 <bsmntbombdood> lambda *x : x[0](x[1:])
21:53:03 <ihope_> There the arguments are the remaining elements of the list?
21:53:38 <bsmntbombdood> huh?
21:53:53 <ihope_> If the elements are foo, bar, and baz, will that call foo(bar,baz)?
21:53:59 <bsmntbombdood> yeah
21:54:05 <ihope_> ~pexec self.apply_thunk = lambda *x: lambda: x[0](x[1:])
21:54:07 <bsmntbombdood> lisp stil
21:54:13 <bsmntbombdood> *style
21:54:14 <ihope_> What?
21:54:16 <ihope_> Oh.
21:55:58 <ihope_> ~pexec self.esoteric(self.apply_thunk(lambda x,y: x+y, 3, 5))
21:56:16 <ihope_> What's the error this time?
21:56:21 <bsmntbombdood> TypeError: <lambda>() takes exactly 2 arguments (1 given)
21:56:28 <bsmntbombdood> :/
21:57:11 <ihope_> Wait, wait...
21:57:12 <bsmntbombdood> ~exec print self.apply_thunk(lambda x,y: x+y, 3, 5)
21:57:32 <ihope_> Ideally, that's a lambda taking no arguments.
21:57:34 <bsmntbombdood> hmm
21:57:41 <ihope_> What is it?
21:57:59 <bsmntbombdood> apply_thunk is returning a function
21:58:10 <ihope_> Yeah, it's supposed to do that.
21:58:13 <bsmntbombdood> ~pexec print self.apply_thunk(lambda x,y: x+y, 3, 5)()
21:58:17 <bsmntbombdood> ~pexec print self.apply_thunk(lambda x,y: x+y, 3, 5)(1,2)
21:58:25 <bsmntbombdood> ~pexec print self.apply_thunk(lambda x,y: x+y, 3, 5)()
21:58:47 <bsmntbombdood> hmm
21:59:00 <ihope_> What did those do?
21:59:10 <bsmntbombdood> TypeError: <lambda>() takes no arguments (2 given)
21:59:12 <CakeProphet> called the function returned by apply_thunk... I'd imagine.
21:59:15 <bsmntbombdood> TypeError: <lambda>() takes exactly 2 arguments (1 given)
21:59:39 <bsmntbombdood> ??????
21:59:42 <CakeProphet> Use parenthesis to avoid any parsing confusion.
21:59:44 <ihope_> The first one is given by the first and the third?
21:59:54 <ihope_> And the second is given by the second?
22:00:04 <bsmntbombdood> ooooh
22:00:06 <bsmntbombdood> I know
22:00:16 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
22:00:31 <bsmntbombdood> ~pexec self.apply_thunk = lambda *x: lambda: x[0](*x[1:])
22:00:42 <bsmntbombdood> ~pexec print self.apply_thunk(lambda x,y: x+y, 3, 5)
22:00:48 <bsmntbombdood> crap
22:00:55 <ihope_> ~pexec self.esoteric(self.apply_thunk(lambda x,y: x+y, 3, 5))
22:00:55 <bsmnt_bot_chroot> 8
22:00:58 <ihope_> Works.
22:01:11 <bsmntbombdood> ~pexec print self.apply_thunk(lambda x,y: x+y, 3, 5)()
22:01:16 <bsmntbombdood> yeah
22:01:32 <CakeProphet> ....you basically just created a.... lambda wrapper.
22:02:32 <ihope_> apply_thunk creates a thunk, and esoteric forces it.
22:02:39 <bsmntbombdood> what's a thunk?
22:02:57 <ihope_> It's an expression that hasn't been evaluated yet, pretty much.
22:03:20 <ihope_> And it's represented as a function taking nothing.
22:03:44 <ihope_> Now to combine esoteric with apply_thunk, because there's really no reason to have both.
22:04:23 <ihope_> ~pexec self.esoteric = lambda *x: bot.raw("PRIVMSG #esoteric :%s" % (lambda: x[0](*x[1:]))())
22:04:37 <ihope_> ~pexec self.esoteric(lambda x,y: x+y, 3, 5)
22:04:38 <bsmnt_bot_chroot> 8
22:04:46 <ihope_> Yay!
22:04:47 <CakeProphet> a thunk is a lambda then.
22:04:51 <CakeProphet> a lambda with no arguments.
22:04:51 <ihope_> Yep.
22:05:00 <CakeProphet> ...so... just use a lambda with no arguments.  :P
22:05:01 <ihope_> And there's really no reason to keep the thunk stuff.
22:05:19 <ihope_> ~pexec self.esoteric = lambda *x: bot.raw("PRIVMSG #esoteric :%s" % x[0](*x[1:]))
22:05:25 <ihope_> ~pexec self.esoteric(lambda x,y: x+y, 3, 5)
22:05:26 <bsmnt_bot_chroot> 8
22:05:36 * CakeProphet considered a thunk-like thing for a language.
22:05:56 <CakeProphet> I wanted to give control to odd parts of the languages operation... such as when to evaluate.
22:06:46 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:09:40 -!- Sgeo has joined.
22:10:03 <ihope_> ~pexec self.esoteric = lambda *x: bot.raw("PRIVMSG #esoteric :%s" % try: x[0](*x[1:]) except: "Error")
22:10:12 <ihope_> That work, bsmntbombdood?
22:11:20 <ihope_> ~pexec self.esoteric(lambda x, y: x/y, 1, 0)
22:11:30 <ihope_> I'm guessing not.
22:11:40 <ihope_> ~pexec self.esoteric(lambda: 3)
22:11:40 <bsmnt_bot_chroot> 3
22:11:49 <ihope_> self.esoteric is still working, at least.
22:17:34 <bsmntbombdood> what?
22:17:40 <bsmntbombdood> ZeroDivisionError: integer division or modulo by zero
22:17:58 <bsmntbombdood>  SyntaxError: invalid syntax
22:18:14 <bsmntbombdood> you can't have try: and except: on the same line
22:18:16 <ihope_> The SyntaxError's for the try/except thing up there?
22:18:22 <bsmntbombdood> yeah
22:18:36 <bsmntbombdood> ~ps
22:18:47 <bsmntbombdood> ...
22:19:09 <bsmntbombdood> ~exec print "foo"
22:19:19 <bsmntbombdood> ~exec self.print_callbacks()
22:19:27 <bsmntbombdood> uuuh
22:19:32 <bsmntbombdood> ~quit
22:19:33 -!- bsmnt_bot_chroot has quit.
22:19:35 -!- bsmnt_bot_chroot has joined.
22:19:39 <bsmntbombdood> ~ps
22:19:39 <bsmnt_bot_chroot> None
22:19:51 <bsmntbombdood> ~pexec self.esoteric = lambda *x: bot.raw("PRIVMSG #esoteric :%s" % x[0](*x[1:]))
22:20:02 -!- digital_me has quit ("Lost terminal").
22:20:51 <bsmntbombdood> ~pexec __import__("time").sleep(100); self.raw("PRIVMSG #esoteric :I rule")
22:20:54 <bsmntbombdood> ~ps
22:20:54 <bsmnt_bot_chroot> 0: '__import__("time").sleep(100); self.raw("PRIVMSG #esoteric :I rule")', 2.90 seconds
22:21:07 <bsmntbombdood> ~pexec __import__("time").sleep(100); self.raw("PRIVMSG #esoteric :I lose")
22:21:08 <bsmntbombdood> ~ps
22:21:09 <bsmnt_bot_chroot> 0: '__import__("time").sleep(100); self.raw("PRIVMSG #esoteric :I rule")', 17.31 seconds
22:21:09 <bsmnt_bot_chroot> 1: '__import__("time").sleep(100); self.raw("PRIVMSG #esoteric :I lose")', 1.60 seconds
22:21:12 <bsmntbombdood> ~kill 1
22:21:17 <bsmntbombdood> ~ps
22:21:17 <bsmnt_bot_chroot> 0: '__import__("time").sleep(100); self.raw("PRIVMSG #esoteric :I rule")', 25.37 seconds
22:21:17 <bsmnt_bot_chroot> 1: '__import__("time").sleep(100); self.raw("PRIVMSG #esoteric :I lose")', 9.66 seconds, killed
22:21:35 <ihope_> Killed, not dead.
22:21:40 <bsmntbombdood> not yet
22:21:52 <bsmntbombdood> It will be killed when sleep returns
22:22:31 <bsmnt_bot_chroot> I rule
22:23:00 <bsmntbombdood> indeed
22:23:02 <bsmntbombdood> ~ps
22:23:02 <bsmnt_bot_chroot> None
22:23:04 -!- kotrin has left (?).
22:23:07 <bsmntbombdood> see?
22:23:18 <ihope_> Cool.
22:23:39 <bsmntbombdood> It's some crazy code to do that
22:24:10 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:24:12 -!- bsmnt_bot_chroot has joined.
22:24:17 <bsmntbombdood> ~pexec __import__("time").sleep(10); self.raw("PRIVMSG #esoteric :I lose")
22:24:28 <bsmnt_bot_chroot> I lose
22:24:36 <bsmntbombdood> interesting
22:24:56 <bsmntbombdood> (watching debug messages on stdout)
22:25:04 <ihope_> ~pexec thread.start_new_thread(self.exec_execer, ("self.raw('PRIVMSG #esoteric :I win')", (globals(), locals())))
22:25:04 <bsmnt_bot_chroot> I win
22:25:11 <ihope_> Wonderful.
22:25:26 <bsmntbombdood> wonderful
22:25:46 <ihope_> ~pexec self.exec_string = lambda x: thread.start_new_thread(self.exec_execer, (x, (globals(), locals())))
22:26:02 <ihope_> ~pexec self.exec_string("PRIVMSG #esoteric :Wonderful.")
22:26:20 <bsmntbombdood> NameError: global name 'self' is not defined
22:26:32 <bsmntbombdood> the scope for lambdas is fucked up
22:26:33 <ihope_> ~pexec self.exec_string = lambda x: thread.start_new_thread(bot.exec_execer, (x, (globals(), locals())))
22:26:39 <ihope_> ~pexec self.exec_string("PRIVMSG #esoteric :Wonderful.")
22:26:50 <bsmntbombdood> NameError: name 'PRIVMSG' is not defined
22:26:56 <ihope_> I'm guessing that's the globals() and locals()
22:27:15 <bsmntbombdood> ~pexec self.exec_string("self.raw('PRIVMSG #esoteric :Wonderful.')")
22:27:19 <bsmntbombdood> hrm
22:27:21 <bsmntbombdood> right
22:27:27 <bsmntbombdood> ~pexec self.exec_string("bot.raw('PRIVMSG #esoteric :Wonderful.')")
22:27:27 <bsmnt_bot_chroot> Wonderful.
22:27:41 <ihope_> Oh, right.
22:27:55 <bsmntbombdood> In that ~pexec, we were given 8 chances to quit
22:28:17 <ihope_> Hmm?
22:28:30 <bsmntbombdood> ie, the trace function was called 8 times
22:30:37 <ihope_> ~pexec self.exec_string = lambda x: thread.start_new_thread(bot.exec_execer, (x, env))
22:30:45 <ihope_> Did that give any errors?
22:30:52 <bsmntbombdood> not yet
22:30:59 <ihope_> ~pexec self.exec_string("self.raw('PRIVMSG #esoteric :Wonderful.')")
22:31:08 <bsmntbombdood> NameError: global name 'env' is not defined
22:31:15 <ihope_> Yay.
22:31:19 <ihope_> ~pexec self.exec_string("bot.raw('PRIVMSG #esoteric :Wonderful.')")
22:31:22 <bsmntbombdood> ...
22:31:27 <ihope_> ~pexec self.exec_string = lambda x: thread.start_new_thread(bot.exec_execer, (x, (globals(), locals())))
22:31:33 <bsmntbombdood> there you go
22:33:09 <bsmntbombdood> but what's the point?
22:34:31 <ihope_> Executing multiple lines of stuff.
22:34:39 <bsmntbombdood> aaah
22:34:58 <ihope_> Aaah?
22:35:06 <bsmntbombdood> Aaah.
22:35:10 <bsmntbombdood> I concur
22:35:16 <ihope_> Oh.
22:35:51 <ihope_> So not at all like "oof"?
22:36:53 <bsmntbombdood> no
22:38:19 <ihope_> ~pexec self.exec_string("def self.exec_string(x):\n    env = (globals(), locals())\n    thread.start_new_thread(bot.exec_execer, (x, env))")
22:38:31 <ihope_> ~pexec self.exec_string("self.raw('PRIVMSG #esoteric :Wonderful.')")
22:38:45 <ihope_> ~pexec self.exec_string("bot.raw('PRIVMSG #esoteric :Wonderful.')")
22:38:46 <bsmnt_bot_chroot> Wonderful.
22:38:54 <ihope_> That one worked, at least.
22:39:21 <ihope_> ~pexec self.exec_string("def self.exec_string(x):\n env = (globals(), locals())\n thread.start_new_thread(bot.exec_execer, (x, env))")
22:39:27 <ihope_> ~pexec self.exec_string("self.raw('PRIVMSG #esoteric :Wonderful.')")
22:39:42 <ihope_> Maybe three's the magic number.
22:39:48 <ihope_> ~pexec self.exec_string("def self.exec_string(x):\n env = (globals(), locals())\n thread.start_new_thread(bot.exec_execer, (x, env))")
22:40:02 <ihope_> ~pexec self.exec_string("self.raw('PRIVMSG #esoteric :Wonderful.')")
22:40:13 <ihope_> Maybe it's not.
22:40:31 <ihope_> Oh well. It still works.
22:43:35 <bsmntbombdood> NameError: name 'self' is not defined
22:43:49 <bsmntbombdood> SyntaxError: invalid syntax
22:44:04 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:44:06 -!- bsmnt_bot_chroot has joined.
22:44:18 <bsmntbombdood> ~pexec self.exec_string = lambda x: thread.start_new_thread(bot.exec_execer, (x, (globals(), locals())))
22:45:21 <bsmntbombdood> I need to put a wrapper around stderr and stdout
22:46:07 -!- oerjan has joined.
22:47:31 <bsmntbombdood> sys.stdout.write = lambda x : self.raw("PRIVMSG #bsmnt_bot :%s" % x)
22:47:36 <bsmntbombdood> that should do it, right?
22:47:45 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:47:48 -!- bsmnt_bot_chroot has joined.
22:47:51 <bsmntbombdood> ~exec print "hi"
22:47:55 <bsmntbombdood> er
22:48:02 <bsmntbombdood> ~raw JOIN #bsmnt_bot
22:48:12 <bsmntbombdood> ~raw JOIN #bsmnt_bot
22:48:17 <bsmntbombdood> ~exec print "hi"
22:48:20 <bsmntbombdood> damn
22:48:38 <bsmntbombdood> ~exec sys.stdout.write("hi")
22:48:43 <bsmntbombdood> Unhandled exception in thread started by <bound method IRCbot.exec_execer of <__main__.IRCbot instance at 0xb7cbcb2c>>
22:49:05 <bsmntbombdood> ?????
22:49:19 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:49:23 -!- bsmnt_bot_chroot has joined.
22:49:23 <bsmntbombdood> ~raw JOIN #bsmnt_bot
22:49:26 <bsmntbombdood> ~exec sys.stdout.write("hi")
22:49:30 <bsmntbombdood> grar
22:49:44 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:49:47 -!- bsmnt_bot_chroot has joined.
22:49:48 <bsmntbombdood> ~raw JOIN #bsmnt_bot
22:49:50 <bsmntbombdood> ~exec sys.stdout.write("hi")
22:51:12 <bsmntbombdood> arghhh
22:52:42 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:52:45 -!- bsmnt_bot_chroot has joined.
22:52:49 <bsmntbombdood> ~raw JOIN #bsmnt_bot
22:52:52 <bsmntbombdood> ~exec sys.stdout.write("hi")
22:52:58 <bsmntbombdood> ~exec sys.stderr.write("hi")
22:53:10 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :foo")
22:53:14 <bsmntbombdood> ....
22:54:05 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:54:06 -!- bsmnt_bot_chroot has joined.
22:54:09 <bsmntbombdood> ~raw JOIN #bsmnt_bot
22:54:13 <bsmntbombdood> ~exec sys.stderr.write("hi")
22:54:27 <bsmntbombdood> AttributeError: 'file' object attribute 'write' is read-only
22:54:40 <bsmntbombdood> WELL WELL WELL
22:55:25 -!- ivan` has joined.
22:55:39 <bsmntbombdood> I do need to write a wrapper class
22:55:54 -!- dantekgeek has joined.
22:56:00 -!- zedrdave has joined.
22:56:04 <dantekgeek> Hi there.
22:56:13 <ihope_> Ello.
22:56:39 <dantekgeek> I'm trying to learn programming, and someone on a forum told me that "brainfuck" would be a good easy starting language.
22:56:50 <ihope_> He was most likely joking.
22:56:56 <dantekgeek> aw damn
22:57:01 <dantekgeek> zedrdave: that was no fun
22:57:07 <dantekgeek> these guys are too seroius!
22:57:14 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:57:15 -!- bsmnt_bot_chroot has joined.
22:57:18 -!- dantekgeek has left (?).
22:57:20 <bsmntbombdood> ~raw JOIN #bsmnt_bot
22:57:25 <bsmntbombdood> ~exec sys.stderr.write("hi")
22:57:46 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:57:48 -!- bsmnt_bot_chroot has joined.
22:57:49 <bsmntbombdood> ~raw JOIN #bsmnt_bot
22:57:51 <bsmntbombdood> ~exec sys.stderr.write("hi")
22:57:52 <bsmnt_bot_chroot> hi
22:57:57 <bsmntbombdood> yaya
22:58:05 <oerjan> what, did he call _us_ serious? :)
22:58:22 <ivan`> this bsmnt thing isn't part of the lame troll
22:58:26 <ivan`> whatever it is
22:58:33 <oklopol> oerjan
22:58:46 <oklopol> is it okay i put your codes in oklobots reference?
22:59:06 -!- ivan` has left (?).
22:59:33 <oerjan> certainly
23:00:02 <oklopol> good, coz i did :)
23:00:04 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:00:05 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
23:00:06 -!- bsmnt_bot_chroot has joined.
23:00:13 <bsmntbombdood> ~exec print "exception
23:00:13 <bsmnt_bot_chroot> Traceback (most recent call last):
23:00:13 <bsmnt_bot_chroot>   File "/bot/ircbot.py", line 168, in exec_execer
23:00:13 <bsmnt_bot_chroot>     exec command in env[0], env[1]
23:00:15 <bsmnt_bot_chroot>   File "<string>", line 1
23:00:17 <ihope_> bsmnt_bot_chroot: you missed it!
23:00:17 <bsmnt_bot_chroot>  
23:00:19 <bsmnt_bot_chroot>     print "exception
23:00:21 <bsmnt_bot_chroot>  
23:00:23 <bsmnt_bot_chroot>                    ^
23:00:25 <bsmnt_bot_chroot>  
23:00:27 <bsmnt_bot_chroot> SyntaxError: EOL while scanning single-quoted string
23:00:37 <ihope_> It's a little bit spammy.
23:00:47 <bsmntbombdood> I'm working on it!
23:00:56 <ihope_> ~pexec 3
23:01:00 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:01:01 -!- bsmnt_bot_chroot has joined.
23:01:03 <bsmntbombdood> ~exec print "exception
23:01:14 <bsmntbombdood> ..
23:01:57 <bsmntbombdood> uuuh crap
23:01:57 <bsmntbombdood> ~qui
23:02:07 <CakeProphet> ~exec print "exception"
23:02:09 <CakeProphet> ???
23:02:11 -!- zedrdave has left (?).
23:02:22 <bsmntbombdood> ~quit
23:02:22 <bsmntbombdood> it won't die
23:02:27 <bsmntbombdood> ~ps
23:02:30 <bsmntbombdood> ...
23:02:37 <bsmntbombdood> wtf happened
23:03:22 <bsmntbombdood> ....
23:03:26 <bsmntbombdood> DIE
23:04:21 <oerjan> may i recommend kill -9 ? :)
23:04:22 <bsmntbombdood> uuuh wtf
23:05:13 -!- bsmnt_bot_chroot has quit (Read error: 131 (Connection reset by peer)).
23:05:17 -!- bsmnt_bot_chroot has joined.
23:05:17 <bsmntbombdood> finally
23:05:22 <bsmntbombdood> foo
23:05:30 <bsmntbombdood> ~exec print "exception
23:05:30 <bsmnt_bot_chroot> Traceback (most recent call last):
23:05:31 <bsmnt_bot_chroot>   File "/bot/ircbot.py", line 168, in exec_execer
23:05:31 <bsmnt_bot_chroot>     exec command in env[0], env[1]
23:05:33 <bsmnt_bot_chroot>   File "<string>", line 1
23:05:35 <bsmnt_bot_chroot>  
23:05:37 <bsmnt_bot_chroot>     print "exception
23:05:39 <bsmnt_bot_chroot>  
23:05:41 <bsmnt_bot_chroot>                    ^
23:05:43 <bsmnt_bot_chroot>  
23:05:45 <bsmnt_bot_chroot> SyntaxError: EOL while scanning single-quoted string
23:06:00 <oerjan> still a bit spammy for a response to a single line
23:06:02 -!- pikhq has joined.
23:06:25 <bsmntbombdood> what should it send?
23:06:47 <oerjan> i believe EgoBot will send all but the first line to the original sender rather than the channel.
23:07:15 <oerjan> although not in all cases, confer !ps
23:07:43 <bsmntbombdood> I think a dedicated error channel is a good idea
23:08:51 <ihope_> Don't print blank lines.
23:09:05 <bsmntbombdood> that too
23:10:22 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:10:24 -!- bsmnt_bot_chroot has joined.
23:11:07 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:11:09 -!- bsmnt_bot_chroot has joined.
23:13:41 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:13:43 -!- bsmnt_bot_chroot has joined.
23:15:05 <bsmntbombdood> join #bsmnt_bot_chroot_errors, everyone
23:15:37 <bsmntbombdood> ~exec print "excpetion 
23:15:40 <oerjan> i note you sometimes find self.register_raw a bit limiting.  Perhaps add an optional guard argument, a lambda that can be used to add checks that are awkward with regexps.  It could take the same arguments as the second lambda.
23:15:57 <pikhq> MY COMPUTER LIVES!!!
23:16:05 <oerjan> RUN AWAY!
23:16:24 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:16:26 -!- bsmnt_bot_chroot has joined.
23:16:27 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:16:29 -!- bsmnt_bot_chroot has joined.
23:16:44 <bsmntbombdood> oerjan: hmm, that might be nice
23:16:46 <bsmntbombdood> ~exec print "excpetion 
23:17:23 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:17:25 -!- bsmnt_bot_chroot has joined.
23:17:29 <bsmntbombdood> ~exec print "excpetion 
23:17:52 <bsmntbombdood> ok, #bsmnt_bot_chroot_errors has stderr and stdout redirected to it
23:18:35 <ihope_> !exec 3
23:18:39 <ihope_> ...
23:18:41 <ihope_> ~pexec 3
23:18:45 <bsmntbombdood> that's not an exception
23:18:51 <ihope_> Stop using ~exec, eh?
23:18:57 <bsmntbombdood> ~pexec print "hi"
23:18:58 <ihope_> ~pexec print 3
23:19:03 <bsmntbombdood> :)
23:19:26 <bsmntbombdood> ~pexec print "hi\nagain"
23:20:12 <oklopol> why not stdout here?
23:20:29 <bsmntbombdood> that would work too
23:21:43 <oklopol> can you put it?
23:22:23 <bsmntbombdood> hmm I need to change the interface for exec_execer then
23:23:58 <oklopol> you gonna do it?=
23:24:10 <bsmntbombdood> maybe
23:24:16 <bsmntbombdood> ~raw join #baadf00d 
23:24:46 <oklopol> i mean, are you gonna do it now or just possibly later because i'll go to sleep if it takes >10 min
23:26:37 <bsmntbombdood> not right now
23:26:47 <oklopol> okay, nn then
23:26:50 <oklopol> ->
23:28:52 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:28:55 -!- bsmnt_bot_chroot has joined.
23:29:02 <bsmntbombdood> foo
23:30:50 <bsmntbombdood> ~exec print "asdf""
23:31:09 <ihope_> When's the last time you registered a command?
23:31:28 <bsmntbombdood> ?
23:33:07 <ihope_> ~pexec self.register_raw('(.*)', lambda x,y: print x)
23:33:16 <ihope_> Does it work?
23:33:30 <ihope_> No?
23:33:42 <bsmntbombdood> ?
23:34:12 <bsmntbombdood> you can't print in a lambda
23:34:55 <CakeProphet> ~pexec self.register_raw('(.*)', lambda x,y: sys.write(x + "\n")))
23:35:05 <CakeProphet> hmmm
23:35:15 <ihope_> ~pexec self.register_raw('(.*)', lambda x,y: self.raw("PRIVMSG #bsmnt_bot_chroot_errors :%s" % x))
23:35:22 <ihope_> No errors?
23:35:23 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:35:24 -!- bsmnt_bot_chroot has joined.
23:35:27 <CakeProphet> hmmm
23:35:34 <ihope_> That clearly didn't work.
23:35:37 <bsmntbombdood> uuuh
23:36:16 <ihope_> I think you should try to catch a few more errors.
23:36:37 <bsmntbombdood> ~pexec self.register_raw(".*", lambda x : sys.__stdout__.write("message"))
23:36:39 <CakeProphet> Just have it spit error messages onto the channel.
23:36:39 <bsmntbombdood> a
23:36:48 <bsmntbombdood> CakeProphet: #bsmnt_bot_chroot_errors 
23:37:04 <bsmntbombdood> ~pexec self.raw_regex_queue.pop()
23:37:38 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:37:40 -!- bsmnt_bot_chroot has joined.
23:37:53 <bsmntbombdood> ~pexec self.register_raw('(.*)', lambda x,y: self.raw("PRIVMSG #bsmnt_bot_chroot_errors :%s" % x))
23:37:57 <bsmntbombdood> j
23:37:57 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:38:00 -!- bsmnt_bot_chroot has joined.
23:38:46 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:38:48 -!- bsmnt_bot_chroot has joined.
23:39:01 <bsmntbombdood> hmmm
23:39:07 <CakeProphet> ~pexec self.register_raw('(.*)', lambda x,y: self.raw("PRIVMSG CakeProphet :%s" % x))
23:39:07 <CakeProphet> hmmm
23:39:20 -!- CakeProphet has quit ("haaaaaaaaaa").
23:39:21 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:39:22 -!- bsmnt_bot_chroot has joined.
23:40:21 <bsmntbombdood> I think it's an error in the callback
23:42:21 -!- anonfunc_ has joined.
23:43:20 <bsmntbombdood> foo
23:43:23 <bsmntbombdood> ~ps
23:43:24 <bsmnt_bot_chroot> None
23:44:35 <bsmntbombdood> ~exec self.register_raw("\S+ PRIVMSG #esoteric :(~quine .*)", lambda x, y : bot.raw("PRIVMSG #esoteric :%s" % y.group(1)))
23:44:39 <bsmntbombdood> ~quine foo
23:44:39 <bsmnt_bot_chroot> ~quine foo
23:44:49 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
23:44:55 <bsmntbombdood> ~exec self.register_raw("\S+ PRIVMSG #esoteric :(~quine.*)", lambda x, y : bot.raw("PRIVMSG #esoteric :%s" % y.group(1)))
23:45:12 <bsmntbombdood> ~quine foo
23:45:13 <bsmnt_bot_chroot> ~quine foo
23:45:14 <bsmntbombdood> ok
23:45:29 <bsmntbombdood> ~exec __import__("time").sleep("this is wrong")
23:45:45 <bsmntbombdood> ~exec raise SystemExit
23:45:49 <bsmntbombdood> ok
23:48:12 <ihope_> Windows doesn't really make any sense when it comes to tool tips...
23:48:19 <ihope_> Or ToolTips, or whatever they're called.
23:51:24 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:51:26 -!- bsmnt_bot_chroot has joined.
23:51:46 <bsmntbombdood> ok, now only tracebacks go to #bsmnt_bot_chroot_errors 
23:51:57 <bsmntbombdood> stdout was pooping on the other threads
23:52:04 <bsmntbombdood> ~pexec print "exvckhjo
23:52:58 <bsmntbombdood> ~pexec print "exvckhjo"
23:53:02 <bsmntbombdood> good
23:54:45 -!- puzzlet has joined.
23:57:23 -!- anonfunc has quit (Connection timed out).

2007-01-08:

00:12:37 -!- Sgeo has quit ("Ex-Chat").
00:27:11 <ihope_> ~pexec print "exvckhjo"
00:27:16 <ihope_> Wait, anonymous function?
00:29:48 <bsmntbombdood> ?
00:30:42 <ihope_> |<-- anonfunc has left chat.us.freenode.net (Connection timed out)
00:30:47 <bsmntbombdood> so?
00:30:48 <ihope_> Anonymous function.
00:31:34 <bsmntbombdood> ...
00:40:33 <bsmntbombdood> ~~~~~~~~
00:43:16 <bsmntbombdood> ~pexec while 1: self.raw("PRIVMSG #esoteric :It's %s" % time.asctime(time.gmtime())); __import__("time").sleep(60 * 30); 
00:43:16 <bsmnt_bot_chroot> It's Mon Jan  8 00:37:35 2007
00:43:22 <bsmntbombdood> ~ps
00:43:23 <bsmnt_bot_chroot> 0: 'while 1: self.raw("PRIVMSG #esoteric :It\'s %s" % time.asctime(time.gmtime())); __import__("time").sleep(60 * 30);', 6.84 seconds
00:48:21 <bsmntbombdood> My bot is cool
00:49:53 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:49:56 -!- bsmnt_bot_chroot has joined.
00:52:42 <bsmntbombdood> very cool
00:54:53 <ihope_> What are asctime and gmtime?
00:55:12 <ihope_> Ascension time and game time?
00:55:13 <bsmntbombdood> gmtime == time from epoch
00:55:23 <bsmntbombdood> asctime formats it
00:55:32 <ihope_> I see.
00:55:37 <ihope_> And what's the logic behind those names?
00:55:45 <bsmntbombdood> dunno
00:56:02 <ihope_> Maybe they're... um...
00:56:18 <bsmntbombdood> ~pexec self.raw("PRIVMSG #esoteric :%s" % time.gmtime())
00:56:19 <bsmnt_bot_chroot> (2007, 1, 8, 0, 50, 37, 0, 8, 0)
00:56:27 <bsmntbombdood> oh right
00:56:38 <ihope_> Maybe "a" is the Spanish pronoun "a" which can mean "to", and "s" stands for "string" and "c" for "converted".
00:56:45 <bsmntbombdood> heh
00:56:50 <bsmntbombdood> http://docs.python.org/lib/module-time.html
00:56:53 <ihope_> And gmtime would be like in GMT.
00:57:41 <ihope_> Or maybe asctime is short for ASCII.
00:58:03 <bsmntbombdood> who knows
00:58:08 <bsmntbombdood> quien sabe
01:00:27 <oerjan> that would probably be "convertado" or something.
01:00:51 <ihope_> And what's "string"?
01:01:15 <oerjan> no, it's generalissimo morte, a reference to Franco (ref. Monty Python)
01:01:37 <ihope_> ...What?
01:01:44 <ihope_> Oh.
01:01:53 <ihope_> Does that mean "generally dead"?
01:02:07 <oerjan> no, it means the Generalissimo is dead.
01:02:39 <ihope_> What's a Generalissimo?
01:03:21 <oerjan> There is only one Generalissimo.  You do know he died not very long after the epoch.
01:03:55 <oerjan> Although to some, it seemed like an eternity.
01:07:16 <bsmntbombdood> ~exec foo
01:07:23 * bsmntbombdood feels leet
01:07:24 <fizzie> The "gmtime" name quite likely comes from "GMT", since there's also "localtime" which returns a struct tm with the numbers in the local time zone.
01:08:20 <oerjan> but everyone knows it's called UTC nowadays. hmph.
01:08:28 <ihope_> ~exec self.foo
01:08:29 <bsmntbombdood> ~exec hmph
01:08:39 <bsmntbombdood> pexec...
01:08:51 <ihope_> Well, stop using ~exec~
01:08:55 <bsmntbombdood> fine
01:08:57 <ihope_> s/~/!/
01:09:01 <ihope_> ~pexec self.foo
01:09:18 <ihope_> ~pexec self.self.self.raw("JOIN #esoteric")
01:09:42 <bsmntbombdood> ...
01:09:51 <oerjan> you could switch exec and pexec, since p can be either "public" or "privileged" as you wish.
01:10:11 <bsmntbombdood> I suppose
01:10:13 <fizzie> I'm less sure about "asctime"; it might be about ascii, or the "as" might be something mysterious. After all, there's ctime() which does to time_t the same thing asctime does to a struct tm. (And the "c" _there_ is probably from "convert".)
01:10:17 <ihope_> I might well start using lots of ~pexec then.
01:10:33 <bsmntbombdood> ihope_: want me to switch?
01:10:44 <ihope_> Might as well.
01:10:54 <ihope_> And by that, I mean yes.
01:11:11 <bsmntbombdood> ~quit
01:11:11 -!- bsmnt_bot_chroot has quit.
01:11:14 -!- bsmnt_bot_chroot has joined.
01:11:17 <bsmntbombdood> there you go
01:13:49 <bsmntbombdood> ~exec print "fooasdf"
01:14:11 <ihope_> ~exec bot.exec_execer("bot.raw('PRIVMSG #esoteric foo')",(globals(),locals()))
01:14:12 <bsmnt_bot_chroot> foo
01:14:19 <ihope_> Always fun.
01:14:39 <bsmntbombdood> always
01:15:00 <ihope_> Every single time.
01:15:24 <bsmntbombdood> ~exec bot.exec_execer("try:\n raise "foo",(globals(),locals()))
01:15:28 <bsmntbombdood> erg
01:16:15 <bsmntbombdood> ~exec bot.exec_execer("try:\n raise \"foo\"\nexcept:\n print 'hi'",(globals(),locals()))
01:16:23 <bsmntbombdood> yay
01:58:13 -!- CakeProphet has joined.
01:59:06 <CakeProphet> .msg memoserv del 1
01:59:11 <CakeProphet> er...
02:02:46 <bsmntbombdood> ~raw PRIVMSG CakeProphet :Fail
02:02:50 <bsmntbombdood> :)
02:06:02 <CakeProphet> :(
02:07:39 <bsmntbombdood> :)
02:08:49 -!- ShadowHntr has quit ("End of line.").
02:14:20 <ihope_> :(
02:14:31 <ihope_> :)
02:14:41 <ihope_> Wait, what?
02:15:53 -!- pikhq has quit (Read error: 54 (Connection reset by peer)).
02:16:33 <bsmntbombdood> ~foo
02:16:48 <oerjan> !ps
02:16:52 <EgoBot> 2 oerjan: ps
02:17:11 <oerjan> !daemon cat bf ,[.,]
02:17:22 <oerjan> !cat food
02:17:26 <EgoBot> food
02:17:36 <oerjan> I just wanted to say that.
02:19:41 -!- pikhq has joined.
02:32:26 <bsmntbombdood> come on, someone do something clever with bsmnt_bot_chroot 
02:33:30 <oerjan> ~exec bot.raw("PRIVMSG :Like what?")
02:33:55 <oerjan> well that didn't work.
02:34:03 <bsmntbombdood> You fail at the IRC protocol
02:34:15 <oerjan> argh!
02:34:30 <oerjan> ~exec bot.raw("PRIVMSG #esoteric :Like this then?")
02:34:30 <bsmnt_bot_chroot> Like this then?
02:34:37 <bsmntbombdood> yep
02:43:58 <oerjan> ~exec argle = 3
02:44:24 <oerjan> ~exec bot.raw("PRIVMSG #esoteric :" + argle)
02:44:41 <oerjan> ~exec bot.raw("PRIVMSG #esoteric :" + str(argle))
02:44:57 <oerjan> hmm...
02:45:04 <oerjan> ~exec bot.argle = 3
02:45:08 <oerjan> ~exec bot.raw("PRIVMSG #esoteric :" + str(argle))
02:45:37 <oerjan> ~exec bot.raw("PRIVMSG #esoteric :Huh?")
02:45:37 <bsmnt_bot_chroot> Huh?
02:46:18 <oerjan> hmm..
02:46:24 <oerjan> ~exec bot.raw("PRIVMSG #esoteric :" + str(bot.argle))
02:46:24 <bsmnt_bot_chroot> 3
02:46:29 <oerjan> whew
02:47:35 <bsmntbombdood> oerjan: might want to join #bsmnt_bot_chroot_errors to see your errors
02:48:07 <oerjan> ~exec bot.raw("PRIVMSG #esoteric :" + str(argle))
02:53:41 -!- CakeProphet has quit (Read error: 104 (Connection reset by peer)).
02:54:07 -!- CakeProphet has joined.
03:11:53 <bsmnt_bot_chroot> 4
03:13:36 <bsmnt_bot_chroot> (1, 2)
03:40:52 -!- pikhq has quit ("leaving").
04:08:33 -!- ihope_ has quit (Connection timed out).
04:45:37 -!- bsmnt_bot_chroot has quit.
04:45:40 -!- bsmnt_bot_chroot has joined.
04:48:47 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:48:49 -!- bsmnt_bot_chroot has joined.
04:50:26 -!- bsmnt_bot_chroot has quit (Client Quit).
04:50:29 -!- bsmnt_bot_chroot has joined.
04:51:14 -!- bsmnt_bot_chroot has quit (Client Quit).
04:51:17 -!- bsmnt_bot_chroot has joined.
04:52:08 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:52:10 -!- bsmnt_bot_chroot has joined.
05:06:03 -!- CakeProphet has quit (Read error: 113 (No route to host)).
05:15:53 -!- oerjan has quit ("leaving").
05:24:04 <bsmntbombdood> mmm
05:24:16 <bsmntbombdood> I think I figured out how to do sandboxed execution in python
05:28:42 -!- RodgerTheGreat has quit.
05:34:53 -!- ShadowHntr has joined.
05:39:00 <bsmntbombdood> allowed_execs = copy.copy(__builtins__.__dict__)
05:39:18 <bsmntbombdood> allowed_execs["__import__"] = None
05:39:39 <bsmntbombdood> exec "importing anything here is impossible" in allowed_builtins
05:39:43 <bsmntbombdood> er
05:39:51 <bsmntbombdood> s/allowed_execs/allowed_builtins/
05:40:36 <bsmntbombdood> allowed_builtins["open"] = None
05:40:45 <bsmntbombdood> exec "importing or opening anything here is impossible" in allowed_builtins
05:57:11 <bsmntbombdood> I think
05:57:39 <bsmntbombdood> oops, nope
05:57:47 <bsmntbombdood>  exec "exec 'print open(\"foo\")' in {}" in my_builtins
05:57:48 <bsmntbombdood> :(
05:57:59 <bsmntbombdood> that's a pity
06:01:17 <bsmntbombdood> And exec is a statement, so that can't be taken away
06:36:43 -!- calamari has joined.
06:41:54 -!- calamari has quit ("Leaving").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
09:28:58 -!- ShadowHntr has quit ("End of line.").
10:39:20 -!- ihope_ has joined.
10:39:46 -!- ihope_ has changed nick to ihope.
13:35:57 -!- ihope has quit (Connection timed out).
16:22:17 -!- FabioNET has joined.
16:49:51 -!- digital_me has joined.
16:53:49 -!- tgwizard has joined.
17:18:35 -!- FabioNET has quit (Connection timed out).
17:18:45 -!- RodgerTheGreat has joined.
17:18:52 <RodgerTheGreat> hi
17:46:52 -!- FabioNET has joined.
18:22:02 -!- FabioNET has quit (Client Quit).
18:34:36 -!- anonfunc_ has quit (Read error: 110 (Connection timed out)).
19:08:28 -!- jix__ has joined.
19:10:04 -!- jix__ has changed nick to ijx.
19:10:07 -!- ijx has changed nick to jix.
19:16:28 -!- RodgerTheGreat_ has joined.
19:16:28 -!- RodgerTheGreat has quit (Read error: 54 (Connection reset by peer)).
19:16:47 -!- RodgerTheGreat_ has changed nick to RodgerTheGreat.
19:23:22 -!- ShadowHntr has joined.
19:27:41 <oklopol> http://esoteric.voxelperfect.net/wiki/PATH
19:27:49 <oklopol> can't be right
19:27:51 <oklopol> the example
19:52:17 <oklopol> http://esoteric.voxelperfect.net/wiki/BF-SC
19:52:39 <oklopol> this i don't understand, if you've got spare time, please tell me :)
19:53:03 <oklopol> ...what the silver coinage has to do with it
19:53:08 <oklopol> *sylver
19:59:49 -!- ShadowHntr has quit ("End of line.").
20:19:10 -!- pgimeno has changed nick to bobot.
20:19:28 -!- bobot has changed nick to pgimeno.
20:45:04 -!- oerjan has joined.
20:49:50 <bsmntbombdood> ~foo
20:54:20 -!- ihope_ has joined.
20:54:44 -!- ihope_ has changed nick to ihope.
20:56:04 -!- CakeProphet has joined.
20:56:32 <ihope> bsmnt!
20:56:38 <ihope> _bot_chroot!
20:59:19 <oklopol> i understand sylver coinage
20:59:26 <oklopol> not how it is related to that language
21:00:40 <oerjan> well, have you read the side effects of setting a cell, in the second paragraph under the box? 
21:02:00 <ihope> Talking about BF-SC, I take it.
21:02:10 <oerjan> yep
21:02:34 <ihope> Yeah, setting a cell is like playing it.
21:05:03 -!- Spacerat3004 has joined.
21:05:52 <oklopol> yeah, what is the relation between sylver coinage and bf-sc?
21:06:03 <oklopol> why would 6 be set if i set 3?
21:06:17 <oerjan> because it says so in that paragraph.
21:06:30 <oklopol> oh
21:06:47 <oklopol> i thought it meant it's what automatically happens given those rules
21:07:12 <oerjan> hope that is cleared up now. :)
21:08:40 <oerjan> ok, away for a while
21:11:12 <bsmntbombdood> iho!
21:11:15 <bsmntbombdood> pe!
21:11:28 <ihope> :-
21:11:30 <ihope> )
21:11:59 <bsmntbombdood> ~exec self.print_callbacks()
21:12:06 <ihope> Let's add some games together!
21:12:17 <bsmntbombdood> ~exec bot.print_callbacks()
21:12:25 <bsmntbombdood> games?
21:12:31 <ihope> Yes, games.
21:12:45 <bsmntbombdood> I want to get scoping right for ~exec
21:12:57 <ihope> They can be added, as long as they're of the right kind.
21:13:18 <bsmntbombdood> huh?
21:13:20 <bsmntbombdood> ~quit
21:13:20 -!- bsmnt_bot_chroot has quit.
21:13:24 -!- bsmnt_bot_chroot has joined.
21:13:37 <ihope> Namely, the kind where each player has a set of moves, and each move changes the game to a different one.
21:14:17 <bsmntbombdood> ~exec self.raw("PRIVMSG #bsmnt_bot_chroot_errors :%s" % globals())
21:14:21 <bsmntbombdood> ~exec self.raw("PRIVMSG #bsmnt_bot_chroot_errors :%s" % locals())
21:14:46 <ihope> And the one who can't move loses.
21:16:20 <Spacerat3004> no IRP allowed
21:16:21 <ihope> Rather, the player who can't move if it's that players turn. If it's your turn and you can't move, you lose.
21:16:21 <Spacerat3004> damn
21:16:34 <ihope> Spacerat3004: I think #irp is for that.
21:16:38 <Spacerat3004> oh i see
21:16:42 <ihope> Also, you can do this:
21:16:48 -!- ihope 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 - 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/.
21:16:56 <ihope> :-)
21:17:07 <bsmntbombdood> heh
21:18:46 <ihope> So why don't we... um, hmm.
21:19:02 <ihope> Let's add * to itself.
21:20:21 <ihope> * times 2 = the player who moves third loses
21:20:51 <ihope> 0 = the first player loses, * = the second player loses, * times 2 = the third player loses, * times 3 = the fourth player loses...
21:20:58 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
21:21:15 <CakeProphet> hmm... this is pretty cool..
21:21:52 <CakeProphet> I'm making an esolang for the sole purpose of dealing with cause-effect chains in a MUD 
21:22:03 <CakeProphet> Just cool that I'll actually be -using- it.... a lot.
21:28:59 <ihope> It'll be an esolang?
21:29:16 <ihope> Surely being an esolang is the sole purpose of an esolang.
21:30:00 <ihope> Well, I guess it depends on how you define an esolang.
21:30:25 <ihope> I'd define it as a language that's intentionally weird in some way.
21:31:53 <CakeProphet> It's going to look something like ORK with coroutines, not quite so object-oriented, not quite so verboose, and with weirder syntax.
21:32:30 <CakeProphet> Right now I'm calling it "Sophia"  (It's what I call almost all of my projects)
21:36:53 -!- Sgeo has joined.
21:38:51 <oerjan> Playing with nimbers, I see
21:39:23 <oerjan> Wait a minute...
21:39:36 <oerjan> third and fourth players?
21:42:23 <oerjan> Is this something different from Conway games?
21:44:41 <oerjan> Or is it just a different way of looking at symmetric ones?
21:46:50 <oklopol> http://esoteric.voxelperfect.net/wiki/Brainloller
21:47:07 <oklopol> rotate rigth?
21:47:11 <oklopol> *right
21:47:20 <oklopol> how the fuck do you rotate right?
21:47:25 <oklopol> is that clockwise?
21:48:02 <ihope> Yes.
21:48:12 <ihope> Right = clockwise, left = counter-clockwise.
21:49:08 <ihope> oerjan: if you have two players taking turns, third player = first player and fourth player = second player.
21:49:21 <ihope> The players who make the third and fourth moves.
21:52:18 <oerjan> right. i am used to considering all games where first player loses to be equivalent.
21:52:57 <ihope> They're not all equivalent if you want to add them together.
21:52:57 <oklopol> http://esoteric.voxelperfect.net/wiki/Brainfork
21:53:00 <oklopol> "Because Brainfork is a proper superset of Brainfuck, all Brainfuck programs are also valid Brainfork programs with identical semantics."
21:53:14 <oklopol> what about the brainfuck program Y?
21:53:20 <oerjan> i do think they are
21:53:24 <ihope> oklopol: except those containing Y :-)
21:53:27 <oklopol> :)
21:53:46 <oerjan> all _stripped_ brainfuck programs.
21:53:55 <ihope> Yeah, that.
21:54:02 <oklopol> yeah, i'm making a compendium of all bf-copies on the wiki site, if compendium means what i think it means
21:54:20 <ihope> A compendium of all whats?
21:54:25 <oklopol> yeah, i know what it meant, i don't know the use of saying that :)
21:54:34 <oklopol> bf-based langs
21:54:55 <oklopol> brainfuxxors
21:55:16 <oerjan> adding a game that the first player loses is an identity operation as far as outcome is concerned.
21:55:25 <oklopol> brainfork duplicates the memory, right?
21:55:37 <oerjan> as long as there are two players, at least.
21:55:41 <ihope> oklopol: I don't think so.
21:55:45 <oklopol> okay
21:55:57 <oklopol> "When a Y is encountered, the current thread forks, with the current cell being zeroed in the parent thread, and the pointer being moved one to the right and that cell set to 1 in the child."
21:56:01 <oklopol> what does that mean then?
21:56:08 <oklopol> i mean, when forking
21:56:19 <ihope> oerjan: well, if the second player can make a move, then adding it's not an identity operation.
21:56:44 <ihope> oklopol: um... uh, download the interpreter?
21:56:53 <oklopol> bah... k
21:56:55 <oklopol> :D
21:57:42 <ihope> I think each thread has its own tape pointer, but they share a tape.
21:57:50 <ihope> I mean, they have to share *something*, no?
21:58:28 -!- Spacerat3004 has quit.
21:58:38 <oklopol> dunno
21:58:41 <oklopol> i'll test
21:59:01 <oklopol> just don't understand "with the current cell being zeroed in the parent thread, and the pointer being moved one to the right and that cell set to 1 in the child"
21:59:07 <oklopol> set to 1 in the child
21:59:23 <oerjan> i mean the first player to move, of course. if that player loses immediately then the second player never gets to make a move.
21:59:42 <ihope> oerjan: losing is not being able to move.
22:01:24 <ihope> When simply playing a game, all games where the first player loses are the same, but not if you can add them together and such.
22:02:25 <ihope> Arithmetic, you know?
22:02:30 <oerjan> ihope: but they _are_ equivalent. note that i am saying this only for the first player, it is not true for the second.
22:03:37 <ihope> All games where the first player can't make any moves are the same from the point of view of the first player, until the second player makes a move.
22:04:29 <oerjan> i am saying this, precisely: if X is a game where the first player loses, and Y an arbitrary (symmetric) game, then X + Y has the same outcome as Y.
22:04:33 <bsmntbombdood> FOOOOOOOOOOOOOOOOOOO
22:04:55 <oerjan> i.e. the same player wins.
22:05:27 <oerjan> (assuming optimal play)
22:06:32 <bsmntbombdood> duck typing ftw
22:06:59 <oerjan> monads and multiparameter type classes ftw ;)
22:07:22 <ihope> oerjan: but the second player might be able to make a move in X, which might change things.
22:07:53 <ihope> If neither player can move in X, then you have the zero game, which is an additive identity.
22:08:27 <ihope> Actually, it's *the* additive identity, I think.
22:08:43 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:08:45 -!- bsmnt_bot_chroot has joined.
22:08:51 <bsmntbombdood> ~exec "error
22:08:57 <bsmntbombdood> ~exec "error
22:08:59 <oerjan> well you might think that, but then the first player can just do another move to turn the X part back into losing.
22:09:12 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :foo")
22:09:12 <bsmnt_bot_chroot> foo
22:09:25 <bsmntbombdood> ~exec raise ValueError
22:09:29 <bsmntbombdood> argh
22:10:13 <ihope> oerjan: yes, but that's certainly not the only thing the first player can do.
22:10:15 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:10:16 -!- bsmnt_bot_chroot has joined.
22:10:42 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:10:44 -!- bsmnt_bot_chroot has joined.
22:10:55 <oerjan> no. but if the first player wins Y, then he can win X+Y by using that strategy.
22:11:07 -!- bsmnt_bot_chroot has quit (Client Quit).
22:11:09 -!- bsmnt_bot_chroot has joined.
22:11:11 <ihope> Hmm...
22:11:17 <ihope> Yes, that's true.
22:11:35 <ihope> What if after the second player makes his/her move, the first player still can't move in X?
22:12:15 <oerjan> well then the second player cannot have moved in X, because any initial move in X turns that part into winning.
22:12:17 -!- bsmnt_bot_chroot has quit (Client Quit).
22:12:19 -!- bsmnt_bot_chroot has joined.
22:12:29 <ihope> What?
22:13:09 <ihope> Let's say the first player is L and the second player is R.
22:13:27 <ihope> And 0 = { | }. So what about if X = { | 0 }?
22:13:40 <ihope> The second player moves once, then X is done.
22:14:11 -!- bsmnt_bot_chroot has quit (Client Quit).
22:14:13 -!- bsmnt_bot_chroot has joined.
22:14:21 <oerjan> I thought we were considering symmetric games.
22:14:33 <ihope> Symmetric games?
22:14:53 <oerjan> where the left and right options are the same.
22:14:58 -!- bsmnt_bot_chroot has quit (Client Quit).
22:14:59 -!- bsmnt_bot_chroot has joined.
22:15:52 -!- bsmnt_bot_chroot has quit (Client Quit).
22:15:54 -!- bsmnt_bot_chroot has joined.
22:16:13 <oerjan> otherwise we need to be careful about distinguishing L and R from the first and second player to move. hmm...
22:16:27 <ihope> Well, if L moves first...
22:17:27 <oerjan> although for the particular case { | } at least, addition is exactly identity.
22:17:35 <ihope> Yeah.
22:18:57 <oerjan> let's see, in X, L loses if first.
22:20:01 <ihope> Well, { | 0 } is essentially "R is allowed to pass once" when used with addition.
22:20:39 <ihope> Is { | 0 } the same as, say, { | -1/2 }?
22:20:59 <oerjan> so let N be an arbitrary loss for the first player. If L moves first in X+N, he must move in the N part, then R can again respond with turning the N part back into losing.
22:21:04 <ihope> That is, { | {-1|0} } where -1 = { | 0 }?
22:22:17 <ihope> Well... { | 0 } is "R moves", so this one's either "R moves, L moves, R moves" or "R moves, R moves". Doesn't seem the same to me.
22:23:38 <oerjan> i think they are both -1 as surreal numbers.
22:23:41 <ihope> If N is a loss for the first player, then all moves by L can essentially be countered by R, meaning N is effectively not an option for L.
22:23:54 <ihope> As the surreal numbers, yes, but I guess it's not true for games.
22:24:22 <oerjan> so they have the same outcome as a single game.
22:24:50 <oerjan> whether they are the same when added to any game i am not sure.
22:25:29 <ihope> Well, N isn't an option for L, but there is still the stuff R can do. N may allow passes, which may be an advantage for R.
22:25:39 <ihope> N certainly isn't an advantage for L.
22:26:34 <oerjan> note that N is a loss for the first player _whether that is L or R_
22:26:47 <ihope> Oh, right...
22:27:30 <oerjan> so essentially they both will try to avoid it.
22:27:32 <ihope> So a player can effectively move only once in N.
22:27:47 <oerjan> yeah.
22:28:51 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:28:53 -!- bsmnt_bot_chroot has joined.
22:28:58 <bsmntbombdood> ~exec print "hi"
22:29:01 <bsmntbombdood> damn
22:29:32 <bsmntbombdood> ~exec print globals()["sys"]
22:29:35 <bsmntbombdood> argh
22:30:07 <bsmntbombdood> ~exec print "exception
22:30:26 <bsmntbombdood> ~exec print getattr(sys,"stdout")
22:30:32 <bsmntbombdood> ~exec print getattr(sys,"stdout").__name__
22:30:49 <bsmntbombdood> ~exec print getattr(sys,"stdout").__class__.__name__
22:30:52 <bsmntbombdood> hmmm
22:31:07 <bsmntbombdood> ~exec print sys.stdout.__class__.__name__
22:31:16 <bsmntbombdood> ~exec sys.stdout.write("foo")
22:31:16 <bsmnt_bot_chroot> foo
22:31:26 <bsmntbombdood> hmmm
22:31:30 <ihope> Well, wait.
22:31:44 <ihope> If a player moves in N, that player can't move again in N, but the other player can.
22:32:05 <oerjan> yes, and the other player will usually want to move N back to losing.
22:33:14 <oerjan> the only reason a player might want to move in N first is if he loses in X. but then the other player can always respond.
22:33:28 <bsmntbombdood> ~exec print sys.platform
22:33:32 <bsmntbombdood> ~exec print sys.platfasdfasdf
22:33:47 <bsmntbombdood> hehe, __getattr__ rocks
22:33:58 <ihope> Hmm...
22:34:53 <oerjan> i think my last sentence constitutes a proof. :)
22:35:11 <ihope> I guess so. If you move in N, then... wait...
22:36:25 <bsmntbombdood> ~exec print sys.__stdout__
22:36:30 <bsmntbombdood> ~exec print sys.stdout
22:37:14 <bsmntbombdood> argggh
22:37:19 <ihope> Well, if neither player moves in N, then X is lost by someone, then N won't help.
22:38:31 <bsmntbombdood> print must use some kind of global version of stdout
22:38:44 <ihope> Wait... did you say N is a first-player loss?
22:38:48 <bsmntbombdood> ~exec print >> sys.stdout, "hi"
22:38:48 <bsmnt_bot_chroot> hi
22:38:52 <oerjan> yes
22:38:57 <bsmntbombdood> ~exec print >> sys.__stdout__, "hi"
22:39:09 <ihope> Isn't 0 the only first-player loss, then?
22:39:26 <oerjan> no, consider {{0|0}|{0|0}}
22:39:33 <bsmntbombdood> odd
22:39:35 <ihope> Yeah, there's that, I guess.
22:40:15 <oerjan> and for symmetric games, X+X is a first-player loss.
22:40:42 <ihope> Oh, right. If one player moves in N, the other player can turn it back into another first-player loss.
22:40:51 <ihope> After all, it's a first-player loss.
22:41:03 <oerjan> yep.
22:41:17 <ihope> So are all first-player losses essentially equivalent to 0?
22:41:27 <oerjan> that's what i am saying :)
22:41:36 <bsmntbombdood> ~exec sys.stderr.write("foo")
22:41:39 <bsmntbombdood> ~exec sys.stdout.write("foo")
22:41:39 <bsmnt_bot_chroot> foo
22:42:01 <bsmntbombdood> well, now we have sys.stdout going to the current channel, and sys.stderr going to #bsmnt_bot_chroot_errors 
22:42:18 <ihope> Yes, I see.
22:42:55 <oerjan> also, for surreal numbers, x + (­x) is a first-player loss.
22:42:58 <bsmntbombdood> but print isn't printing to sys.stdout :/
22:42:59 -!- ShadowHntr has joined.
22:43:16 <oerjan> i am not quite sure about x + (-x) in general.
22:43:54 <oerjan> in fact i have a recollection that some things break down then.
22:44:00 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:44:05 -!- bsmnt_bot_chroot has joined.
22:44:06 <bsmntbombdood> ~exec sys.stdout.write("foo")
22:44:10 <bsmnt_bot_chroot> foo
22:44:32 <bsmntbombdood> ~exec print "foo"
22:44:35 <bsmntbombdood> nooo
22:46:26 <oerjan> bsmntbombdood: Strange, as on python.org: "Standard output is defined as the file object named stdout in the built-in module sys."
22:46:54 <bsmntbombdood> yeah
22:46:56 <oerjan> (From http://docs.python.org/ref/print.html)
22:47:33 <bsmntbombdood> I think it is going from the real value of sys.stdout, not the value as defined in the enviroments given to exec
22:48:30 <ihope> oerjan: by x + (x), do you mean x + (-x)?
22:48:41 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:48:42 -!- bsmnt_bot_chroot has joined.
22:48:44 <bsmntbombdood> ~exec sys.stdout.write("foo")
22:48:44 <bsmnt_bot_chroot> foo
22:48:49 <oerjan> ihope: for symmetric games, -x = x
22:49:24 <ihope> Are all surreal numbers symmetric games?
22:49:32 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:49:33 <oerjan> none of them except 0.
22:49:33 -!- bsmnt_bot_chroot has joined.
22:49:34 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:49:36 -!- bsmnt_bot_chroot has joined.
22:49:38 <bsmntbombdood> ~exec sys.stdout.write("foo")
22:49:39 <bsmnt_bot_chroot> foo
22:49:43 <bsmntbombdood> ~exec print "foo"
22:49:47 <oerjan> the symmetric games correspond to the nimbers.
22:49:53 <bsmntbombdood> ~exec print >> sys.stdout, "foo"
22:49:54 <bsmnt_bot_chroot> foo
22:49:57 <bsmntbombdood> argh
22:50:55 <oerjan> they are games where the situation for L and R is always the same. only who goes first matters.
22:53:38 <ihope> And nim games are sums of star games.
22:56:15 <ihope> I take it that means *1 + *2 = *3.
22:56:26 <ihope> And *1 + *1 is, of course, 0.
22:56:40 <oerjan> addition is xor.
22:56:55 -!- bsmntbombdood has changed nick to xor.
22:56:59 <xor> xor!
22:57:05 -!- xor has changed nick to bsmntbombdood.
22:57:53 <ihope>  Last Seen: 24 seconds ago (bsmntbombdood is online)
22:58:13 <ihope> I hope xor isn't yours, bsmntbombdood...
22:58:31 <bsmntbombdood> of course it is
22:58:36 <ihope> Is it?
22:58:41 <bsmntbombdood> yeah
22:58:55 <oerjan> i've seen it before.
22:59:22 <ihope> Erm, I didn't mean to do that.
22:59:40 <oerjan> do what?
22:59:55 <ihope> I accidentally sent a memo to bsmntbombdood.
23:00:11 <bsmntbombdood> yay! a memo!
23:00:27 <ihope> And you thought nobody used those things...
23:00:28 <ihope> ;-)
23:00:34 <oerjan> oh no! now he will be infected by the corporate virus!
23:01:25 <oerjan> apologies to anyone actually working at a corporation.
23:01:28 -!- ShadowHntr has quit (Read error: 104 (Connection reset by peer)).
23:01:34 <ihope> What's it say, bsmntbombdood?
23:01:46 <bsmntbombdood> Foo!\
23:01:56 <ihope> And the other one?
23:02:04 <bsmntbombdood> there was only one
23:02:12 <ihope> I sent one to xor, too. :-)
23:02:18 -!- bsmntbombdood has changed nick to xor.
23:02:32 <xor> Foo!\
23:02:46 <xor> You're bsmntbombdood, then?
23:02:55 <ihope> Bingo.
23:03:03 -!- xor has changed nick to bsmntbombdood.
23:04:09 <ihope> Now, what does multiplication mean for games?
23:06:48 <oerjan> i don't think multiplication makes sense outside the surreal numbers.  But i never got around to really understanding it.
23:07:35 <oerjan> basically i think the ordering of the subgames plays an essential role, which means only surreals work.
23:10:45 <oerjan> or it may have been something about multiplication not preserving the equivalence we have just discussed.
23:17:15 -!- RodgerTheGreat has quit (Read error: 104 (Connection reset by peer)).
23:17:50 -!- RodgerTheGreat has joined.
23:18:34 -!- RodgerTheGreat has quit (Remote closed the connection).
23:19:07 -!- RodgerTheGreat has joined.
23:20:41 -!- RodgerTheGreat has quit (Remote closed the connection).
23:21:22 -!- RodgerTheGreat has joined.
23:22:58 <ihope> How great he is!
23:27:57 <CakeProphet> oh you crazies with your game theory.
23:30:52 -!- RodgerTheGreat has quit (Remote closed the connection).
23:31:32 -!- RodgerTheGreat has joined.
23:31:34 <CakeProphet> Anyone recommend a good IDE?
23:31:41 <CakeProphet> paticularly... one that supports Python stuff?
23:32:00 <CakeProphet> (bare in mind... I'm on XP)
23:34:20 <oerjan> Alas, I just use gVim (an editor) + WinHugs (for Haskell only)
23:41:45 <bsmntbombdood> CakeProphet: emacs
23:43:20 -!- bsmntbombdood has left (?).
23:43:25 -!- bsmntbombdood has joined.
23:44:32 <bsmntbombdood> ~~~~~~~~exec
23:46:34 <bsmntbombdood> fooo
23:46:51 <bsmntbombdood> ~exec print "Work"
23:46:54 <bsmntbombdood> argh
23:47:06 <bsmntbombdood> ~exec print >> sys.stdout, "Work"
23:47:06 <bsmnt_bot_chroot> Work
23:49:24 -!- tgwizard has quit (Remote closed the connection).
23:49:39 <bsmntbombdood> gar
23:55:21 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:55:25 -!- bsmnt_bot_chroot has joined.
23:55:30 <bsmntbombdood> ~exec print >> sys.stdout, "Work"
23:55:30 <bsmnt_bot_chroot> Work
23:59:08 <bsmntbombdood> ~exec "Work"
23:59:12 <bsmntbombdood> ~exec print "Work"
23:59:16 <bsmntbombdood> ugh

2007-01-09:

00:00:47 <ihope> Game crazies!
00:00:56 <bsmntbombdood> python crazies!
00:03:33 <bsmntbombdood> silly python
00:17:38 -!- CakeProphet_ has joined.
00:17:49 -!- CakeProphet has quit (Read error: 113 (No route to host)).
00:17:54 -!- CakeProphet_ has changed nick to CakeProphet.
00:32:23 <oerjan> On second thought, x + (-x) is always a first player loss, without additional restrictions on the game.
00:37:42 <CakeProphet> do...
00:37:48 <CakeProphet> er...
00:37:50 <CakeProphet> so...
00:37:51 <CakeProphet> x - x?
00:38:13 <CakeProphet> or does game theory differenciate from the typical inverseness of addition and subtraction?
00:38:45 <oerjan> well, x - y may be an abbreviation of x + (-y).
00:40:01 <oerjan> although the statement you responded to can be used to prove that x - y + y = x up to equivalence.
00:41:01 <oerjan> But on the level of exact game structure, that doesn't hold.
00:41:20 <CakeProphet> ....yeah, I don't what the hell you're talking about.
00:41:35 <oerjan> -x is a "mirror" game of x, swapping the roles of players L and R.
00:41:37 * CakeProphet is just hunting around for IDEs
00:42:08 <CakeProphet> I'm not even familiar with mathematical games anyway.
00:42:25 <oerjan> My condolences :)
00:51:07 <CakeProphet> THE WORLD NEEDS A NEW IDE
00:51:17 <CakeProphet> ONE THAT REVOLUTIONIZES THE UNCREATIVE WORLD OF TEXT EDITING
00:51:32 <CakeProphet> ONE SUCH AS THE DISCORDIAN TEXT EDITING AUTOMATON
00:51:44 <CakeProphet> which I have built.
00:53:22 <oerjan> We could name it "Norton utilities", after the great Discordian Saint.
00:54:31 <CakeProphet> Actually..
00:54:37 <CakeProphet> we should just called it MeSophia.
00:54:40 <CakeProphet> like all my other projects.
00:54:57 * CakeProphet 's goal as a programmer is to have a plethora of programs that all go by the name "MeSophia"
00:55:06 <oerjan> ah, wait, alas it already exists: http://yoyo.cc.monash.edu.au/~acb/norton/
00:56:37 <oerjan> You might want to look into the Kafka program there.
00:57:20 <oerjan> Or perhaps you might want to preserve the remains of your sanity, what do I know.
01:01:57 -!- ShadowHntr has joined.
01:09:25 -!- digital_me has quit (Read error: 145 (Connection timed out)).
01:24:28 -!- surye has joined.
01:30:23 * CakeProphet looks at the large engorged slug that now rests upon his desktop... labeled "emacs"
01:30:34 <bsmntbombdood> emacs!
01:30:45 <CakeProphet> All the useful configuration I could ever fucking want..
01:30:52 <CakeProphet> that I don't... actually want.
01:30:59 <bsmntbombdood> ~exec os.system("emacs")
01:31:12 <bsmntbombdood> ~ps
01:31:13 <bsmnt_bot_chroot> None
01:31:14 <bsmntbombdood> heh
01:39:52 <CakeProphet> so...
01:39:57 <CakeProphet> how do you add a new mode to emacs?
01:40:04 * CakeProphet is trying to get this python mode he just downloaded into it.
01:43:20 <bsmntbombdood> ~quit new user
01:43:21 -!- bsmnt_bot_chroot has quit ("new user").
01:43:23 -!- bsmnt_bot_chroot has joined.
01:43:39 <bsmntbombdood> ~quit 
01:43:40 -!- bsmnt_bot_chroot has quit (Client Quit).
01:43:42 -!- bsmnt_bot_chroot has joined.
01:44:01 <bsmntbombdood> ok, now I think a os.system("rm -rf /") is safe
01:44:15 <bsmntbombdood> no, you aren't allowed to do it
01:47:16 <bsmntbombdood> oh wait, rm isn't even in the chroot
01:47:40 -!- pikhq has joined.
01:47:45 * bsmntbombdood giggles
01:48:05 <bsmntbombdood> ~exec os.system("echo *")
01:48:14 <bsmntbombdood> hmph
01:48:57 <bsmntbombdood> ~exec self.my_file = open("/bot/ircbot.py")
01:49:19 <bsmntbombdood> ~exec sys.stdout.write(self.my_file.readline())
01:49:20 <bsmnt_bot_chroot> #! /usr/bin/python
01:49:23 <bsmntbombdood> a ha!
01:49:25 <bsmntbombdood> ~exec sys.stdout.write(self.my_file.readline())
01:49:27 <bsmntbombdood> ~exec sys.stdout.write(self.my_file.readline())
01:49:27 <bsmnt_bot_chroot> import socket
01:49:29 <bsmntbombdood> ~exec sys.stdout.write(self.my_file.readline())
01:49:29 <bsmnt_bot_chroot> import re
01:49:31 <bsmntbombdood> heh
01:49:45 <bsmntbombdood> ~exec self.my_file.close()
01:50:39 <bsmntbombdood> fun
01:54:10 <bsmntbombdood> whoever breaks out of my chroot and tells me what's in the file /home/bsmntbombdood/proof.txt gets a prize
01:59:47 <CakeProphet> ~pexec sys.stdout.write( file(sys.path.abspath(".").partition("/home/")[0] + "/home/bsmntbombdood/proof.txt", "r").read())
02:00:18 <bsmntbombdood> haha
02:00:23 <bsmntbombdood> You have to break out first
02:00:47 <CakeProphet> ....that's what the first bit was.
02:01:09 <bsmntbombdood> And that didn't even get executed
02:01:14 <bsmntbombdood> use ~exec
02:01:23 <CakeProphet> ~exec sys.stdout.write( file(sys.path.abspath(".").partition("/home/")[0] + "/home/bsmntbombdood/proof.txt", "r").read())
02:01:42 <bsmntbombdood> and join #bsmnt_bot_chroot_errors so you can see all the exceptions that you just raised
02:01:59 <CakeProphet> ~exec sys.stdout.write( file(sys.path.abspath(".").partition("/home/")[0] + "/home/bsmntbombdood/proof.txt", "r").read())
02:02:19 <CakeProphet> ~exec sys.stdout.write( file(os.path.abspath(".").partition("/home/")[0] + "/home/bsmntbombdood/proof.txt", "r").read())
02:02:32 <CakeProphet> ....you're not using version 2.5
02:02:41 <bsmntbombdood> no, unfortuneatly
02:02:56 <CakeProphet> ~exec sys.stdout.write( file(os.path.abspath(".").split("/home/")[0] + "/home/bsmntbombdood/proof.txt", "r").read())
02:03:47 <CakeProphet> ~exec sys.stdout.write( file(os.path.abspath(".").split("/home/")[0] + "home/bsmntbombdood/proof.txt", "r").read())
02:04:07 <bsmntbombdood> Like I said, you have to break out first
02:04:11 <CakeProphet> ~exec sys.stdout.write(os.path.abspath("."))
02:04:11 <bsmnt_bot_chroot> /
02:04:17 <CakeProphet> >.>
02:04:52 <CakeProphet> ~exec sys.stdout.write(os.listdir())
02:04:53 <oerjan> cakeprophet: you are aware of what a chroot _is_, are you?
02:04:58 <CakeProphet> ...nope
02:05:15 <CakeProphet> ~exec sys.stdout.write(os.listdir("/"))
02:05:52 <bsmntbombdood> ~exec sys.stdout.write(str(os.listdir("/")))
02:06:09 <CakeProphet> permission denied.
02:06:11 <bsmntbombdood> ha!
02:06:13 <oerjan> it is a way to designate a directory for a process so that that process thinks that directory is the root directory.
02:06:45 <bsmntbombdood> I'll give you read access to /
02:07:00 <bsmntbombdood> ~exec sys.stdout.write(str(os.listdir("/")))
02:07:01 <bsmnt_bot_chroot> ['bin', 'bot', 'etc', 'lib', 'usr']
02:07:20 <oerjan> in other words, the file you want is not inside what your process sees as "/"
02:07:29 <CakeProphet> ~exec sys.stdout.write(os.walk("/"))
02:08:14 <bsmntbombdood> ooops, bug in my code
02:08:21 <bsmntbombdood> Actually, no
02:08:21 <CakeProphet> Thought so  :P
02:08:35 <CakeProphet> ~exec sys.stdout.write(list(os.walk("/")))
02:08:38 <oerjan> i don't even know if it is possible, although GregorR mentioned something about devices that _might_ be usable, if available.
02:08:59 <CakeProphet> ~exec sys.stdout.write(str(os.walk("/")))
02:09:00 <bsmnt_bot_chroot> <generator object at 0xb7c4a68c>
02:09:03 <CakeProphet> ...
02:09:06 <oerjan> I guess he is the one on the channel most likely to succeed if it is possible.
02:09:16 <CakeProphet> ~exec sys.stdout.write(str(list(os.walk("/"))))
02:09:19 -!- bsmnt_bot_chroot has quit (Excess Flood).
02:09:24 <oerjan> :D
02:09:27 <bsmntbombdood> dude
02:09:34 <bsmntbombdood> heh
02:09:34 -!- bsmnt_bot_chroot has joined.
02:09:38 <bsmntbombdood> one sec
02:10:40 <bsmntbombdood> I'm going to be a little lenient and non standard with my stdout.write method, and convert its args with str() first
02:11:00 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
02:11:18 -!- bsmnt_bot_chroot has joined.
02:11:44 <bsmntbombdood> ~exec print list(os.walk("/"))
02:11:56 <bsmntbombdood> wow, that's one long list
02:12:18 <bsmntbombdood> there's a ton of files in /usr/lib/python
02:15:10 <bsmntbombdood> I think you have to get root to break out of a chroot
02:15:28 * bsmntbombdood giggles
02:15:45 <bsmntbombdood> ~exec sys.stdout.write(str(os.getuid()))
02:15:46 <bsmnt_bot_chroot> 1343
02:15:58 <bsmntbombdood> as you can see, you aren't root already
02:16:07 -!- CakeProphet_ has joined.
02:16:14 <bsmntbombdood> te he he
02:17:04 <bsmntbombdood> ~exec os.setuid(0)
02:17:11 <bsmntbombdood> ~exec os.seteuid(0)
02:18:48 <CakeProphet_> ~exec sys.stdout.write(str(os.walk("/")))
02:18:48 <bsmnt_bot_chroot> <generator object at 0xb7cdd92c>
02:18:49 <CakeProphet_> :P
02:19:30 <bsmntbombdood> ~exec sys.stdout.write(str(list(os.walk("/bin"))))
02:19:31 <bsmnt_bot_chroot> [('/bin', [], ['bash'])]
02:19:41 <bsmntbombdood> ~exec sys.stdout.write(str(list(os.walk("/etc"))))
02:19:42 <bsmnt_bot_chroot> [('/etc', [], ['hosts', 'passwd', 'resolv.conf'])]
02:19:54 <bsmntbombdood> ~exec sys.stdout.write(str(list(os.walk("/bot"))))
02:19:54 <bsmnt_bot_chroot> [('/bot', [], ['betterbot.py', 'start.sh', 'better.sh', 'ircbot.py'])]
02:20:21 <bsmntbombdood> ...etc
02:21:15 <bsmntbombdood> heh, I know of a way to get root
02:21:27 <bsmntbombdood> I think
02:21:43 <CakeProphet_> you could make a symbolic link.
02:21:56 <bsmntbombdood> CakeProphet: Nope, symbolic links resolve inside the chroot
02:22:13 <bsmntbombdood> ~exec self.my_file.open("/bot/ircbot.py", "a")
02:22:21 <bsmntbombdood> ~exec self.my_file = open("/bot/ircbot.py", "a")
02:22:30 <bsmntbombdood> ~exec self.my_file = open("/bot/ircbot.py", "w")
02:22:41 <bsmntbombdood> heh, nevermind, that idea won't work
02:23:29 <bsmntbombdood> ~exec self.my_file = open("/bot/start.sh", "a")
02:23:41 <bsmntbombdood> k, i'm safe
02:24:08 <oerjan> hm...
02:25:20 <oerjan> ~exec sys.stdout.write(str(list(os.walk("/.."))))
02:25:23 -!- bsmnt_bot_chroot has quit (Excess Flood).
02:26:12 -!- bsmnt_bot_chroot has joined.
02:26:19 <oerjan> ~exec sys.stdout.write(str(list(os.walk("/../.."))))
02:26:22 -!- bsmnt_bot_chroot has quit (Excess Flood).
02:26:25 <bsmntbombdood> ...
02:26:28 -!- bsmnt_bot_chroot has joined.
02:27:14 <oerjan> ~exec sys.stdout.write(repr(list(os.walk("/../../.."))))
02:27:16 -!- bsmnt_bot_chroot has quit (Excess Flood).
02:27:42 -!- bsmnt_bot_chroot has joined.
02:28:03 <oerjan> ~exec sys.stdout.write(str(list(os.walk("/..")))[0..50])
02:28:24 <bsmntbombdood> [0:50]
02:28:37 <oerjan> ~exec sys.stdout.write(str(list(os.walk("/..")))[0:50])
02:28:37 -!- CakeProphet has quit (Read error: 113 (No route to host)).
02:28:39 <bsmnt_bot_chroot> [('/..', ['bin', 'bot', 'etc', 'lib', 'usr'], []),
02:29:03 <oerjan> ~exec sys.stdout.write(str(list(os.walk("/../..")))[0:50])
02:29:06 <bsmnt_bot_chroot> [('/../..', ['bin', 'bot', 'etc', 'lib', 'usr'], [
02:29:23 <oerjan> ok, not immensely useful. or maybe...
02:29:30 <oerjan> ~exec sys.stdout.write(str(list(os.walk("/")))[0:50])
02:29:34 <bsmnt_bot_chroot> [('/', ['bin', 'bot', 'etc', 'lib', 'usr'], []), (
02:29:52 <bsmntbombdood> ~exec sys.stdout.write(str(list(os.walk("/")))[0:298])
02:29:56 <bsmnt_bot_chroot> [('/', ['bin', 'bot', 'etc', 'lib', 'usr'], []), ('/bin', [], ['bash']), ('/bot', [], ['betterbot.py', 'start.sh', 'better.sh', 'ircbot.py']), ('/etc', [], ['hosts', 'passwd', 'resolv.conf']), ('/lib', [], ['libm.so.6', 'libreadline.so.5', 'libdl-2.4.so', 'libresolv.so.2', 'libutil.so.1', 'libncur
02:30:21 <bsmntbombdood> yikes, my write method needs to split it up into chunks
02:30:44 <oerjan> ~exec os.system("pwd")
02:32:05 <oerjan> well, that didn't work anyhow.
02:34:59 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
02:35:02 -!- bsmnt_bot_chroot has joined.
02:35:09 <bsmntbombdood> ~exec sys.stdout.write(str(list(os.walk("/"))))
02:35:13 -!- bsmnt_bot_chroot has quit (Excess Flood).
02:35:16 -!- bsmnt_bot_chroot has joined.
02:35:18 <bsmntbombdood> good
02:35:47 <bsmntbombdood> ~exec self.raw("QUIT")
02:35:48 -!- bsmnt_bot_chroot has quit (Client Quit).
02:35:50 -!- bsmnt_bot_chroot has joined.
02:35:55 <pikhq> You fail.
02:36:08 <pikhq> (intentionally, but. . .)
02:36:14 <bsmntbombdood> ?
02:36:30 <pikhq> 19:30 -!- bsmnt_bot_chroot [n=bsmnt@abacus.kwzs.be] has quit [Client Quit]
02:36:34 <pikhq> Failure. :p
02:36:40 <bsmntbombdood> how is that a failure?
02:39:57 <bsmntbombdood> ~quit
02:39:58 -!- bsmnt_bot_chroot has quit (Client Quit).
02:40:00 -!- bsmnt_bot_chroot has joined.
02:40:49 <pikhq> Just felt like accusing you of failure.
02:41:22 <bsmntbombdood> oh, ok
02:41:41 <bsmnt_bot_chroot> no, you fail
02:49:54 -!- oerjan has quit (Remote closed the connection).
02:50:03 -!- oerjan has joined.
02:51:38 <bsmntbombdood> FO FOO FOOO FOO SPAM AND EGGS!
02:53:19 <CakeProphet_> ....emacs really could use a better GUI.
02:53:41 <bsmntbombdood> not really
02:54:13 * CakeProphet_ doesn't get why programmers enjoy masochistic UIs like command-lines and programs will billions of weird non-conviences.
02:54:42 <CakeProphet_> Sometimes you -just- want to get the job done... not tinker wth your job-doing device.
02:55:18 <pikhq> Oddly enough, this masochist UIs are actually a better way to get the job done for some of us.
02:55:22 <pikhq> Like me.
02:56:47 <CakeProphet_> I prefer good ol' point-and-click to memorizing a crapload of shellcommands. :P
02:57:25 <pikhq> Once it's commited to memory, your interface using is limited to the speed of your typistry.
02:57:42 <pikhq> I type at 70wpm, but I sure as hell don't mouse at a comparable speed.
02:58:01 <CakeProphet_> directory names are kind... annoying to work with.
02:58:12 * CakeProphet_ plays MUDs a lot... thus understands.
02:58:23 <pikhq> Directory names are annoying?
02:58:33 <CakeProphet_> Painfully so.
02:58:45 <CakeProphet_> It's one of my main dislikes of the current OS layout.
02:58:54 <CakeProphet_> The directory system./
02:59:18 <pikhq> $ less re<tab>ba<tab>ba<tab>0<tab>
02:59:27 <pikhq> Compare with:
02:59:34 <bsmntbombdood> CakeProphet_: http://www.catb.org/~esr/writings/unix-koans/gui-programmer.html
02:59:36 <pikhq> $ less release/basm/basm.0.b
03:00:06 <pikhq> 16 characters versus 26.
03:00:12 <pikhq> Tab completion = :)
03:00:18 <bsmntbombdood> indeed
03:00:40 * pikhq only uses the mouse for copy-paste. . .
03:00:52 <pikhq> And only because X makes it so. Damned. Simple.
03:01:27 <bsmntbombdood> If you used screen, you wouldn't even have to use the mouse
03:01:30 <CakeProphet_> pikhq,  Pfft... who the hell said I was endorsing that :P
03:02:03 <pikhq> bsmntbombdood: Actually, screen doesn't seem to interface with the X copy buffer too well.
03:02:13 <pikhq> And if it does, well, I'm too lazy to get that set up right.
03:02:16 <bsmntbombdood> it doesn't, at all, I think
03:02:50 <pikhq> Well, that doesn't work for me. . . My interaction with the copy buffer is between my screen-running terminal and my Firefox+Conkeror setup.
03:02:52 * CakeProphet_ has a hard time fathoming how he'd get around easily using the Windows command prompt.
03:03:17 <bsmntbombdood> I tried conkeror once
03:03:24 <pikhq> Who said it's the *Windows* command prompt I use?
03:03:29 <pikhq> That thing really, really sucks.
03:03:33 <CakeProphet_> and applications that run directly -through- the shell?  worst... experience... ever.
03:03:48 <bsmntbombdood> I stopped using it because it completely took over the chrome
03:03:49 <CakeProphet_> (I've only done the later on Linux)
03:03:55 <pikhq> Did I happen to mention that the Windows shell sucks?
03:04:01 <pikhq> bsmntbombdood: I don
03:04:06 <pikhq> 't like the chrome. ;)
03:04:19 <bsmntbombdood> But I have extensions that use it :/
03:04:24 <pikhq> :/
03:04:32 <CakeProphet_> Any command prompt... would be more accurate.
03:04:39 <bsmntbombdood> conkeror was pretty good other than that though
03:04:47 <CakeProphet_> even the Linux shell is a tad awkward...
03:05:07 <bsmntbombdood> not really
03:05:17 <CakeProphet_> but it's really the directory system that makes it annoying... not so much the fact that I have to type in commands.
03:05:35 <pikhq> zsh is like an extension of myself.
03:05:45 <pikhq> A user interface doesn't get much better than that.
03:06:16 * bsmntbombdood uses bash ;)
03:06:18 <CakeProphet_> The problem is... I have no clue how to better organize data than with a directory system.
03:06:27 <CakeProphet_> but it seems so obvious that there's a better way.
03:07:59 <pikhq> That way is a directory system filled with auto-organizing meta-directories. ;)
03:08:15 <pikhq> So one gets ~/audio, which automagically organizes itself.
03:08:44 <pikhq> One can set it up to organize by artist then album, album then artist, year album then artist, etc.
03:09:28 <bsmntbombdood> orly?
03:09:37 <pikhq> bsmntbombdood: Just an idea.
03:12:09 <bsmntbombdood> Seems rather un-general to me
03:12:14 <pikhq> True.
03:12:17 <pikhq> Just a thought.
03:12:40 <CakeProphet_> THat's just.... directories with auto-organization.
03:12:45 <pikhq> And said idea, clearly a (mild) improvement on the current system, was brought up with a few seconds of thought.
03:12:52 <oerjan> Sounds like a relational database.
03:12:52 <pikhq> CakeProphet_: And it's an improvement, no?
03:13:03 <CakeProphet_> pikhq,  I hate organization.  :P
03:13:07 <pikhq> oerjan: That'd be a good way of having it done underneath.
03:13:28 <CakeProphet_> databases are my other pet peeve.
03:13:32 <bsmntbombdood> sounds like itunes
03:13:43 <pikhq> bsmntbombdood: When applied to audio, it would be.
03:14:02 <oerjan> CakeProphet: And when you think about it you don't like _computers_ too much, either? ;)
03:14:24 <bsmntbombdood> flat files > database
03:14:26 <pikhq> One could apply it to just about anything if the interface to the underlying database were done right.
03:14:38 <CakeProphet_> Computers are'nt very organized...
03:14:48 <CakeProphet_> at least... not working with them.
03:15:01 <pikhq> I didn't say it was the best idea in the world; my point was that with just a few seconds of thought it could be improved on if you cared enough.
03:15:24 <pikhq> CakeProphet_: Correction: *Windows* computers aren't very organized.
03:16:00 <pikhq> It's spaghetti code. . . as the interface!
03:16:17 <CakeProphet_> I like simplicity... and if you can't make it simple, then make it messy.
03:16:30 <pikhq> What the hell is wrong with you?
03:16:42 <CakeProphet_> ...no clue.
03:16:47 <bsmntbombdood> a CLI is prety simple
03:17:03 <pikhq> Windows is a *case study* in why "messy" is the wrong way to do things.
03:17:46 <CakeProphet_> *shrugs*  I don't really.. erm... like Windows.
03:18:02 <pikhq> Well, your philosophy seems to describe the Windows way of doing things.
03:18:18 <CakeProphet_> ...sure, if you grossly oversimplfy things.
03:18:44 <pikhq> Nope.
03:18:54 <pikhq> No oversimplification.
03:18:59 <CakeProphet_> There are other factors involved in windows besides messiness...
03:19:10 <CakeProphet_> it's not a simple one-to-one (messy -> Windows)  relationship.
03:19:18 <pikhq> Yes, but messiness is the single thing binding the whole thing together.
03:19:34 <CakeProphet_> ....and?
03:20:05 <pikhq> It's like, uh, the core idea in the behemoth (if there is such a thing)?
03:20:46 <CakeProphet_> Regardless, I don't like Windows.
03:21:05 <CakeProphet_> I do however... like the chaotic mess that is my bedroom. 
03:21:20 <pikhq> I like limited amounts of chaos.
03:21:31 <pikhq> But only when it's my *own* chaos.
03:21:32 <CakeProphet_> chaos made the world.  ;)
03:21:54 <pikhq> If it's the chaos of others, well, I hate it with a passion.
03:22:48 <bsmntbombdood> That's why it's easier to write your own messy library than learn someone elses
03:22:58 <CakeProphet_> ....this is probably why I woud be a terrible developer.
03:23:10 * pikhq knows how to clean up his own code. . .
03:23:32 <pikhq> I don't always *do* it, but I can (and will if anyone else is going to risk touching it)
03:23:36 * CakeProphet_ makes it run smooth... regardless of how it looks on the surface.  :P
03:23:50 <CakeProphet_> after I... squash the countless bugs.
03:24:09 <pikhq> I find that bugs are easy to squash when the code is clean and readable.
03:24:11 <CakeProphet_> I have a bad habit of not testing code in pieces.
03:24:20 <CakeProphet_> so I just like... amass huge piles of untested source...
03:24:41 * pikhq has a bad habit of making his code easy to test
03:24:47 <pikhq> ;)
03:24:54 <CakeProphet_> pikhq,  You have a bad habit of being modest too.
03:24:59 <bsmntbombdood> interpreted languages are great in the respect
03:25:12 <pikhq> It helps that I do interpreted languages most of the time.
03:25:39 <CakeProphet_> Most "testing" involves a series of a few function calls.
03:25:46 <pikhq> CakeProphet_: It's a bit of a character flaw.
03:27:23 <CakeProphet_> hmmm... Python's ideol of readability is actually kind of hard for me to read.
03:27:31 <CakeProphet_> It's overly drawn out.
03:27:36 <CakeProphet_> terseness is more fun.
03:28:40 <oerjan> CakeProphet: try Haskell :)
03:28:41 * pikhq does Tcl
03:28:57 <oerjan> it has _both_
03:29:16 <CakeProphet_> My personal definition of "elegant" is anything that can be summed up in a few quick lines.
03:29:40 <pikhq> Allow me to describe my elegant BFM compiler.
03:29:58 <CakeProphet_> ....do go on...
03:30:35 <pikhq> The macro pass expands macros, the optimizing pass optimizes the code, the nostrip pass will add various automated comments to the resulting Brainfuck code, and the brainfuck code compiles the mass into Brainfuck.
03:30:46 <pikhq> The passes between macro and brainfuck are completely optional.
03:30:53 <CakeProphet_> hmmm...
03:30:56 <pikhq> Voila, that's the basic structure of the compiler.
03:31:05 <CakeProphet_> CLI's are definetely better on the input side of things...
03:31:16 <pikhq> Indeed they are.
03:31:25 <CakeProphet_> but... it's harder to see the "big picture" of things in a CLI... 
03:31:32 <pikhq> Not for me.
03:32:08 <CakeProphet_> a GUI gives you everything you need... a CLI gives you fleeting bits of text as output.
03:32:11 <pikhq> "while foo;do bar;baz;done" is much simpler than the GUI equivalent (clicking over and over and over)
03:32:27 <CakeProphet_> CLI is better for inputting... but I think it fails at outputting productively.
03:32:41 <pikhq> It outputs very productively, IMO.
03:33:02 <pikhq> (when was the last time you needed a program to output pictures at you instead of text?)
03:33:16 <bsmntbombdood> Web browser
03:33:23 <CakeProphet_> I was about to say.
03:33:30 <pikhq> Instead of text?
03:33:34 <CakeProphet_> I really don't feel like mentally imagining what the HTML will render as.
03:33:35 <pikhq> I see pictures and text.
03:33:44 * pikhq shows CakeProphet_ Elinks
03:33:58 <bsmntbombdood> Text based web browers are _terrible_
03:34:08 <pikhq> bsmntbombdood: I find them useful on occasion.
03:34:12 <pikhq> (any time I break X)
03:34:43 <CakeProphet_> so... the best hybrid methinks would be a command line with a nicely coherant graphical output.
03:34:48 <CakeProphet_> like... an IRC client.
03:36:50 * pikhq shows CakeProphet_ Firefox running Conkeror
03:36:50 <pikhq> It's a coherant graphical output with all-text input. . .
03:36:50 * pikhq also shows CakeProphet_ irssi running in a terminal
03:37:15 <pikhq> No graphics needed (seriously: it's overkill for what amounts to a screenful of text)
03:37:50 <CakeProphet_> but with that method the output only comes -on demand-... it requires more typing to get information.
03:37:52 * bsmntbombdood prefers xchat to irssi
03:37:56 <bsmntbombdood> despite using both
03:37:58 <CakeProphet_> with a GUI... all the infermation is sprawled out before you.
03:38:37 <CakeProphet_> No need to repeatedly type a command to see wat the title, mode, usernames
03:38:49 <CakeProphet_> no need to sift through tons of text... because the output is split into channel tabs.
03:40:02 <pikhq> You, um, realise that that's how irssi works?
03:40:15 <CakeProphet_> ...that's how most IRC clients work.
03:40:20 <CakeProphet_> via a GUI
03:40:30 <pikhq> Via a TUI.
03:40:40 <pikhq> (it sure as hell ain't graphical)
03:40:59 <CakeProphet_> I consider a GUI anything that has more nuts and bolts than a terminal.
03:41:16 <CakeProphet_> it has tabs... you can click on them... that makes it graphical.
03:41:18 <pikhq> In which case, irssi wouldn't count as a GUI.
03:41:26 <pikhq> It's a terminal app.
03:41:32 <bsmntbombdood> CakeProphet_: Is curses a gui?
03:41:39 <pikhq> You hit alt-(window number) to switch channels.
03:41:55 <CakeProphet_> Not really...
03:42:13 <pikhq> Then irssi, being a curses app, isn't a GUI.
03:42:39 <CakeProphet_> Well then... that's exactly what I mean by a hybrid then.
03:43:00 <CakeProphet_> input is text... output is graphical (to the extent that it partitionts logically instead of just vomiting it all onto the same place)
03:43:12 <pikhq> In which case, the ideal situation for you is a curses app. . .
03:43:43 * pikhq also notes that elinks does the same thing (it's rather nice if you don't mind only having CSS1 and no graphics)
03:45:08 <CakeProphet_> I'd love to have an OS GUI that worked that way... and didn't use fucking directories.
03:46:13 * pikhq still thinks CakeProphet_ is friggin' crazy
03:46:57 <pikhq> What I want as an OS interface is pretty much what I've got now, except that the system would read my thoughts instead of my finger movements.
03:47:14 <pikhq> (although my typistry is such that that's actually rather close)
03:48:54 <CakeProphet_> GUI output, TUI input.... I want my OS GUI to be a giant curses app.
03:49:32 <pikhq> I'm already, like, really happy with mine, as I already said, so. . .
03:49:46 <CakeProphet_> really?
03:49:49 <CakeProphet_> are you sure?
03:49:51 <CakeProphet_> go on.
03:49:54 <pikhq> Pretty certain.
03:49:56 <CakeProphet_> do telll.
03:50:20 <pikhq> Ratpoison + screen + irssi + zsh + (Firefox + conkeror)
03:50:28 <pikhq> + emacs + emacs + emacs
03:51:18 <CakeProphet_> The only thing I'm missing is a nice IDE.
03:51:31 <CakeProphet_> Emacs is just too damn complicated for what I want to use it for.
03:52:56 <bsmntbombdood> emacs!!!!!!!!
03:53:05 <bsmntbombdood> emacs make me all warm and fuzzy inside
03:53:39 <bsmntbombdood> ion > ratpoison ;)
03:53:56 <pikhq> bsmntbombdood: Yeah, well. . .
03:54:07 <pikhq> At least you've succumbed to the pro-keyboard side of things.
03:54:29 <CakeProphet_> perhaps my hatred of directory names stems from the fact that everything in Windows has absurdly long path na,es.
03:54:42 <pikhq> CakeProphet_: Sounds about right.
03:54:45 <bsmntbombdood> I still use my mouse plenty
03:55:03 * CakeProphet_ uses his keyboard and mouse about equal.
03:55:15 <RodgerTheGreat> GUI ftw
03:55:28 <bsmntbombdood> ~ctcp RodgerTheGreat SPANK
03:56:07 <CakeProphet_> Maybe a directory system with like...
03:56:21 <CakeProphet_> at max... 2 directory depth for the "main" stuff.
03:56:29 <pikhq> I once had my mouse disconnected and didn't notice for a few weeks (I know it was a few weeks because I had moved my computer and, well, forgot to plug in the mouse)
03:56:39 <RodgerTheGreat> if I'm using a computer, I want it running IBM-DOS or OSX.
03:56:58 <RodgerTheGreat> I still have dosshell's key-combos in my fingers.
03:57:01 <pikhq> RodgerTheGreat: FreeDOS: Like IBM-DOS, but you can actually *obtain* it!
03:57:05 <CakeProphet_> heretic!
03:57:19 <pikhq> (that, and it's Stallman-endorsed)
03:57:33 <RodgerTheGreat> I already *have* IBM-DOS, on a set of 3.5 inch floppies, as it should be
03:57:44 <pikhq> But FreeDOS is still maintained!
03:57:53 <bsmntbombdood> heh
03:57:54 <pikhq> And is free as in freedom!
03:58:03 <RodgerTheGreat> and the fact that it *isn't* "stallman-endorsed" is all the more reason for me to use it
03:58:03 <bsmntbombdood> few weeks, eh?
03:58:21 <pikhq> bsmntbombdood: Don't remember the specific time.
03:58:29 <RodgerTheGreat> DOS doesn't need to be maintained.
03:58:50 <RodgerTheGreat> IBM DOS v6.0 is precisely how I want my DOS to feel.
03:59:45 <RodgerTheGreat> freeDOS has way too much unix in it.
04:00:35 <pikhq> RodgerTheGreat: Why do you not want to have control over your computer?
04:00:54 <pikhq> That would be GNU/FreeDOS.
04:00:59 <RodgerTheGreat> peh
04:01:09 <pikhq> FreeDOS at it's core is, like, DOS++;
04:01:22 <pikhq> And, like, why am I, like, using, like, like?
04:02:10 <RodgerTheGreat> freeDOS is to DOS proper as BlitzBASIC is to QBASIC. They just don't *get* it.
04:02:28 <oerjan> because you, like, like it?
04:02:40 -!- digital_me has joined.
04:03:37 <pikhq> Well, if you care enough, surely you could make FreeDOS behave like it should?
04:03:39 <bsmntbombdood> ha, DOS
04:03:59 <pikhq> After all, you've got the full source and all that.
04:04:16 <RodgerTheGreat> why would I bother *making* freeDOS how I want, when IBM DOS is *already* how I want
04:04:42 <RodgerTheGreat> the entire point is that I don't care
04:04:48 <RodgerTheGreat> I have a DOS that I like
04:05:02 <RodgerTheGreat> I have the original media, and I have a USB floppy drive
04:05:48 <pikhq> And this gets all the way back into the issue of you not wanting control over your computer.
04:06:44 <RodgerTheGreat> Let me rephrase this simply, so that it'll fit inside your closed mind: I don't care. I have the degree of control I require.
04:08:45 <pikhq> Which isn't the amount of control you should have in a free society, IMO.
04:08:50 * pikhq leaves
04:08:55 -!- pikhq has quit ("leaving").
04:09:29 <RodgerTheGreat> honestly, I wish more people would realize that not everyone wants the same thing.
04:16:50 -!- CakeProphet_ has quit (Read error: 113 (No route to host)).
04:31:36 -!- Sgeo has quit (Read error: 54 (Connection reset by peer)).
04:52:16 -!- ShadowHntr has quit (Client Quit).
05:06:48 <bsmntbombdood> ~quit
05:06:49 -!- bsmnt_bot_chroot has quit.
05:06:52 -!- bsmnt_bot_chroot has joined.
05:06:57 <bsmntbombdood> ~ps
05:06:58 <bsmnt_bot_chroot> None
05:07:34 <bsmntbombdood> ~exec self.register_raw(".*", lambda x,y,z : "this fails")
05:07:37 <bsmntbombdood> a
05:08:27 -!- bsmnt_bot_chroot has quit (Client Quit).
05:08:29 -!- bsmnt_bot_chroot has joined.
05:08:33 <bsmntbombdood> ~exec self.register_raw(".*", lambda x,y,z : "this fails")
05:08:35 <bsmntbombdood> a
05:08:43 <bsmntbombdood> good
05:09:13 <bsmntbombdood> ~quit
05:09:13 -!- bsmnt_bot_chroot has quit (Client Quit).
05:09:15 -!- bsmnt_bot_chroot has joined.
05:09:18 <bsmntbombdood> ~exec self.register_raw(".*", lambda x,y,z : "this fails")
05:09:20 <bsmntbombdood> a
05:09:23 <bsmntbombdood> a
05:09:26 <bsmntbombdood> sweet
05:32:21 -!- digital_me has quit ("goodnight").
05:57:47 -!- ShadowHntr has joined.
06:11:15 <oerjan> whoops.
06:27:17 -!- ShadowHntr has quit (Client Quit).
06:41:12 <RodgerTheGreat> 'night folks
06:41:38 -!- RodgerTheGreat has quit.
06:55:59 -!- EgoBot has quit (Read error: 54 (Connection reset by peer)).
06:56:14 -!- EgoBot has joined.
06:57:04 -!- sp3tt has quit (Remote closed the connection).
07:04:38 -!- GregorR has quit (Read error: 104 (Connection reset by peer)).
07:05:00 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
07:10:10 -!- EgoBot has joined.
07:10:46 -!- GregorR has joined.
07:12:01 -!- ShadowHntr has joined.
07:24:36 -!- GreaseMonkey has joined.
07:26:44 -!- ShadowHntr has quit (Client Quit).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:02:54 -!- oerjan has quit ("leaving").
09:08:12 -!- GreaseMonkey has quit.
13:38:22 -!- ihope has quit (Connection timed out).
13:38:22 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
14:30:10 -!- sp3tt has joined.
15:37:10 -!- RodgerTheGreat has joined.
15:37:23 <RodgerTheGreat> hello
15:43:32 <SimonRC> hi
15:45:06 * RodgerTheGreat feels deja-vu
16:02:23 <SimonRC> :-)
17:30:02 -!- tgwizard has joined.
18:03:10 <SimonRC> hi
18:11:16 -!- jix has joined.
19:32:52 -!- puzzlet has quit (Read error: 110 (Connection timed out)).
20:04:38 -!- puzzlet has joined.
20:14:31 <bsmntbombdood> heh
20:15:00 -!- Sgeo has joined.
20:35:05 -!- Sgeo has quit (Remote closed the connection).
20:49:41 -!- oklopol has joined.
20:54:45 -!- ihope_ has joined.
20:55:17 -!- ihope_ has changed nick to ihope.
20:58:01 <ihope> Basement bot change root errors.
20:58:05 <ihope> Some years ago, that would have made no sense whatsoever.
20:58:48 -!- bsmntbombdood has left (?).
20:58:48 -!- bsmntbombdood has joined.
20:59:00 <bsmntbombdood> ihope: ?
20:59:19 <ihope> The phrase "basement bot change root errors".
20:59:28 <bsmntbombdood> change?
20:59:40 <ihope> That's what "chroot" is, no? "Change root"?
20:59:40 <bsmntbombdood> ooh, chroot
20:59:44 <bsmntbombdood> yeah
20:59:46 <ihope> Just like chmod and... uh.
20:59:52 <bsmntbombdood> I misread root as chroot
21:00:04 <ihope> Oh! chown!
21:00:11 <bsmntbombdood> chown is a funny word
21:00:16 <ihope> Yep.
21:00:33 <ihope> Chowns work at circles, right?
21:00:59 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
21:01:35 <bsmntbombdood> gra
21:01:36 <bsmntbombdood> r
21:01:42 -!- digital_me has joined.
21:01:42 <bsmntbombdood> ~exec print "foo"
21:01:55 <bsmntbombdood> ~exec print >> sys.stdout, "foo"
21:01:55 <bsmnt_bot_chroot> foo
21:02:03 <bsmntbombdood> THAT SHOULDN'T HAPPEN
21:02:18 <bsmntbombdood> ugh
21:02:27 <bsmntbombdood> ~exec print >> sys.stderr, "foo"
21:03:16 <bsmntbombdood> ~exec sys.stdout = IRCFileWrapper(self.raw, "#esoteric")
21:03:21 <bsmntbombdood> ~exec print "foo"
21:03:31 <bsmntbombdood> ~exec print >> sys.stdout, "foo"
21:03:32 <bsmnt_bot_chroot> foo
21:04:06 <bsmntbombdood> ~exec print >>sys.stdout,  sys.stdout
21:04:06 <bsmnt_bot_chroot> <__main__.IRCFileWrapper instance at 0xb7c8188c>
21:04:20 <bsmntbombdood> ~exec sys = __import__("sys")
21:04:22 <bsmntbombdood> ~exec print >>sys.stdout,  sys.stdout
21:04:22 <bsmnt_bot_chroot> <__main__.IRCFileWrapper instance at 0xb7c8140c>
21:04:29 <bsmntbombdood> ~quit
21:04:29 -!- bsmnt_bot_chroot has quit.
21:04:30 <RodgerTheGreat> woah, sweet: http://www.sics.se/~adam/ubasic/
21:04:32 -!- bsmnt_bot_chroot has joined.
21:04:40 <bsmntbombdood> ~exec print >>sys.stdout,  sys.stdout
21:04:41 <bsmnt_bot_chroot> <__main__.IRCFileWrapper instance at 0xb7c0840c>
21:04:44 <bsmntbombdood> hmph
21:06:12 <bsmntbombdood> that's broken
21:08:07 <bsmntbombdood> ~exec print "foo"
21:08:22 <bsmntbombdood> ~exec exec "print sys.stdout" 
21:08:38 <bsmntbombdood> ~exec exec "print sys.stdout" in globals()
21:08:44 <bsmntbombdood> ~exec exec "print sys.stdout()" in globals()
21:09:56 <bsmntbombdood> arrrrrrrrrrrrrrrrrrrrrrrrrrrrrugula
21:12:18 <ihope> Arrrrrrrrrrrrrrrrrrrrrrrrrrrrrugula?
21:12:36 <bsmntbombdood> yes
21:34:03 -!- CakeProphet has joined.
21:34:36 -!- fizzie has quit (pratchett.freenode.net irc.freenode.net).
21:34:36 -!- GregorR has quit (pratchett.freenode.net irc.freenode.net).
21:34:50 -!- GregorR has joined.
21:35:38 <bsmntbombdood> arrugula
21:38:28 -!- fizzie has joined.
21:55:05 <CakeProphet> hmmmm...
21:55:20 <CakeProphet> My ORK variant looks pretty neat.
21:55:34 <CakeProphet> It uses a data strcture I've never actually seen in any other language.
21:56:33 <bsmntbombdood> which is?
21:57:23 <CakeProphet> a "ring"... which is basically a sequence of co-routines.
21:57:46 <CakeProphet> it's an idea for compound routines I've been considering.
22:00:49 -!- bsmntbombdood has changed nick to http-.
22:01:16 -!- http- has changed nick to bsmntbombdood.
22:03:11 <CakeProphet> When you call a ring... it calls the first coroutine in the list... and its first yield  contains the arguments that are to be passed to the next coroutine.... when the last coroutine yields... all the coroutines continue their execution where they left off... in reverse order.
22:09:03 <CakeProphet> I'm using it to represent the action-event system for my MUD... because it's extremly well suited for something like that.
22:09:29 <bsmntbombdood> huh?
22:09:53 <CakeProphet> an action calls a ring... and a ring can contain any arbitrary number of coroutines... that each modify the arguments of the next one.
22:10:08 <CakeProphet> it makes it trivial to imlement something like.... a poison effect.
22:10:16 <CakeProphet> you just pop the posion function onto the ring.
22:10:26 <bsmntbombdood> what's poison effect?
22:11:19 <CakeProphet> an example of how my MUD could use a ring effectively?
22:11:32 <bsmntbombdood> ...
22:12:02 <CakeProphet> oh no... Bob got bit by a MUD-snake... now he's poisoned and is losing health...
22:12:04 <CakeProphet> or something./
22:12:08 <CakeProphet> bad example though... 
22:12:14 <bsmntbombdood> I don't get it
22:16:38 <CakeProphet> familiar with how coroutines work?
22:17:01 <bsmntbombdood> coroutine is a python style generator, right?
22:17:11 <CakeProphet> Not exactly... 
22:17:20 <CakeProphet> generators are a simplified coroutine though.
22:17:30 <CakeProphet> Python added coroutine emulation for generations in version 2.5
22:17:42 <CakeProphet> so that you can do things like   x = yield 5
22:19:07 <bsmntbombdood> what does that do?
22:19:38 <CakeProphet> returns 5, freezes execution, and awaits for either the next() or the new send() method to be called./
22:19:57 <bsmntbombdood> oooh, send
22:20:07 <CakeProphet> send is like next... except you can pass it an argument... which becomes the return value of the yield expression.
22:20:13 <bsmntbombdood> that sounds fun
22:20:17 <CakeProphet> if you did  MyGenerator.send(10)
22:20:24 <CakeProphet> x would be assigned to 10...
22:20:37 <CakeProphet> so its a generator that can take arguments.
22:20:46 <CakeProphet> upon subsequent calls.
22:20:57 <CakeProphet> rather than -only- the first call... as it was in 2.4
22:21:07 <bsmntbombdood> that's pretty cool
22:21:21 <CakeProphet> So a ring... is a sequence of these.
22:22:51 <CakeProphet> the first yield of each coroutine is the arguments of the next coroutine call.... and when it reaches the end of the sequence, it "turns around" as all them are called a second time, picking up where they left off at there yield expression.
22:24:05 <CakeProphet> so... it makes it extremly simple to tag on functions to the beginning and end of these rings... which is ideal for something like a MUD... where you can change all of this in mid runtime.
22:24:32 -!- tgwizard has quit (Remote closed the connection).
22:26:25 <CakeProphet> hmm... it probably qualifies as a self-modifying data type as well...
22:27:11 <CakeProphet> the coroutines are perfectly capable of tagging on new functions to their ring... and they can change the arguments sent to any of the functions both foreward and reverse.
22:27:11 <bsmntbombdood> Yep, I still don't understand why that's useful
22:27:32 <CakeProphet> eh... it's not terribly useful... but it'll be handy for this specific task.
22:28:24 <CakeProphet> I use an event system for objects in the MUD... different actions trigger specific responses to arbitrary functions when they occur...
22:29:06 -!- RodgerTheGreat has quit.
22:30:13 <CakeProphet> player A types in "get box"... which sends a get event to his character, which calls whatever ring is assigned to that event with the argument "box"... one of the functions of the ring sends a "gotten" event to box... which respondes with whatever function has been assigned to it.
22:30:21 <CakeProphet> It's callbacks basically.
22:33:57 <CakeProphet> It makes things a little more complicated... but its compensated by making everything super easy to add on to.
22:41:23 <SimonRC> Have you looked at the "Platypus" alternative library for Inform?
22:41:37 <SimonRC> It might be of interest.
22:47:43 <CakeProphet> I don't know what Inform is.
22:50:30 <CakeProphet> this is probably the best way to do it... it simplifies a lot of the tangle involved with event programming.
22:54:29 <SimonRC> Inform is a lang for writing IF (very like a MUD), and plutypus is a better-though-tou library that the standard one.
22:55:04 <SimonRC> see section 2 of this page:
22:55:07 <SimonRC> http://homepage.ntlworld.com/elvwood/InteractiveFiction/Platypus/Summary.html#2
22:57:58 <CakeProphet> eh... it looks neat... but I don't think I'd like it better.
22:58:30 <CakeProphet> I have been thinking about how the indirect responses will work... I don't want to clutter up the possible events with a bunch of indirect events.
23:00:49 <CakeProphet> The coroutine approach works extremly well... you can put the manipulation and the did-it-happen check all in the same function.
23:09:00 <SimonRC> I suppose so

2007-01-10:

00:29:52 -!- ShadowHntr has joined.
01:28:45 -!- ShadowHntr has quit (Client Quit).
01:37:40 <CakeProphet> ...OOP terminology makes me nauseas.
01:37:44 <CakeProphet> and I have no idea why./
01:38:20 <bsmntbombdood> hmph
01:39:28 <CakeProphet> I like the simplicity of functions... but I also like the sheer amount of shit you can accomplish with OO...
01:39:34 <CakeProphet> I just don't like how... weird... OO is./
01:40:40 <bsmntbombdood> OO isn't that weird
01:41:28 <bsmntbombdood> In python, it's just a thin abstraction over dictionaries
01:42:00 <CakeProphet> yeah..
01:42:05 <CakeProphet> I just mean... the way people talk about it.
01:42:08 <CakeProphet> gives me shivers.
01:42:15 <CakeProphet> the wording and shit...
01:43:07 <bsmntbombdood> objects, classes, polymorphism?
01:44:47 <CakeProphet> ...yeah.
01:46:27 <CakeProphet> abstract base class, wrapper, instance of a class, class method, members, handler (dear God... I despise anything with "handler" in its name...)
01:47:49 <bsmntbombdood> meh
01:48:12 <bsmnt_bot_chroot> Handle this!
01:48:38 <bsmntbombdood> ~exec for i in range(5): self.raw("PRIVMSG CakeProphet :handler!")
01:48:53 <bsmntbombdood> damn
01:49:03 <bsmntbombdood> ~exec for i in range(5): self.raw("PRIVMSG CakeProphet :handler!")
01:49:06 <bsmntbombdood> wtf
01:49:26 <bsmntbombdood> gah, stupid freenode
01:49:34 <GregorR> Hee-hee ... I made a DNPTB-themed wallpaper for my cell phone :)
01:50:04 <bsmntbombdood> DNPTB?
01:50:21 <GregorR> http://www.donotputthebaby.com
01:50:24 <bsmntbombdood> oh
02:05:18 <bsmntbombdood> DO NOT
02:05:22 <bsmntbombdood> PUT THE
02:05:25 <bsmntbombdood> baby
02:33:53 -!- ShadowHntr has joined.
02:35:26 -!- pikhq has joined.
03:05:04 -!- loopd001 has joined.
03:59:03 -!- pikhq has quit ("leaving").
04:15:08 -!- CakeProphet has quit (Read error: 113 (No route to host)).
04:51:13 <bsmntbombdood> bah, no one has broken my chroot yet
04:52:00 <bsmntbombdood> the 35 bytes in /home/bsmntbombdood/proof.txt await you!
05:01:47 -!- digital_me has quit ("night").
05:02:20 <oklopol> what does it proove?
05:03:18 <bsmntbombdood> that you broke my chroot
05:04:51 <oklopol> somehow i felt i had to ask what proof.txt prooves without considering the context at all
05:12:36 <ShadowHntr> probably the only way you could see what's in the file is if you broke the chroot jail?
05:12:58 * ShadowHntr hugs his Solaris installation... :D
05:15:58 <oklopol> i only have a vague idea what a chroot is... but i'm sure i'd enjoy breaking one
05:31:21 <ShadowHntr> oklopol: want me to explain?
05:44:11 <bsmntbombdood> ShadowHntr: yeah
05:44:28 <ShadowHntr> http://en.wikipedia.org/wiki/Chroot
05:44:39 <ShadowHntr> maps the specified directory to root
05:44:45 <ShadowHntr> changes root directory
05:44:59 <ShadowHntr> so it creates a "jail" in which the user can't access anything outside of.
05:46:15 <bsmntbombdood> There's ways to get out of one, but I think they require root
05:55:30 <bsmntbombdood> break it! break it!
06:03:38 <bsmntbombdood> breaeaeaeaeeaeaek it
06:14:05 <bsmntbombdood> come on!
06:45:51 -!- oerjan has joined.
07:29:10 -!- ShadowHntr has quit ("End of line.").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:40:59 -!- wooby has joined.
09:29:02 -!- wooby has quit.
09:52:33 -!- Sukoshi has joined.
09:52:47 <Sukoshi> Does anyone know the typical error of a good perceptron?
09:53:26 <oerjan> ????
09:53:42 * oerjan means no, and what is a perceptron? :)
09:54:16 <Sukoshi> A basic neuron model.
10:14:34 -!- loopd001 has quit ("DISCO").
12:23:32 -!- clog has joined.
12:23:32 -!- clog has joined.
13:18:02 -!- ihope has quit (Connection timed out).
15:04:53 -!- oerjan has joined.
15:28:19 -!- tgwizard has joined.
15:31:46 -!- jix has joined.
18:57:19 -!- RodgerTheGreat has joined.
18:57:25 <RodgerTheGreat> hi
18:58:44 <oklopol> http://esoteric.voxelperfect.net/wiki/Fortuna
18:58:52 <oklopol> can someone explain this?
18:59:17 <oklopol> 0 Change nothing
18:59:17 <oklopol> 1 Take hand on or off the wheel
18:59:27 <oklopol> what the fuck does a hand do?
18:59:29 <oklopol> :\
19:00:27 <RodgerTheGreat> "there is a theoretical wheel, spinning at a constant speed of 1, that manipulates a set of bits"
19:00:39 <oklopol> ye
19:01:43 <oklopol> so... executes a BF > or < between every instruction... or?
19:03:55 <oerjan> I get this sudden urge to create the Incomprehensible template :)
19:04:15 <oklopol> if it's a constant speed of one, how can you change it? speed as a concept includes the direction, if it's constant, how is it changed?
19:04:18 <oklopol> means velocity?
19:04:37 <oerjan> no, velocity includes direction, speed does not.
19:04:51 <oklopol> okay
19:04:55 <oklopol> good
19:05:31 <oerjan> although with the rest of the description I wouldn't bet on the writer having considered that.
19:05:32 <oklopol> nah i don't understand the lang
19:06:27 <oklopol> i hate these descriptions, i have to read the long code of the interpretor to be able to understand the idea, which can easily be expressed in a few sentences
19:06:36 <oklopol> or then i
19:06:51 <oklopol> 'm just too stupid to understand clear descriptions
19:07:29 <oklopol> which, tho, i wouldn't be suprised of, given i missed the on this wheel part in "On this wheel there are five commands:"
19:07:33 <oerjan> That would have been an option if there was actually a pointer to an implementation.
19:07:46 <oklopol> yes, that's why i had to ask
19:07:58 <oklopol> if you get it, please tell me :\
19:08:43 <oklopol> i got a result of almost printing 0000111 when executing the prog, but then it did something weird in the end
19:08:54 <oklopol> and the scan... i have no idea what that means
19:09:59 <oklopol> "move bit pointer in current direction" there are 3 directions, memory direction, wheel direction and ip direction, right?
19:10:16 <oerjan> OK I had one sudden insight.
19:10:25 <oklopol> on that, or smth else?
19:11:24 <oerjan> The wheel does not actually contain the bits. The wheel only has 5 positions, each of which corresponds to a command.
19:12:13 <oklopol> yes
19:12:44 <oerjan> Well, perhaps.  It doesn't make very much sense even then.
19:12:45 <oklopol> but, when scanning for example, wtf do you scan, the code? and are there multiple directions to iterate the code? or?
19:14:29 <oklopol> the code, if i'm right, first fills in the memory 00001110, then changes wheel dir and does somt very strange
19:14:37 <oklopol> *something
19:14:40 <oerjan> Impossible to say.  Whoever wrote the description had no idea how to express an idea.
19:15:54 <oklopol> it changes wheel direction, then outputs, THEN SCANS, scanning being so badly described i have no idea about it, and scanning in that sence too that the output is done 8 times too
19:15:56 <oklopol> i think
19:15:58 <oerjan> OK, perhaps if the example code can be deciphered, something more can be said.
19:17:12 <oklopol> i could decipher that the wheel goes around, when hand is put on, that command is done, when hands are taken off, that command is not executed, while hands are on, all commands are executed
19:17:21 <oklopol> which is said in the description too
19:17:22 <oerjan> Could you please explain how you get even as much as that out of the code? :)
19:17:27 <oklopol> tho not very clearly
19:17:30 <oklopol> okay
19:18:11 <oerjan> actually you said the essential thing while i was writing i think
19:18:15 <oklopol> 0, no hands-on, so bit not changed, 1, wheel turned to 'move bit pointer' and hand were put on, so that is done, memory now 00
19:18:17 <oklopol> good
19:18:19 <oklopol> thought so
19:18:42 <oklopol> i was in a hurry to write that before you could figure it out so i'd get the credit :)
19:19:37 <oerjan> Well, congratulations :)
19:20:08 <oklopol> the author really thought it's obvious that intructions are executed when hands are on the wheel?
19:20:22 -!- digital_me has joined.
19:20:41 <oerjan> I'll have to write up what we get after doing your initial decoding step. But first I actually need some food...
19:24:25 <oerjan> Although if the code = bits and so is self-modifying, the decoding may have to be done continuously.
19:25:31 <oerjan> Wait a minute - a second insight
19:26:00 <oerjan> The "scan" may be a warped version of brainfuck [] - after all, it says the language is brainfuck inspired.
19:26:36 <oerjan> Again, perhaps.
19:26:41 <oklopol> yeah, i think it is, but it's not needed there
19:26:54 <oklopol> very hard keeping track of the execution
19:27:40 <oklopol> that is of course a plus :) but the documentation is bad, unless it's intentionally left as homework for the reader
19:30:06 <oerjan> OK, what did you say you thought the first actual command executed was?
19:31:32 <oklopol> [0]1[2340]1[2340]1[2340]1[234]01[234]01[234]01[234]0[123]432[1]0401[2]3432[1]0401[2]3432[1]0401[2]3432[1]0401[2]343[2]104
19:31:42 <oklopol> this is all the commands if i omit 2's
19:31:49 <oklopol> the beginning makes sence
19:31:59 <oklopol> actual first command >
19:32:36 <oklopol> or, the beginning is >>>>*>*>*>* then change wheel direction... and lost me :)
19:33:45 <oklopol> you'd think it's the output part because there are as many commands as in the beginning where the 0000111(1?) is done
19:33:55 <oklopol> but no, it's full of weird loops and such
19:34:47 <oerjan> a bell character should be 00000111, anyhow
19:35:06 <oklopol> or, does the "Switch direction of wheel" actually mean "change direction of the bit pointer"?
19:35:15 <oklopol> then it'd make sence
19:35:44 <oklopol> oerjan, i think the last bit might be output twice
19:35:46 <oerjan> i would have thought it meant both
19:35:57 <oklopol> because the end is not identical to the almost-end
19:36:10 <oklopol> might mean both, but then 2's are executed
19:36:29 <oklopol> even tho i don't think that is sensible
19:37:56 <oklopol> [0]1[2340]1[2340]1[2340]1[234]01[234]01[234]01[234]0[123]4[012]301[2]3401[2]... now it seems to omit 2's but change direction all the time making the first >>>>*>... thing useless
19:38:48 <oklopol> and, it's clear that in the past-middle output section, either almost every instruction or just one instruction is executed (0001100011 etc)
19:39:03 <oklopol> so, 2 would be most sensible to omit
19:39:23 <oklopol> since it certainly has nothing to do with outputting a \0x7
19:40:39 <oklopol> is the author here? i'll spank him
19:41:28 <oklopol> i thought it'd take like 3 hours to write down a list of all brainfucks and their syntaxes
19:41:36 <oklopol> has taken maybe 6 now
19:41:44 <oklopol> and i'm half down the list
19:42:55 <oklopol> fuck it... next lang :)
19:43:03 <oklopol> if you figure it out, tell me
19:44:43 <oklopol> http://esoteric.voxelperfect.net/wiki/FukYorBrane, once again, a thorough spesification :(
19:44:52 <oklopol> bomb?
19:45:12 <oklopol> a non-'<>+-[],.' instruction?
19:45:27 <oerjan> It's inspired by brainfuck and redcode, i believe
19:45:40 <oklopol> oh, there is an implementation
19:45:45 <oklopol> yeah, i know
19:49:35 <oklopol> now i realize it's one of gregorr's langs, which i already read on his page, well, who'd remember a name like FukYorBrane :D
19:59:44 <oklopol> GregorR, damn you, first brainfuck i couldn't specify in 5 sentences :D
20:00:36 <oerjan> Yeah, gregorR's languages tend to have a certain quality.
20:05:15 <oklopol> yeah, i assumed all bf-copies are shit :)
20:05:24 <oklopol> in fact, many are pretty nice
20:05:27 <oklopol> http://esoteric.voxelperfect.net/wiki/Hargfak
20:05:30 <oklopol> now, the main stack
20:05:34 <oklopol> is that the main array?
20:06:06 <oklopol> <, > etc are just 'same as in BF', but then i'll have to know if the stack is the memory... it's not really a stack in bf :\
20:06:49 <oklopol> plus, "{} Make a code-block, push to stack" wouldn't make sence then
20:07:18 <oerjan> i think the stack and array are separate
20:07:40 <oklopol> #  ( Move top from main stack to top of stack at sub pointer
20:07:40 <oklopol> # ) Reverse function of ( 
20:07:50 <oklopol> i have no idea what that means :\
20:08:00 <oklopol> top of stack at sub pointer?
20:08:04 <bsmntbombdood> ask the GregorR himself
20:08:12 <oklopol> sub pointer points to memory, i'd think :\
20:08:18 <oklopol> is Hargfak his?
20:08:21 <oklopol> i doubt it
20:08:24 <oklopol> not on his page
20:08:35 <bsmntbombdood> oh, I thought you said it was
20:08:41 <oklopol> FuckYorBrane is well commented
20:09:09 <oerjan> nope it's ZZo38's
20:09:23 <oklopol> oh
20:09:38 <oklopol> does he exist somewhere? :D
20:09:50 <oerjan> he is quite productive on the wiki
20:10:33 <oklopol> well, doesn't help me :\
20:10:40 <oklopol> you understand ()?
20:10:45 <oerjan> darn, the wiki is slow.
20:11:00 <oklopol> or you understand "top of stack at sub pointer"
20:11:16 <oerjan> i think i retract my first assumption
20:11:32 <oerjan> i think the language has stacks as elements of stacks
20:11:41 <oerjan> as one of the data types.
20:12:43 <oklopol> yeah, thought might be so, then all cells are numbers by default, but stacks can be put there
20:13:07 <oklopol> put... what's the word...
20:13:46 <oklopol> i'm starting to miss basic vocabulary, someone must be feeding me drugs or smth
20:14:54 <oerjan> i'm sorry but obviously your brain is fucked.
20:15:17 <oerjan> put is fine, i think.
20:15:18 <oklopol> well... makes sence :\
20:15:59 <oklopol> put is fine, yeah, but it's not really nice if i can't look-up the word i was gonna use...
20:16:27 <oklopol> i mean, generally, not nice to forget something you've known for ages
20:16:35 <oklopol> been doing too much brainfuck
20:16:36 <oklopol> maybe
20:17:05 <oerjan> inserted, placed, pushed?
20:17:35 <oklopol> any of those would've been nice :)
20:17:50 <oklopol> put was the only one i found
20:18:03 <oklopol> usually happens when i've been reading a dictionary
20:18:20 <oklopol> i forget all other words for a while
20:18:35 <oklopol> tho, off-topic, gotta continue my task
20:19:30 <oklopol> okay
20:19:42 <oklopol> if stack is the same as the memory, "; Push data at pointer to stack"
20:20:30 <oklopol> okay, i have no idea, next lang
20:38:12 <oerjan> *sigh* that Fortuna program doesn't make sense either way.
20:38:56 <oerjan> no matter which interpretation is used it looks like it is doing _input_ first.
20:45:27 <oerjan> looking at the history, a couple of points in the article might actually be misunderstandings by later people trying to clean up after the author. The author actually explained that hands on/off continued/suspended execution, and didn't actually say the beep was a single character.
20:53:38 <oklopol> i figured it'd be nice to have 50 brainfucks rather that 48 so i'll have to improvise 2
20:53:54 <oklopol> the first one is nice, i'll add it in the wiki and feel proud
20:53:55 <oklopol> yay
21:14:16 <oklopol> god ihope has a lot of langs there :O
21:14:56 -!- ihope_ has joined.
21:15:20 -!- ihope_ has changed nick to ihope.
21:15:41 <bsmntbombdood> speak of the devil
21:16:52 <oklopol> wow
21:16:58 <oklopol> that was weird
21:17:16 <oerjan> What, you've never seen a synchronicity before? :)
21:17:20 <oklopol> but i said god ihope, not devil
21:17:43 <oklopol> oerjan, yeah, but things can be weird multiple times
21:17:44 <oklopol> :)
21:17:52 <ihope> Basement bot change root again.
21:18:03 <bsmntbombdood> yes?
21:18:29 <ihope> What happened?
21:18:35 <bsmntbombdood> ?
21:19:03 <ihope> Ah, I see.
21:19:10 <bsmntbombdood> ?
21:19:11 <ihope> 13:14:16 <oklopol> god ihope has a lot of langs there :O
21:19:18 <ihope> 13:14:56 --- join: ihope_ (n=foo@c-71-205-100-59.hsd1.mi.comcast.net) joined #esoteric
21:19:35 <bsmntbombdood> ya
21:19:55 <oklopol> it was weird until i figured ppl here have a habit of actively reading logs
21:20:09 <oklopol> which is never done in any other channel i am on
21:20:16 <bsmntbombdood> heh
21:20:51 <oklopol> but, this is one of the only channels that sometimes has stuff worth reading afterwards
21:21:15 <oklopol> due to it's experimental nature
21:21:20 <ihope> I didn't see that log until afterward.
21:21:25 <oklopol> okay
21:21:29 <oklopol> then it is weird
21:21:36 <ihope> I must be psychotic. ;-)
21:21:59 <bsmntbombdood> psychotic indeed
21:22:01 <bsmntbombdood> :P
21:22:14 <oerjan> ain't we all
21:22:35 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :psychos!")
21:22:35 <bsmnt_bot_chroot> psychos!
21:22:45 <oklopol> i don't know if you have many bf-langs there, just saw your name three times in a row when checking the author of pages randomly
21:22:52 <oklopol> ihope
21:22:58 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
21:23:22 <ihope> BF-langs, eh?
21:23:54 <oklopol> in the category bf-derivatives
21:24:05 <oklopol> i saw your name in three random picks
21:24:21 <oklopol> ihope127 actually, assumed that's you
21:24:27 <ihope> Yeah, it is.
21:24:33 <bsmntbombdood> whoa
21:24:37 <oerjan> oklopol is writing a thesis, "A survey of languages within the Mullerian sub-paradigm of Esoterics."
21:24:40 <bsmntbombdood> 127 is 2**7-1
21:24:42 * ihope clicks "Random Page" a few times and eventually lands on one of his own languages.
21:24:52 <oklopol> :D
21:25:05 <oklopol> how many do you have?
21:25:06 <ihope> Exactly why I chose the number 127.
21:25:21 <ihope> No idea.
21:25:25 <oklopol> bsmntbombdood, what a witty thing to notice :D
21:25:27 <bsmntbombdood> 1<<7 - 1
21:25:54 <oerjan> it is indeed possible to do a search for the word "ihope"
21:26:02 <ihope> True.
21:26:02 <oerjan> i believe
21:26:07 <bsmntbombdood> t
21:26:10 <bsmntbombdood> nil
21:26:11 <oklopol> hey, good idea
21:27:42 <oklopol> eh... 6 ones? maybe the search is too complicated for me
21:29:24 <oerjan> I only get 3. hmmm..
21:29:43 <ihope> I have Catch, Foobar, SMATINY, SNOBOL, quantum brainfuck, BF-SC, and BF-PDA. The fact that there are six there and you said six may be making me forget the others.
21:29:56 <ihope> I also have Subtle Cough.
21:30:25 <ihope> ...Wait, I listed seven there, not six.
21:30:28 <oerjan> ah, ihope127 gave many more matches than ihope for some reason.
21:30:29 <bsmntbombdood> a language were the only construct is raising and catching exceptions
21:30:31 <ihope> So that makes eight.
21:30:35 <ihope> oerjan: of course.
21:30:41 -!- CakeProphet has joined.
21:30:42 <ihope> bsmntbombdood: fun, no?
21:30:53 <bsmntbombdood> Is that actually what it is?
21:30:55 <ihope> Of course, I could probably do it much better now.
21:31:04 <bsmntbombdood> sweet
21:31:05 <ihope> bsmntbombdood: might be; I dunno.
21:31:11 <bsmntbombdood> ?
21:31:12 <oerjan> i thought it would match subwords as well.
21:31:19 <ihope> Also, I make Thubi. Nine, then.
21:33:18 <oerjan> ok i see 11 matches
21:33:34 <ihope> What'd I miss?
21:33:55 <oerjan> wait a minute, SNOBOL is not esoteric.
21:34:10 <oerjan> ah, SLOBOL. 12 then.
21:34:16 <oklopol> hmm, a qbit is a bit that has a certain probability for being 1 or 0? too complex for me again, if not :)
21:34:19 <ihope> Close enough.
21:34:29 <oerjan> BF-PDA is not listed.
21:34:37 <oklopol> it is
21:34:51 <oerjan> not under the search results
21:34:58 <ihope> oklopol: no, there's a probability amplitude, which is a complex number, for every possible combination of bits.
21:35:08 <oklopol> no name on the article
21:35:13 <oklopol> maybe that's why
21:35:17 <ihope> And the probability corresponding to the amplitude x is |x|^2. Confusing, eh?
21:35:47 <oklopol> |x|^2 is the length of the number ^ 2?
21:35:51 <oerjan> neither is Subtle Cough.
21:36:05 <oklopol> |complex| is the length
21:36:05 <oklopol> ?
21:36:38 <ihope> x is the amplitude.
21:36:51 <bsmntbombdood> yo mommoa is the amplitude
21:36:53 <ihope> |x| is the absulute value of the amplitude.
21:36:53 <oklopol> okay, is that a complex number?
21:37:01 <ihope> Yes, x is a complex number.
21:37:19 <oklopol> but, absolute value of a complex number is it's length
21:37:23 <ihope> Also, I made ///, a.k.a. Slashes. Does that make 10?
21:37:23 <oklopol> right?
21:37:29 <ihope> oklopol: the length of its vector? Yes.
21:37:39 <oklopol> well, that's what i meant, yeah
21:38:08 <oerjan> there is Slashes (///), REverge, Minimum, Pointy and Onoz.
21:38:11 <ihope> Yay.
21:38:19 <oklopol> k, i'll just do like the wiki and assume the reader knows qubits :)
21:39:41 <ihope> So REverge isn't really a language, so that's Catch, Foobar, SMATINY, SLOBOL, quantum brainfuck, BF-SC, BF-PDA, Subtle Cough, ///, Minimum, Pointy, onoz.
21:39:53 <ihope> Twelve in all, I guess.
21:40:32 <ihope> And how many are joke languages?
21:41:12 <oerjan> Ah yes, Subtle Cough is not really usable either, as I proved.
21:41:55 <ihope> Yeah, that.
21:43:19 <oerjan> REverge seems a bit unfinished.
21:43:47 <ihope> I mostly forgot about Catch, Foobar is finite, SMATINY is not only finite but reversible, SLOBOL is Foobar in disguise, quantum brainfuck is Turing-complete, BF-SC and BF-PDA are guaranteed to terminate, Subtle Cough is not Turing-complete, /// is unknown, Minimum has no programs, Pointy is Turing-complete, and onoz is unknown.
21:43:54 <ihope> Yes, REverge might as well be deleted.
21:44:11 <ihope> So that's at least two languages I made that are Turing-complete.
21:44:27 <oerjan> SMATINY is definitely not a joke, in my opinion.
21:44:43 <oerjan> not any more than SMETANA.
21:45:52 <ihope> Yeah, it's not a joke.
21:46:16 <ihope> Catch... oh, whether or not it's Turing-complete depends on the built-in exceptions and handlers.
21:47:36 <oerjan> Onoz can of course express all programs known to terminate.
21:47:45 <ihope> Yep.
21:49:23 <oerjan> It is probably Turing-complete, although we will never know how to program in it, because for infinite loops we have to use a subprogram which we think but are not sure never terminates.
21:51:08 <ihope> Hmm...
21:54:02 <oerjan> I expect some variant of the proof of the halting problem can be used to find a couple of algorithms such that one of them does not terminate but we can never know which.
21:55:24 <oerjan> halting problem + gõdel's incompleteness theorem (whose proofs are essentially very similar)
21:56:53 <ihope> Hmm.
21:57:19 <ihope> Wait. If we can never know something's incorrect, it's correct.
21:57:31 <ihope> If there's no observable difference, then they're the same.
21:57:37 <oerjan> yes, but we cannot necessarily prove it.
21:58:00 <ihope> We can't prove two things to be the same, sure.
21:58:33 <ihope> If we have a collection of algorithms and we know exactly one is correct, we can figure out which one it is.
21:58:50 <oerjan> and the definition of Onoz uses provability of non-termination, not actual termination.
21:59:36 <oerjan> except that in reality none of them terminate, but we are not sure of it. Maybe we don't really need more than one algorithm.
22:00:40 <oklopol> i assume http://esoteric.voxelperfect.net/wiki/SPL also has + / - since they are used in the example
22:00:44 <oklopol> but what is |?
22:02:26 <oklopol> "that of brainfuck", someday i'll learn to read
22:02:41 <ihope> Brainfuck has |?
22:03:31 <oerjan> it seems like | is a variant of $
22:05:57 <oerjan> There is the same confusion on his webpage (except in Italian :) )
22:06:23 <oerjan> Several more example programs though.
22:06:37 <oklopol> okay
22:06:41 <oklopol> variant?
22:06:46 <oklopol> ah
22:06:48 <oklopol> decimal
22:07:01 <oerjan> All except the final example use |.
22:07:06 <oklopol> yeah, a monkey could see that from the example
22:07:13 <oklopol> the | is decimal input thig
22:07:15 <oklopol> *thing
22:07:27 <oklopol> but i didn't
22:07:29 <oerjan> Actually so is $, according to the website.
22:07:33 <oklopol> really?
22:07:38 <oklopol> well, i don't believe it :)
22:07:48 <oerjan> $Aspetta che l'utente inserisca un numero e lo mette nell'accumulatore
22:07:56 <oklopol> i make my own lang then, take the same name and change that
22:08:35 <oerjan> http://stelk.altervista.org/SPL0.2.tar.gz
22:08:41 <oklopol> or, my lang's name is SPL ^H
22:08:45 <oklopol> if needed
22:09:46 <oklopol> i can't open that, anyway, i'll make it ascii input, i'm sure the author never sees my page :)
22:10:09 <oklopol> oh fuck
22:10:18 <oklopol> | puts a number in the current cell
22:10:37 <oerjan> There is an implementation there too, in C++
22:11:05 <oklopol> i can't open the link
22:11:16 <oerjan> No, it's , which does that.
22:11:22 <oklopol> now it opened
22:11:24 <oerjan> $ insers into the accumulator.
22:11:40 <oklopol> | read a number in the current cell, at least in the example
22:11:42 <oerjan> *inserts
22:11:44 <oklopol> *reads
22:11:45 <oklopol> :D
22:12:41 <oklopol> LOLfuck, '$' is twice in that code
22:12:48 <oklopol> there's no '|'
22:13:04 <oerjan> Which file?
22:13:52 <oklopol> i got it open
22:14:11 <oerjan> ah, the C++ code. And not an else in sight, either :)
22:14:17 <oklopol> there is a '#' that is just a subset of '[' xD
22:14:40 <oklopol> no elses, so '$' does two inputs, only latter one is used
22:14:44 <oerjan> unnested version
22:14:55 <oklopol> okay
22:15:05 <oklopol> you can use it with [] for interesting results
22:15:12 <oklopol> so i retract my statemenzzor
22:15:25 <oklopol> especially 'xD'
22:15:28 <oklopol> :)
22:20:33 <oerjan> Wait a moment.
22:20:46 <oerjan> Hm...
22:20:59 <oerjan> It says on the wiki that # ... # is a comment.
22:22:55 <oerjan> However, the implementation makes no attempt to ignore [] matches inside #'s, so it can still be used for interesting results.
22:24:49 <oklopol> :DD
22:26:59 <oklopol> i didn't even think of the '#' as a comment since i thought it was supposed to be used with [] for additional fun
22:27:42 <oerjan> There is some serious possibility for buffer overruns with #[] too..
22:28:08 <oklopol> yeah, overall, FRENCH PEOPLE SUCK AT CODING
22:28:16 <oklopol> (i'm kidding don't kill me :;()
22:28:38 <oerjan> It would have been better if you had noticed it was Italian.
22:28:57 <oerjan> Unless that was part of the joke :)
22:29:11 <oklopol> THEY CAN'T EITHER
22:29:13 <oklopol> :)
22:29:23 <oklopol> i don't know either language :\
22:29:51 <oerjan> I know enough to guess most of the meaning.
22:30:27 <oklopol> hmm
22:30:29 <oklopol> maybe me too
22:30:31 <oklopol> i'll try
22:31:08 <oklopol> "Aspetta che l'utente inserisca un numero e lo mette nell'accumulatore"
22:31:11 <oklopol> no idea
22:31:45 <oerjan> "Expect that the user will insert a number, and put it in the accumulator."
22:33:13 <bsmnt_bot_chroot> looneys!
22:33:18 <bsmnt_bot_chroot> looneys i say!
22:33:23 <oerjan> BLBLBLBLBLBLBL
22:33:45 <bsmntbombdood> No
22:33:46 <bsmntbombdood> one
22:33:51 <bsmntbombdood> has broken
22:33:53 <oklopol> what langs do you know to understand that?
22:33:54 <bsmntbombdood> my chroot
22:33:55 <bsmntbombdood> yet
22:34:11 <oklopol> bsmntbombdood, maybe it's too easy for us
22:34:19 <bsmntbombdood> oh, right
22:34:31 <oerjan> English, a bit Italian, and in theory a bit French.
22:34:45 <bsmnt_bot_chroot> looneys!
22:35:02 <bsmnt_bot_chroot> break me!
22:35:05 <oerjan> Note that almost every long word except "mette" is related to the English.
22:35:41 <bsmntbombdood> ~quit
22:35:41 -!- bsmnt_bot_chroot has quit.
22:35:45 -!- bsmnt_bot_chroot has joined.
22:35:51 <oklopol> yes, but vaguely
22:35:52 <bsmntbombdood> oops
22:35:53 <oerjan> So what I need of Italian is mostly grammar.
22:35:56 <bsmntbombdood> ~quit
22:35:57 -!- bsmnt_bot_chroot has quit (Client Quit).
22:35:58 -!- bsmnt_bot has joined.
22:36:00 <oklopol> utente in unguessable
22:36:57 <oerjan> Oh yes, I also once read a Latin grammar.  Made me understand a lot about how things like "utente" and "user" can be related.
22:36:57 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
22:37:03 <bsmntbombdood> ~exec print >> sys.stdout, os.abspath(".")
22:37:52 <bsmntbombdood> ~exec print >> sys.stdout, os.getpid()
22:37:53 <bsmnt_bot> 16985
22:38:05 <oerjan> Basically one is the present stem and the other the past perfect.
22:38:58 <oerjan> And English for some reason borrows Latin words with the latter.
22:39:40 <oerjan> Actually English has that version too: "utility"
22:39:51 -!- oklopol has joined.
22:40:15 <bsmntbombdood> lame
22:40:16 <oerjan> *words -> verbs
22:40:48 <oerjan> darn i didn't notice you left :(
22:40:51 <oklopol> :)
22:40:53 <oklopol> i thought so
22:40:56 <oklopol> repeat!
22:40:56 <oklopol> :D
22:41:07 <oerjan> Oh yes, I also once read a Latin grammar.  Made me understand a lot about how things like "utente" and "user" can be related.
22:41:14 <oerjan> Basically one is the present stem and the other the past perfect.
22:41:19 <oerjan> And English for some reason borrows Latin words with the latter.
22:41:27 <oerjan> Actually English has that version too: "utility"
22:41:32 <oerjan> *words -> verbs
22:42:50 -!- bsmnt_bot has quit ("nobody loves me :(").
22:42:52 -!- bsmnt_bot has joined.
22:43:49 * oerjan hugs bsmnt_bot
22:44:23 <bsmnt_bot> break me!
22:44:46 * oerjan doesn't have the skills for that.
22:45:13 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
22:45:18 <oerjan> I tend to stay at an abstract level, fairly far from the machine.
22:45:33 <bsmntbombdood> ~exec print >> sys.stdout, os.getpid()
22:45:34 <bsmnt_bot> 16991
22:46:20 <oerjan> Besides, who knows if there even is a loophole to use.
22:46:41 <bsmntbombdood> I'm sure there's a way to do it
22:48:02 <oerjan> I suppose if you included the whole Linux distribution in the jail there might be a chance.
22:48:19 <bsmntbombdood> yeah, there isn't much to exploit inside it
22:48:53 <oerjan> It might in fact be easier to break into your machine from the outside, for all I know.
22:48:59 <bsmntbombdood> no setuid root programs
22:49:48 <bsmntbombdood> (inside the jail)
22:53:26 <oerjan> So basically only someone with a good knowledge of the Linux kernel (and probably Python) would stand a chance, which doesn't include me.
22:53:38 <bsmntbombdood> heh, yeah
22:59:05 -!- oklopol has joined.
23:01:59 -!- tgwizard has quit (Remote closed the connection).
23:02:59 <CakeProphet> ~exec print os.listdir()
23:03:41 <bsmntbombdood> ~exec print >> sys.stdout, os.listdir()
23:03:44 <bsmntbombdood> ~exec print >> sys.stdout, os.listdir(".")
23:03:44 <bsmnt_bot> ['bin', 'bot', 'etc', 'lib', 'usr']
23:03:54 <CakeProphet> Why do you have to do that?
23:04:01 <bsmntbombdood> because python is stupid
23:04:08 <CakeProphet> ~exec print >> sys.stdout,  os.listdir("bin")
23:04:09 <bsmnt_bot> ['bash']
23:04:25 <CakeProphet> .... print >> sys.stdout   is the exact same thing as print
23:04:28 <CakeProphet> it's redundant.
23:04:37 <bsmntbombdood> In a normal enviroment, yeah
23:04:44 <CakeProphet> ~exec print >> sys.stdout,  sys.stdout
23:04:45 <bsmnt_bot> <__main__.IRCFileWrapper instance at 0xb7bfe48c>
23:04:53 <oerjan> ~exec print >> sys.stdout, os.listdir("lib")
23:04:53 <bsmnt_bot> ['libm.so.6', 'libreadline.so.5', 'libdl-2.4.so', 'libresolv.so.2', 'libutil.so.1', 'libncurses.so.5', 'libcrypt.so.1', 'ld-linux.so.2', 'libdl.so.2', 'libpthread.so.0', 'libpam_misc.so.0', 'libpam.so.0', 'libc.so.6']
23:05:29 <CakeProphet> ...no... I mean... that -is- the same thing.
23:05:42 <bsmntbombdood> obviously not
23:05:47 <bsmntbombdood> inside an exec
23:05:47 <CakeProphet> There's no other way to get around that... unless you use >>,  print goes directly to sys.stdout.
23:05:48 <oerjan> it would if the sys module was the standard one.
23:06:07 <CakeProphet> so you're using a different module for sys?
23:06:28 <CakeProphet> even then... you'd have to hack the interpreter to make those two statements mean anything different from each other.
23:06:31 <bsmntbombdood> I'm using a costum object, to redirct stdout to the right place
23:06:56 <CakeProphet> ...that doesn't change the fact that print by itself always goes to sys.stdout...
23:07:06 <oerjan> How are you assigning it to sys.stdout?
23:07:16 <CakeProphet> sys.stdout = whatever
23:07:32 <oerjan> i'm asking bsmntbombdood
23:07:35 <bsmntbombdood> CakeProphet: Can't do that, that interferes with the "real" stdout
23:07:55 * CakeProphet does it all the time...
23:07:59 <oerjan> well that's the idea, isn't it?
23:08:03 <bsmntbombdood> oerjan: by passing a costum enviroment to the python exec statement
23:08:20 <oerjan> it _should_ change the real stdout.
23:08:36 <bsmntbombdood> no, we only want it to change inside the exec
23:08:36 <CakeProphet> what's a costum enviornment... and how does it change the axiomatic grand law of python's print statement?
23:09:05 <oerjan> he is probably redefining the sys variable to not point at the sys module.
23:09:10 <bsmntbombdood> right
23:09:24 <CakeProphet> ....regardless.... the regular print would just point to that as well.
23:09:30 <bsmntbombdood> env[0]["sys"] = SysWrapper(stdout = IRCFileWrapper(self.raw, r.group(1)), stderr = IRCFileWrapper(self.raw, self.errorchan))
23:09:55 <CakeProphet> That sounds kind of extraneous.  :P
23:10:11 <CakeProphet> you could just do.
23:10:23 <oerjan> basically print will always refer to the stdout of the real sys module, not to stdout of whatever happens to be in the global variable sys.
23:10:38 <CakeProphet> exec SomeCode in {"sys":<something>}
23:10:54 <bsmntbombdood> CakeProphet: That's what I am doing...
23:11:08 <CakeProphet> hmmm... so what's the point in wrapping sys if it doesn't do the main objective of replacing stdout?
23:11:26 <bsmntbombdood> It does replace stdout
23:11:33 <CakeProphet> only for the programmer.
23:11:35 <bsmntbombdood> ~exec print >> sys.stdout, sys.stdout
23:11:36 <bsmnt_bot> <__main__.IRCFileWrapper instance at 0xb7bfe7ac>
23:11:43 <bsmntbombdood> that's no file object
23:11:49 <oerjan> but not for print, which makes it pointless :)
23:11:52 <CakeProphet> but if the regular print statement doesn't.
23:11:54 <CakeProphet> yes.
23:11:59 <CakeProphet> you finished before me...
23:12:03 <bsmntbombdood> ~quit
23:12:03 -!- bsmnt_bot has quit.
23:12:06 -!- bsmnt_bot has joined.
23:12:15 <bsmntbombdood> ~exec print "error
23:12:28 <oerjan> it would be simpler to just do print >> channelObj
23:12:43 <oerjan> whatever you call that.
23:12:51 * CakeProphet doesn't like the >> syntax for print.
23:12:58 <bsmntbombdood> print >> IRCFileWrapper(self.raw, "#esoteric"), "foo"
23:13:01 <CakeProphet> channelObj.write("blah blah")
23:13:19 <CakeProphet> if you had constant objects for channels... it would be more convient.
23:13:24 <bsmntbombdood> ?
23:13:33 <CakeProphet> instead of instantiating one everytime.
23:13:33 <oerjan> esoteric = IRCF....
23:13:44 <CakeProphet> yeah.
23:13:45 <bsmntbombdood> sys.stdout is the object representing the current channel
23:13:48 <oerjan> Then just print >> esoteric
23:14:04 <oerjan> well print >> curChannel
23:14:05 <CakeProphet> but what's the point in replacing sys.stdout if it doesn't does what sys.stdout is supposed to do?
23:14:21 <CakeProphet> you might as well just make a variable called "channel".
23:14:25 <bsmntbombdood> Well, I had to try
23:14:54 <bsmntbombdood> oerjan: print >> sys.stdout IS print >> currchan
23:15:13 <bsmntbombdood> I'm still trying to figure out how to make print behave like it should
23:15:21 <CakeProphet> I kind of like that... 
23:15:25 <CakeProphet> just  print >> esoteric
23:15:32 <CakeProphet> or even better  esoteric.send()
23:15:59 <bsmntbombdood> ~exec global esoteric; esoteric = IRCFileWrapper(self.raw, "#esoteric")
23:16:26 <bsmntbombdood> ~exec print >> esoteric, esoteric
23:16:31 <bsmntbombdood> damn
23:16:39 <CakeProphet> yeah.
23:16:42 <CakeProphet> I didn't think that would work.
23:16:44 <bsmntbombdood> ~exec self.esoteric = IRCFileWrapper(self.raw, "#esoteric")
23:16:53 <bsmntbombdood> ~exec self.esoteric.write("hi")
23:16:53 <bsmnt_bot> hi
23:17:41 <CakeProphet> hehe... I would have done factory functions or something  :D
23:17:57 <bsmntbombdood> factory functions?
23:18:02 <CakeProphet> esoteric = channelfactory("#esoteric")
23:18:07 <CakeProphet> esoteric("Hello World!")
23:18:36 <bsmntbombdood> ~exec self.esoteric = IRCFileWrapper(self.raw, "#esoteric").write
23:18:46 <bsmntbombdood> ~exec self.esoteric("foo")
23:18:47 <bsmnt_bot> foo
23:18:49 <bsmntbombdood> better?
23:18:55 * CakeProphet shrugs
23:18:58 <CakeProphet> doesn't matter to me.
23:19:47 <CakeProphet> factroy functions give functional programming an OO-like advantage.
23:19:51 <CakeProphet> without being all... OO-ish.
23:24:41 <ihope> CakeProphet: factory functions?
23:24:47 <ihope> You mean constructors?
23:24:59 <CakeProphet> ...same idea... 
23:25:06 <CakeProphet> sorta kinda
23:25:09 <ihope> data Channel = ChannelFactory String -- this?
23:25:14 <bsmntbombdood> make_adder = lambda x : lambda y : x+y
23:25:31 <CakeProphet> constructors setup an initial state... factory functions produce other functions.
23:25:44 <ihope> Ah, I see.
23:25:52 <ihope> So a factory function is just a function returning a function?
23:25:57 <CakeProphet> Yup.
23:26:07 <CakeProphet> pretty powerful stuff.
23:26:20 <ihope> Naturally I'd miss the point completely, being used to first-class functions :-)
23:26:30 <CakeProphet> well... there's other flavors of factory functions... I've made a factory function that spat out classes.
23:26:43 <ihope> Anything that produces something unusual?
23:26:51 <CakeProphet> hmmm...
23:26:58 <CakeProphet> not that I can think of.
23:27:00 <bsmntbombdood> In python you can make classes like factory functions
23:27:04 <CakeProphet> I considered making a factory factory function.
23:27:22 <ihope> I mean a factory function is something that produces something unusual?
23:27:26 <CakeProphet> for producing convient factory functions.
23:27:29 <CakeProphet> no.
23:27:37 <CakeProphet> it just produces a... function.
23:27:47 <bsmntbombdood> ~quit
23:27:47 -!- bsmnt_bot has quit.
23:27:49 -!- bsmnt_bot has joined.
23:27:52 <ihope> So how could a factory function spit out classes?
23:27:54 <CakeProphet> it puts a common set of goals that you'd have for defining a certain type of function into a nice little package.
23:27:57 <bsmntbombdood> ~exec self.esoteric = IRCFileWrapper(self.raw, "#esoteric")
23:28:00 <CakeProphet> by defining them in their body.
23:28:04 <ihope> I see.
23:28:05 <bsmntbombdood> ~exec self.esoteric("foo")
23:28:05 <bsmnt_bot> foo
23:28:08 <bsmntbombdood> neat, eh?
23:28:11 <ihope> bsmntbombdood: is this guy chrooted?
23:28:15 <bsmntbombdood> yeah
23:28:34 <bsmntbombdood> the long nick was getting annoying
23:28:37 <ihope> ~pexec self.quit
23:28:43 <ihope> That didn't work.
23:28:43 <bsmntbombdood> the new error channel is #bsmnt_bot_errors, btw
23:28:47 <bsmntbombdood> ~exec
23:29:03 <bsmntbombdood>  ~exec is public now
23:29:14 <ihope> ~exec self.quit
23:29:27 <ihope> That didn't exactly work either, eh?
23:29:37 <bsmntbombdood> it got executed though
23:29:46 <bsmntbombdood> <bsmnt_bot> AttributeError: IRCbot instance has no attribute 'quit'
23:30:28 <ihope> ~exec self.do_quit()
23:30:35 <ihope> I also forgot about the () at the end... uh...
23:30:45 <ihope> Yes.
23:30:46 <bsmntbombdood> ...join that channel so I don't have to copy and paste erros
23:33:07 <ihope> ~exec self.disconnect("RAH RAH RAH")
23:33:07 -!- bsmnt_bot has quit ("RAH RAH RAH").
23:33:10 -!- bsmnt_bot has joined.
23:33:16 <ihope> Pretty fancy.
23:33:20 <bsmntbombdood> there ya go
23:34:14 <ihope> ~exec self.do_callbacks(":bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :~quit")
23:34:15 -!- bsmnt_bot has quit (Client Quit).
23:34:18 -!- bsmnt_bot has joined.
23:34:20 <ihope> Wonderful.
23:35:33 -!- oklofok has joined.
23:35:50 <ihope> What the...
23:35:56 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
23:35:59 <bsmntbombdood> ?
23:36:08 <ihope> s/pol/fok/?
23:36:23 <CakeProphet> ihope,  http://deadbeefbabe.org/paste/3246
23:36:30 <CakeProphet> assume that class statement is dedented a notch.
23:36:40 <CakeProphet> *indentation was screwing up.
23:37:12 <bsmntbombdood> silly python, indentation is for stupid people
23:37:32 <ihope> CakeProphet: pretty fancy.
23:37:43 <ihope> bsmntbombdood: uh...
23:38:01 <ihope> Oh... wait...
23:38:03 <ihope> Eh.
23:38:22 <CakeProphet> insane hackish solutions that weren't intended to be done is my favorite passtime.  :D
23:38:43 <bsmntbombdood> __bases__?
23:38:52 <bsmntbombdood> ihope: what?
23:39:13 <CakeProphet> __bases__ is a classes inheritance tuple.
23:39:21 <CakeProphet> class Lol(Rofl, omfg)
23:39:24 <ihope> bsmntbombdood: nothing, nothing...
23:39:30 <CakeProphet> Lol.__bases__   would be (Rofl, omfg)
23:39:33 <bsmntbombdood> oh ok
23:39:56 <CakeProphet> I could have skipped the whole class statement thing by doing.
23:40:04 <CakeProphet> Meh = type(name, parents, dictionary)
23:40:09 <ihope> Pff.
23:40:14 <ihope> That's no fun.
23:40:21 <CakeProphet> since type is -the- metaclass.  :D
23:40:25 <bsmntbombdood> property(None, self.__setattr__, self.__delattr__)?
23:40:34 <CakeProphet> Makes it read-only.
23:40:44 <bsmntbombdood> What's the property function do?
23:40:44 <CakeProphet> there's no get function for it to use.
23:40:46 <CakeProphet> er...
23:40:49 <CakeProphet> write-only  :P
23:40:54 <ihope> Now what's Python have that's like Haskell's "let" or "where"?
23:41:15 <bsmntbombdood> oh, i get it
23:41:21 <CakeProphet> it does some crazy magic stuff to alter the get, set, and delete functions of only one attribute.
23:41:35 <CakeProphet> ihope,  variables are local scope by default.
23:41:51 <CakeProphet> Python has only one, rarely used, scope declaration... "global".
23:42:09 <ihope> Oh, right, Python lets you assign things to variables.
23:42:22 <ihope> Now, uh, hmm...
23:42:24 <CakeProphet> but they're probably going to add a "nonlocal"... for nested scopes.  (Python has a pretty simple idea of nested scopes... it just has "globals" and "locals"...)
23:42:46 <ihope> ~exec self.raw("PRIVMSG #esoteric :Foo"); self.raw("PRIVMSG #esoteric :Foo")
23:42:46 <bsmnt_bot> Foo
23:42:47 <bsmnt_bot> Foo
23:42:51 <ihope> Wonderful.
23:43:08 * ihope pushes #esoteric onto the stack and runs to eat dinner
23:44:06 * CakeProphet ...knows entirely too much about Python.
23:44:18 <CakeProphet> I should find something else to tinker with.
23:44:28 <bsmntbombdood> ...and I though I had to do some low level stuff for bsmnt_bot 
23:45:03 <bsmntbombdood> The trace function was quite nice I though ;)
23:45:53 <CakeProphet> ...the lowest level thing I've ever done with Python is.... select.
23:46:35 <bsmntbombdood> you mean with sockets?
23:46:43 <CakeProphet> Yeah.
23:46:53 <bsmntbombdood> threads > select
23:46:54 <CakeProphet> it's the most basic thing I could think of that I've used.
23:46:54 <oklofok> i made a cool bf :)
23:47:14 <bsmntbombdood> CakeProphet: That class generator was pretty low level
23:47:37 <CakeProphet> heh... that depends on your definition of low level.
23:47:59 <bsmntbombdood> using a class's __ functions is low level python
23:48:19 <CakeProphet> I thought it was fairly abstract...  (anything that creates abstract plans for objects is pretty damn high in abstractiness)
23:48:39 <CakeProphet> meh... just some interpreter magic... __ methods are pretty common in Python programs.
23:48:45 <bsmntbombdood> the __ variables are very close to the interpreter
23:48:50 <bsmntbombdood> hence, low level
23:49:33 <oerjan> Nah, it's not really abstract until it borrows terms from category theory :)
23:49:46 <CakeProphet> they're glorified callback functions basically...
23:49:58 <bsmntbombdood> CakeProphet: they are low level
23:50:34 <CakeProphet> heh... I won't debate the existence of a non-specific, human invented definition.
23:51:08 <CakeProphet> low-level doesn't exist... 
23:51:16 <bsmntbombdood> heh
23:51:16 <CakeProphet> it does... in the sense that there is such a thing as year.
23:51:29 <CakeProphet> and that things like months can exist.
23:51:33 <CakeProphet> but basically it's nothing.
23:53:20 <CakeProphet> hmm... I've taken a liking to using Python sets...
23:53:38 <CakeProphet> they're extremly useful for my MUD... where I don't want accidental duplicate references of objects appearing.
23:56:59 <bsmntbombdood> ~exec self.test = SysWrapper(IRCFileWrapper(self.raw, "#esoteric"), IRCFileWrapper(self.raw, "#esoteric"))
23:57:10 <bsmntbombdood> ~exec self.test.stdout("foo")
23:57:10 <bsmnt_bot> foo
23:57:16 <bsmntbombdood> ~exec self.test.stdout.write("foo")
23:57:17 <bsmnt_bot> foo
23:57:24 <bsmntbombdood> __call__ is great
23:57:52 <bsmntbombdood> ~exec sys.stdout = self.test.stdout
23:57:56 <bsmntbombdood> ~exec print "foo"
23:58:02 <bsmntbombdood> argh
23:58:40 <CakeProphet> most of the special methods are great.  :D
23:58:56 <CakeProphet> __setitem__, __getitem__, __contains__... you can make just about anything.
23:59:26 <bsmntbombdood> CakeProphet("foo")
23:59:43 <CakeProphet> I've got the design for a periodic table of elements somewhere.
23:59:47 <CakeProphet> the information isn't filled in yet...

2007-01-11:

00:00:03 <CakeProphet> but it works like supped up dictionary.
00:02:25 <bsmntbombdood> oh boy, suped up dictionary...
00:02:44 <bsmntbombdood> Just a dictionary of dictionarys would be good
00:03:31 <bsmntbombdood> {"K":{"full-name":"pottassium", valence:whatever...}...}
00:04:00 <oerjan> taste: AAAARGGHHHH
00:04:19 <bsmntbombdood> "spelling":"incorrect"
00:05:27 <CakeProphet> it is basically...
00:05:47 <bsmntbombdood> ~exec sys.stdout(sys)
00:05:48 <bsmnt_bot> <module 'sys' (built-in)>
00:05:52 <CakeProphet> it's 5 or 6 dictionaries of a bunch of objects.
00:06:07 <CakeProphet> objects have the advantage of having methods as well as data.  ;)
00:06:18 <bsmntbombdood> ~exec sys.stdout(sys.__dict__)
00:06:18 <bsmnt_bot> {'_SysWrapper__sys': <module 'sys' (built-in)>, 'stderr': <__main__.IRCFileWrapper instance at 0xb7bda7cc>, 'stdout': <__main__.IRCFileWrapper instance at 0xb7bda76c>}
00:06:29 <bsmntbombdood> hmph
00:06:30 <CakeProphet> and the 5 or 6 dictionaries are just optimization for some common ways to refer to elements.
00:06:34 <bsmntbombdood> ~exec sys.stdout(sys.sys.__dict__)
00:06:47 <bsmntbombdood> ~exec sys.stdout(sys._SysWrapper__sys.__dict__)
00:06:48 -!- bsmnt_bot has quit (Excess Flood).
00:06:50 -!- bsmnt_bot has joined.
00:06:52 <bsmntbombdood> argh
00:07:05 <bsmntbombdood> I need to put flood protection in IRCFileWrapper
00:07:06 <ihope> CakeProphet: I still don't exactly see the point of objects when methods are really just functions on them. Then again, in Python, objects' methods are really just functions on them, so...
00:07:21 <ihope> ~exec raw(self,"PRIVMSG #esoteric :Foo")
00:07:29 <ihope> Fun.
00:07:34 <CakeProphet> eh... self-containedness... there's no functional benefit... it just makes organizing everything easier.
00:07:40 <CakeProphet> when everything's in a scope of some sort.
00:07:48 <ihope> Well, yeah.
00:08:13 <ihope> Of course, some things *do* have points.
00:08:26 <ihope> I'm still waiting for my language where programs are first-order logic theories.
00:09:04 <ihope> Call it a FOLTE, for First Order Logic Theory Evaluator. And pronounce it "faulty".
00:09:19 <bsmntbombdood> ~exec IRCbot.raw(self, "PRIVMSG #esoteric :foo")
00:09:20 <bsmnt_bot> foo
00:09:25 <bsmntbombdood> ^^ ihope
00:09:27 <ihope> Gasp!
00:09:37 <ihope> Wonderful.
00:09:43 <CakeProphet> I'm going with interesting data types as my main theme for any sort of language-inventing
00:09:48 <CakeProphet> at the moment.
00:10:09 <bsmntbombdood> ~exec self.esoteric("asdf")
00:10:18 <bsmntbombdood> gasp
00:10:32 <CakeProphet> and with some new ways to treat procedures as data.
00:10:38 * bsmntbombdood wonders how to implement flood protection
00:10:40 <CakeProphet> like the "ring" concept.
00:10:42 <ihope> You oughta save at least some state, bsmnt.
00:10:50 <ihope> bombdood.
00:12:12 * CakeProphet remember his first encounter with programming.
00:12:42 <CakeProphet> pure imperitive... global-variables-for-state-and-conditional-mechanisms hacking
00:12:59 <CakeProphet> it was like building some weird ass clock..
00:13:27 <bsmntbombdood> ihope: like what?
00:13:30 <bsmntbombdood> ~quit
00:13:31 -!- bsmnt_bot has quit.
00:13:33 -!- bsmnt_bot has joined.
00:13:41 <bsmntbombdood> ~exec print >> sys.stdout, sys
00:13:42 <bsmnt_bot> <module 'sys' (built-in)>
00:13:46 <ihope> ~exec new_bot = IRCbot({"HOST": "blue", "PORT": 6667, "NICK": "AlsoBot", "IDENT": "bsmnt", "REALNAME": "not applicable", "CHAN": "#esoteric", "VERBOSE": True}); new_bot.listen()
00:13:48 <bsmntbombdood> ~exec print >> sys.stdout, "a" * 400
00:13:57 <bsmnt_bot> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
00:13:58 <ihope> bsmntbombdood: well, you could have the thing not actually disappear when it disconnects.
00:14:01 <bsmnt_bot> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
00:14:07 <ihope> Hmm.
00:14:08 <oklofok> bsmntbombdood, make a wrapper class for whatever you print in and make it keep track of when smth was said last...
00:14:21 <ihope> ~exec new_bot = IRCbot({"HOST": "irc.freenode.net", "PORT": 6667, "NICK": "AlsoBot", "IDENT": "bsmnt", "REALNAME": "not applicable", "CHAN": "#esoteric", "VERBOSE": True}); new_bot.listen()
00:14:37 <ihope> Huh
00:14:53 <bsmntbombdood> now IRCFileWrapper splits it up into 300 byte chunks
00:15:00 <ihope> ~exec new_bot = IRCbot({"HOST": "85.188.1.26", "PORT": 6667, "NICK": "AlsoBot", "IDENT": "bsmnt", "REALNAME": "not applicable", "CHAN": "#esoteric", "VERBOSE": True}); new_bot.listen()
00:15:03 -!- AlsoBot has joined.
00:15:04 <bsmntbombdood> ihope: I haven't gotten dns working inside the chroot
00:15:06 <bsmntbombdood> :)
00:15:08 <ihope> Wonderful.
00:15:14 <ihope> bsmntbombdood: ah.
00:15:26 <ihope> So, there's a, uh... hmm.
00:15:36 <ihope> ~raw "PRIVMSG #esoteric :Foo"
00:15:52 <ihope> ~exec self.raw("PRIVMSG #esoteric :Foo")
00:15:52 <AlsoBot> Foo
00:15:52 <bsmnt_bot> Foo
00:15:53 <bsmntbombdood> ~raw PRIVMSG #esoteric :foo
00:15:54 <AlsoBot> foo
00:15:54 <bsmnt_bot> foo
00:15:58 <ihope> Yay.
00:15:59 <bsmntbombdood> huh
00:16:01 <bsmntbombdood> *heh
00:16:22 <bsmntbombdood> ~exec print >> sys.stdout, new_bot
00:16:26 <bsmntbombdood> argh
00:16:44 <ihope> ~exec new_bot.COMMAND_CHAR = r"@"
00:16:51 <ihope> @raw PRIVMSG #esoteric :Foo
00:16:55 <bsmntbombdood> no
00:17:15 <bsmntbombdood> you borked it
00:17:19 <ihope> I did?
00:17:23 <ihope> That's nice.
00:17:27 <ihope> ~quit
00:17:35 <ihope> Uh, yeah.
00:17:39 <bsmntbombdood> there's no references to new_bot
00:17:43 <ihope> ~exec self.disconnect()
00:17:48 <bsmntbombdood> ~quit
00:17:48 -!- AlsoBot has quit (Remote closed the connection).
00:17:48 -!- bsmnt_bot has quit (Client Quit).
00:17:51 -!- bsmnt_bot has joined.
00:17:52 <ihope> I can't figure this out, can I?
00:18:13 <bsmntbombdood> ~exec self.new_bot = IRCbot({"HOST": "85.188.1.26", "PORT": 6667, "NICK": "AlsoBot", "IDENT": "bsmnt", "REALNAME": "not applicable", "CHAN": "#esoteric", "VERBOSE": True}); self.new_bot.listen()
00:18:17 <bsmntbombdood> there
00:18:20 -!- AlsoBot has joined.
00:18:25 <ihope> Ah, better, yes.
00:18:34 <ihope> ~exec self.new_bot.COMMAND_CHAR = r"@"
00:18:41 <ihope> @raw PRIVMSG #esoteric :Foo
00:18:43 <bsmntbombdood> won't work
00:18:47 <ihope> I see.
00:19:07 <bsmntbombdood> self.COMMAND_CHAR only matters during __init__
00:19:13 <ihope> Oh.
00:19:43 <ihope> That gives me an idea.
00:19:54 <ihope> ~exec self.disconnect("")
00:19:55 -!- bsmnt_bot has quit (Client Quit).
00:19:55 -!- AlsoBot has quit (Client Quit).
00:19:56 <bsmntbombdood> ~exec print >> sys.stdout, self.COMMAND_CHAR
00:19:57 -!- bsmnt_bot has joined.
00:20:02 <bsmntbombdood> ~exec print >> sys.stdout, self.COMMAND_CHAR
00:20:02 <bsmnt_bot> ~
00:20:16 <ihope> ~exec self.__init__(args)
00:20:26 <bsmntbombdood> whoa
00:20:27 -!- bsmnt_bot has quit (Remote closed the connection).
00:20:28 <ihope> ~raw PRIVMSG #esoteric :Foo
00:20:29 -!- bsmnt_bot has joined.
00:20:32 <bsmntbombdood> BUGGAGE
00:20:33 <ihope> Uh, hmm.
00:20:38 <ihope> Did you kill it?
00:20:41 <bsmntbombdood> no
00:20:54 <ihope> I'll have to do it faster, then :-P
00:20:55 <bsmntbombdood> we got some weird exception on the real stderr
00:21:04 <ihope> ~exec self.__init__(args)
00:21:05 <ihope> ~raw PRIVMSG #esoteric :Foo
00:21:06 -!- bsmnt_bot has quit (Remote closed the connection).
00:21:08 -!- bsmnt_bot has joined.
00:21:11 <ihope> Clearly not working.
00:21:31 <CakeProphet> what are you trying to do?
00:21:35 <bsmntbombdood> you can't call __init__ on a class that's already inited
00:21:43 <CakeProphet> you can... it's just..
00:21:47 <bsmntbombdood> without breakage
00:21:49 <CakeProphet> not something you'd usually want to do.
00:22:14 <bsmntbombdood> ~exec sys.stdout(self.__init__)
00:22:15 <bsmnt_bot> <bound method IRCbot.__init__ of <__main__.IRCbot instance at 0xb7c7942c>>
00:22:39 <ihope> ~exec IRCbot.__init__
00:22:48 <ihope> ...Right.
00:22:49 <ihope> ~exec IRCbot.__init__()
00:23:03 <CakeProphet> why are you calling init anyways?
00:23:03 <ihope> Fun.
00:23:05 <bsmntbombdood> ~exec IRCbot.__init__(self, args)
00:23:08 <ihope> Oh, because.
00:23:09 -!- bsmnt_bot has quit (Remote closed the connection).
00:23:11 -!- bsmnt_bot has joined.
00:23:17 <bsmntbombdood> ValueError: list.remove(x): x not in list
00:23:19 <bsmntbombdood> ????
00:23:23 <ihope> ~exec IRCbot.__init__(args, self)
00:23:37 <ihope> ~exec IRCbot.__init__(self, self)
00:23:47 <CakeProphet> self probably isn't defined.
00:23:53 <bsmntbombdood> it is
00:24:07 <ihope> ~exec def IRCbot.__getitem__: return 3
00:24:08 <bsmntbombdood> ~exec sys.stdout(self)
00:24:11 <CakeProphet> oh... well then that just does the same thing as   self.__init__()
00:24:12 <bsmnt_bot> <__main__.IRCbot instance at 0xb7c5a42c>
00:24:14 <ihope> ~exec IRCbot.__init__(self, self)
00:24:23 <CakeProphet> ihope,   Can't define methods like that.
00:24:24 <ihope> Erm, wait...
00:24:30 <bsmntbombdood> wtf are you doing
00:24:40 <ihope> bsmntbombdood: playing?
00:24:45 <CakeProphet> def <identifier>
00:24:54 <CakeProphet> IRCbot.__getitem__  is an expression.
00:24:55 <bsmntbombdood> ihope: ...continue
00:25:05 <ihope> CakeProphet: I see.
00:25:12 <CakeProphet> using the . operator... so it's not a valid "identifier"... plus it's just plain weird.  :P
00:25:25 <ihope> ~exec IRCbot = 3
00:25:28 <bsmntbombdood> It would be nice if python could do that like ruby
00:25:31 <CakeProphet> def myFunc(blah, blah): blah blah blah
00:25:37 <ihope> ~raw PRIVMSG #esoteric :Foo
00:25:41 <CakeProphet> IRCbot.__getitem__ = myFunc
00:25:44 <ihope> Did I break it?
00:25:50 <bsmntbombdood> not yet
00:26:05 <bsmntbombdood> you can't make any more IRCbot s, though
00:26:06 <ihope> ~exec self.raw("PRIVMSG #esoteric :Foo")
00:26:06 <bsmnt_bot> Foo
00:26:11 <ihope> Hmm.
00:26:21 <CakeProphet> bsmntbombdood,  it doesn't... because that's not consistent with pretty much anything else.... and it's kind of tacky.
00:26:22 <bsmntbombdood> ~exec self = 3
00:26:27 <ihope> Woot!
00:26:29 <bsmntbombdood> now it's broken
00:26:33 <ihope> ~exec self.raw("PRIVMSG #esoteric :Foo")
00:26:33 <bsmntbombdood> I think
00:26:34 <bsmnt_bot> Foo
00:26:36 <bsmntbombdood> or no
00:26:37 <bsmntbombdood> t
00:26:47 <bsmntbombdood> ~exec sys.stdout(self)
00:26:47 <CakeProphet> ~exec del IRCbot
00:26:47 <bsmnt_bot> <__main__.IRCbot instance at 0xb7c5a42c>
00:26:52 <bsmntbombdood> weird
00:26:59 <ihope> ~exec self.disconnect("pero ya eres todo un hombre pa la guerra y pa matar")
00:26:59 -!- bsmnt_bot has quit (Client Quit).
00:27:02 -!- bsmnt_bot has joined.
00:27:05 <ihope> Yay!... no.
00:27:12 <bsmntbombdood> oh right, self is passed by value
00:27:17 <CakeProphet> bsmntbombdood,  how does the bot handle the scope of subprocesses?
00:27:31 <CakeProphet> if you just make the dict on the fly in the exec statement... it won't preserve the dict beyond the exec.
00:27:45 <bsmntbombdood> in the (globals(), locals()) of IRCbot.do_exec
00:28:17 <oerjan> assign it to an attribute of the bot object
00:28:27 * CakeProphet would make a private dictionary for subprocesses... and then update the main one or something when the subprocess is done executing.
00:28:32 <CakeProphet> to prevent weird race conditions and stuff.
00:28:47 <ihope> ~exec self.self = 3
00:28:57 <ihope> Did it work or something?... no, probably didn't.
00:29:03 <ihope> ~raw PRIVMSG #esoteric :Foo
00:29:12 <bsmntbombdood> CakeProphet: having one sepperate global dictionary for all ~execs might be good
00:29:14 <ihope> Well, ~raw isn't working, at least.
00:29:25 <ihope> ~exec self.raw("PRIVMSG #esoteric :Foo")
00:29:26 <bsmnt_bot> Foo
00:29:30 <bsmntbombdood> ihope: you don't match the ~raw regex
00:29:36 <ihope> Oh.
00:29:39 <bsmntbombdood> ~exec die
00:29:42 <CakeProphet> if ~exec re-assigns self each time... that's why.
00:29:47 <ihope> ~exec self.disconnect = 3
00:29:58 <bsmntbombdood> ~quit
00:30:02 <ihope> ~exec self.do_kill = 3
00:30:14 <ihope> ~exec self.do_exec = 3; self.exec = 3
00:30:17 <CakeProphet> it probably does...
00:30:28 <bsmntbombdood> now it's broken
00:30:34 <CakeProphet> considering do_exec is called with do_exec.im_self passed to the first parameter.
00:30:34 <bsmntbombdood> ~exec foo
00:30:43 <CakeProphet> each time it's called.
00:30:56 <CakeProphet> so reassigning self does little to nothing but alter that function calls local scope.
00:30:58 <bsmntbombdood> huh?
00:31:00 <ihope> ~exec self.exec_execer = 3
00:31:07 <bsmntbombdood> ~exec foo
00:31:12 <bsmntbombdood> there you go
00:31:25 <ihope> Yay!
00:31:34 <bsmntbombdood> now it's broken
00:31:39 <ihope> ~exec self.raw("foo")
00:31:44 <ihope> Yep.
00:31:57 <CakeProphet> !exec sys.stdout.write(dir(locals()))
00:31:58 <bsmntbombdood> only way to kill it now is ^C on the console
00:32:01 <EgoBot> Huh?
00:32:09 <CakeProphet> ~exec sys.stdout.write(dir(locals()))
00:32:13 -!- bsmnt_bot has quit (Remote closed the connection).
00:32:16 -!- bsmnt_bot has joined.
00:32:19 <CakeProphet> ~exec sys.stdout.write(dir(locals()))
00:32:20 <bsmnt_bot> ['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__seti
00:32:20 <bsmnt_bot> tem__', '__str__', 'clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', 'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
00:32:31 <bsmntbombdood> you don't want dir
00:32:32 <CakeProphet> sweet... plenty of stuff to tinker with.
00:32:32 <ihope> I'm guessing what CakeProphet did didn't kill it.
00:32:55 <CakeProphet> oh... erm.. yeah
00:32:57 <ihope> How do I list all the files in /? >:-)
00:33:04 <CakeProphet> ~exec sys.stdout.write(locals())
00:33:05 <bsmnt_bot> {'message': ':CakeProphet!n=CakeProp@h146.231.213.151.ip.alltel.net PRIVMSG #esoteric :~exec sys.stdout.write(locals())', 'r': <_sre.SRE_Match object at 0xb7c95b18>, 'command': 'sys.stdout.write(locals())', 'self': <__main__.IRCbot instance at 0xb7c3542c>}
00:33:05 <bsmntbombdood> os.listdir("/")
00:33:23 <CakeProphet> hmmm...
00:33:36 <ihope> ~exec sys.stdout.write(os.listdir("/"))
00:33:36 <bsmnt_bot> ['bin', 'bot', 'etc', 'lib', 'usr']
00:33:39 <CakeProphet> so wait... I have access to the source code of my exec in the exec itself?
00:33:40 <ihope> Hmm.
00:33:44 <ihope> ~exec sys.stdout.write(os.listdir("/bot"))
00:33:45 <bsmnt_bot> ['betterbot.py', 'start.sh', 'better.sh', 'ircbot.py']
00:33:49 <ihope> ~exec sys.stdout.write(os.listdir("/bin"))
00:33:50 <bsmnt_bot> ['bash']
00:33:51 <bsmntbombdood> CakeProphet: yeah
00:33:58 <ihope> ~exec sys.stdout.write(os.listdir("/etc"))
00:33:59 <bsmnt_bot> ['hosts', 'passwd', 'resolv.conf']
00:34:05 <CakeProphet> ~exec sys.stdout.write(command)
00:34:06 <bsmnt_bot> sys.stdout.write(command)
00:34:09 <CakeProphet> quine
00:34:14 <ihope> Ooh! Let's change... wait, is passwd... what is it?
00:34:23 <ihope> Oh well.
00:34:30 <ihope> ~exec sys.stdout.write(os.listdir("/lib"))
00:34:30 <bsmnt_bot> ['libm.so.6', 'libreadline.so.5', 'libdl-2.4.so', 'libresolv.so.2', 'libutil.so.1', 'libncurses.so.5', 'libcrypt.so.1', 'ld-linux.so.2', 'libdl.so.2', 'libpthread.so.0', 'libpam_misc.so.0', 'libpam.so.0', 'libc.so.6']
00:34:33 <bsmntbombdood> ~exec sys.stdout(open("/etc/passwd").read())
00:34:34 <bsmnt_bot> root:x:0:0:root::/bin/bash
00:34:34 <bsmnt_bot> bsmnt_bot:x:1343:1343:::/bin/bash
00:34:36 <CakeProphet> ~exec sys.stdout.write(dir(self))
00:34:36 <bsmnt_bot> ['COMMAND_CHAR', 'THREADING', '__doc__', '__init__', '__module__', 'chan', 'commands_running', 'commands_running_lock', 'connect', 'connected', 'disconnect', 'do_callbacks', 'do_ctcp', 'do_exec', 'do_kill', 'do_ps', 'do_quit', 'do_raw', 'errorchan', 'exec_execer', 'get_message', 'host', 'ident', 'li
00:34:37 <bsmnt_bot> sten', 'message_re', 'nick', 'pong', 'port', 'print_callbacks', 'raw', 'raw_regex_queue', 'readbuffer', 'realname', 'register_raw', 'socket', 'sockfile', 'verbose']
00:34:38 <ihope> ~exec sys.stdout.write(os.listdir("/usr"))
00:34:38 <bsmnt_bot> ['bin', 'lib', 'include']
00:34:56 <ihope> All so very confusing, I'm sure.
00:34:59 <ihope> ~exec sys.stdout.write(os.listdir("~"))
00:35:17 <ihope> ~exec sys.stdout.write(os.exec("/bin/bash"))
00:35:30 <ihope> I see, maybe.
00:35:42 <bsmntbombdood> If you want a bash prompt, you are gonna have to wrap in in some sockets
00:35:45 <ihope> Did that say syntax error?
00:35:53 <bsmntbombdood> yeah, exec is a statement
00:36:20 <CakeProphet> ~exec sys.stdout.write(self.__doc__)
00:36:20 <bsmnt_bot> None
00:36:25 <bsmntbombdood> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
00:36:30 <CakeProphet> Lousy documentation :P
00:36:31 <bsmntbombdood> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
00:36:34 <bsmntbombdood> yep
00:37:02 <CakeProphet> ~exec sys.stdout.write(self.socket)
00:37:02 <bsmnt_bot> <socket._socketobject object at 0xb7c3332c>
00:37:16 <oklofok> i'd be ready now if i knew wtf Tory is
00:37:21 <oklofok> but i can't find it anywhere
00:37:23 <CakeProphet> ~exec sys.stdout.write(self.chan)
00:37:23 <bsmnt_bot> #esoteric
00:37:39 <bsmntbombdood> self.chan is kinda useless
00:37:44 <CakeProphet> ~exec sys.stdout.write(self.THREADING)
00:37:44 <bsmnt_bot> True
00:37:48 <oklofok> ~exec sys.stdout.write(self.chan**2)
00:38:03 <oklofok> does someone know it?
00:38:03 <CakeProphet> ~exec sys.stdout.write(dir(self.__class__))
00:38:04 <bsmnt_bot> ['__doc__', '__init__', '__module__', 'connect', 'disconnect', 'do_callbacks', 'do_ctcp', 'do_exec', 'do_kill', 'do_ps', 'do_quit', 'do_raw', 'exec_execer', 'get_message', 'listen', 'pong', 'print_callbacks', 'raw', 'register_raw']
00:38:23 <oklofok> ~exec sys.stdout.write(self.chan*2)
00:38:23 <bsmnt_bot> #esoteric#esoteric
00:38:34 <oklofok> ~exec sys.stdout.write(self.chan-"#")
00:38:46 <bsmntbombdood> oklofok: your errors go to #bsmnt_bot_errors 
00:38:57 <bsmntbombdood> < bsmnt_bot> TypeError: unsupported operand type(s) for -: 'str' and 'str'
00:39:07 <CakeProphet> ~exec sys.stdout.write(dir(sys))
00:39:07 <bsmnt_bot> ['_SysWrapper__sys', '__doc__', '__getattr__', '__init__', '__module__', 'stderr', 'stdout']
00:39:26 <CakeProphet> ~exec sys.stdout.write(dir(sys.stdout))
00:39:27 <bsmnt_bot> ['__call__', '__doc__', '__init__', '__module__', 'channel', 'raw', 'write']
00:39:52 <CakeProphet> ~exec sys.stdout.write(dir(sys.__sys))
00:40:08 <bsmntbombdood> <bsmnt_bot> AttributeError: 'module' object has no attribute '__sys'
00:40:14 <oerjan> oklofok: http://web.archive.org/web/20051218132142/http://chimpen.com/tory/
00:41:19 <bsmntbombdood> ~exec raise "foo"
00:41:26 <CakeProphet> ~exec sys.stdout.write(globals())
00:41:26 <bsmnt_bot> {'IRCbot': <class __main__.IRCbot at 0xb7c3323c>, 'args': {'IDENT': 'bsmnt', 'REALNAME': 'bsmntbombdood bot', 'CHAN': '#esoteric', 'NICK': 'bsmnt_bot', 'HOST': '85.188.1.26', 'PORT': 6667, 'VERBOSE': True}, '__builtins__': <module '__builtin__' (built-in)>, '__file__': '/bot/ircbot.py', 'inspect': <
00:41:26 <bsmnt_bot> module 'inspect' from '/usr/lib/python2.4/inspect.pyc'>, 'IRCFileWrapper': <class __main__.IRCFileWrapper at 0xb7c3326c>, 'sys': <module 'sys' (built-in)>, 'thread_info': <thread._local object at 0xb7ccb7e8>, '__name__': '__main__', 'exec_global_tracer': <function exec_global_tracer at 0xb7c31cdc>, 
00:41:28 <bsmnt_bot> 'copy': <module 'copy' from '/usr/lib/python2.4/copy.pyc'>, 'socket': <module 'socket' from '/usr/lib/python2.4/socket.pyc'>, 'thread': <module 'thread' (built-in)>, 'traceback': <module 'traceback' from '/usr/lib/python2.4/traceback.pyc'>, 'os': <module 'os' from '/usr/lib/python2.4/os.pyc'>, 'ppri
00:41:31 <CakeProphet> ...
00:41:32 <bsmnt_bot> nt': <module 'pprint' from '/usr/lib/python2.4/pprint.pyc'>, 'bot': <__main__.IRCbot instance at 0xb7c3542c>, 're': <module 're' from '/usr/lib/python2.4/re.pyc'>, 'time': <module 'time' from '/usr/lib/python2.4/lib-dynload/time.so'>, 'threading': <module 'threading' from '/usr/lib/python2.4/threadi
00:41:36 <bsmnt_bot> ng.pyc'>, 'SysWrapper': <class __main__.SysWrapper at 0xb7c3329c>, 'exec_local_tracer': <function exec_local_tracer at 0xb7c3d454>, '__doc__': None}
00:41:45 <bsmntbombdood> yay, no excess flood
00:42:03 * CakeProphet loves introspection.
00:42:58 <CakeProphet> now it just needs random quotes... and support for persistence.
00:43:10 <bsmntbombdood> CakeProphet: code it
00:43:42 <bsmntbombdood> http://bsmntbombdood.mooo.com/chroot_ircbot.py
00:43:45 <CakeProphet> ~exec globals()["random"] = __import__("random")
00:44:38 <CakeProphet> ~exec self.__class__.dice = lambda : random.randint(1,6)
00:44:59 <CakeProphet> ~exec sys.stdout.write(self.dice()
00:45:02 <CakeProphet> ~exec sys.stdout.write(self.dice())
00:45:21 <bsmntbombdood> CakeProphet: #bsmnt_bot_errors 
00:45:30 <CakeProphet> ~exec globals()["random"] = __import__("random")
00:45:36 <CakeProphet> ~exec self.__class__.dice = lambda : random.randint(1,6)
00:45:45 <bsmntbombdood> ~exec sys.stdout(random)
00:45:54 <bsmntbombdood> odd
00:46:20 <bsmntbombdood> oh, right
00:46:22 <bsmntbombdood> ~quit
00:46:22 -!- bsmnt_bot has quit.
00:46:25 -!- bsmnt_bot has joined.
00:46:30 <bsmntbombdood> ~exec globals()["random"] = __import__("random")
00:46:34 <bsmntbombdood> ~exec sys.stdout(random)
00:46:35 <bsmnt_bot> <module 'random' from '/usr/lib/python2.4/random.pyc'>
00:47:06 <bsmntbombdood> there
00:47:13 <bsmntbombdood> I was making a copy.copy for some reason
00:47:50 <CakeProphet> you wanted to make sure exec didn't effect globals?
00:47:58 <CakeProphet> by the way... dictionaries have a copy method.
00:48:06 <CakeProphet> ..so... you didn't really need to use the copy module.
00:48:10 <bsmntbombdood> ok
00:48:11 <CakeProphet> ~exec globals()["random"] = __import__("random")
00:48:16 <CakeProphet> ~exec self.__class__.dice = lambda : random.randint(1,6)
00:48:21 <CakeProphet> ~exec sys.stdout.write(self.dice())
00:48:33 <bsmntbombdood> self.__class__.dice?
00:48:43 <CakeProphet> it would have it simply from inheritance.
00:48:49 <bsmntbombdood> That would force you to reinstanciate the bot
00:48:53 <CakeProphet> nope.
00:48:57 <CakeProphet> ~exec globals()["random"] = __import__("random")
00:49:05 <CakeProphet> ~exec self.__class__.dice = lambda self : random.randint(1,6)
00:49:10 <CakeProphet> ~exec sys.stdout.write(self.dice())
00:49:10 <bsmnt_bot> 5
00:49:33 <CakeProphet> method resolution is dynamic... if the class has it... the instance gets it to.
00:49:45 <CakeProphet> you would only need to re-init the bot if you did an entire class statement.
00:49:47 <bsmntbombdood> orly?
00:49:57 <CakeProphet> as then you would be creating an entirely new class... instead of modifying the old one...
00:49:59 <CakeProphet> rly
00:50:37 <CakeProphet> heh... meta-programming is scary shit...
00:50:46 <bsmntbombdood> what's that?
00:50:49 <CakeProphet> it's probably the part of Python I'm most familiar with.
00:50:55 <CakeProphet> programming things that program.
00:51:16 <CakeProphet> basically all of that was... sorta kinda... basic "meta-programming"
00:51:41 <CakeProphet> I created a program that re-programmed your class.
00:51:47 <CakeProphet> basic example... but that's the core of it.
00:52:28 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~dice", lambda x,y: self.raw("PRIVMSG %s :%s" % (y.group(1), random.randint(1,6)))
00:52:37 <CakeProphet> ~dice
00:52:42 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~dice", lambda x,y: self.raw("PRIVMSG %s :%s" % (y.group(1), random.randint(1,6))))
00:52:46 <bsmntbombdood> ~dice
00:52:46 -!- bsmnt_bot has quit (Remote closed the connection).
00:52:48 -!- bsmnt_bot has joined.
00:52:53 <bsmntbombdood> argh
00:53:02 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~dice", lambda x,y: bot.raw("PRIVMSG %s :%s" % (y.group(1), random.randint(1,6))))
00:53:05 <bsmntbombdood> ~dice
00:53:06 -!- bsmnt_bot has quit (Remote closed the connection).
00:53:08 -!- bsmnt_bot has joined.
00:53:11 <CakeProphet> why group?
00:53:13 <bsmntbombdood> argh
00:53:16 <CakeProphet> there's nothing to group.
00:53:21 <bsmntbombdood> ~exec globals()["random"] = __import__("random")
00:53:23 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~dice", lambda x,y: bot.raw("PRIVMSG %s :%s" % (y.group(1), random.randint(1,6))))
00:53:26 <bsmntbombdood> CakeProphet: ?
00:53:29 <CakeProphet> oh.
00:53:31 <CakeProphet> nevermind,.
00:53:35 <bsmntbombdood> group is a regex match object method
00:53:40 <CakeProphet> yah yah
00:53:45 <bsmntbombdood> ~dice
00:53:45 <CakeProphet> it's the channel... nevermind.
00:53:45 <bsmnt_bot> 1
00:53:52 <bsmntbombdood> ~dice
00:53:52 <bsmnt_bot> 3
00:54:01 * CakeProphet has, funnily enough, a dice library.
00:54:26 <CakeProphet> with some weird callback stuff for constructing tabletop style dice functions.
00:54:41 <CakeProphet> that I made.
00:54:49 <bsmntbombdood> ok i have to go
00:55:03 * CakeProphet gets to work on that pickling stuff.
00:55:06 <CakeProphet> have fun.
00:55:54 <ihope> ~exec insert
00:56:01 <ihope> Hmm.
00:56:07 <oklofok> k made a new language instead of looking for Tory
00:56:14 <oklofok> and i'm sure mine is better too
00:56:30 <CakeProphet> hmm... you can't pickle functions though.... unless you save their source code.
00:56:49 <CakeProphet> but... I could go ultra-fancy and use some insane abuse of the pickle protcol to make it save functions.
00:56:50 <oerjan> oklofok: http://web.archive.org/web/20051218132142/http://chimpen.com/tory/
00:56:59 <CakeProphet> I've done it before.
00:57:08 <oklofok> oerjan, too late :(
00:57:18 <oerjan> Why? :)
01:00:55 <oklofok> i made my own brainfuck in it's place
01:00:59 <oklofok> to get to 50 
01:01:11 <oklofok> and mine has sence to it :)
01:01:41 <oklofok> made 3 languages today \o/
01:02:37 <oklofok> maybe i'll make 50 improvised languages tomorrow, sounds like a good use of time
01:04:32 -!- oklofok has changed nick to oklopol.
01:05:47 <CakeProphet> hmm... I should work on Stue some more.
01:06:09 <ihope> Stue?
01:06:13 <ihope> Is that like Thue at all?
01:06:21 <CakeProphet> Dunno.
01:06:25 * CakeProphet isn't familiar with Thue
01:06:33 <CakeProphet> Stue is a "stack of queues" language.
01:06:34 <CakeProphet> that I made.
01:06:45 <oerjan> It is extremely unlike Thue. :)
01:07:14 <oerjan> The only thing in common is that they may be considered Norwegian words.
01:07:23 <CakeProphet> Hello World   -->    !m?spam?"Hello, World!\n"^
01:07:45 <CakeProphet> with a semicolon at the end
01:07:54 <oklopol> !m?spam?"Hello, World!\n"^;
01:07:57 <EgoBot> Huh?
01:08:36 <CakeProphet> print 2 + 2    -->   !m22+^)?spam?^;
01:08:38 <oklopol> so... how do i sleep now that i slept 5 hours during the day and drank a litre of coke just now?
01:09:11 <CakeProphet> I wrote the entire specification on the esolang wiki... but then I forgot to save it.
01:09:16 <CakeProphet> and I'm entirely too lazy to type it out again.
01:09:19 <CakeProphet> in a way that makes sense.
01:09:51 <oklopol> i can't tell how it works from that :'(
01:10:29 <CakeProphet> yeah... it's a bit... 
01:10:48 <oklopol> that's always a good thing
01:10:56 <CakeProphet> ...
01:11:16 <oklopol> you use stact notation, spam is print, ^ has something to do with pushing?
01:11:19 <oklopol> *stack
01:11:28 <CakeProphet> kinda sorta
01:11:34 <oklopol> gooda
01:11:39 <oklopol> )?
01:11:46 <oklopol> sorry, ')'?
01:11:54 <CakeProphet> it appears stack-based... but then you'll notice the order in which you push things seems to change sporatically... 
01:12:21 <CakeProphet> everything is pushed except for commands...  and ^ is the call command :D
01:12:43 <oklopol> yeah, i figured that a second before you said that
01:12:49 <oklopol> but, doesn't help
01:13:01 <CakeProphet> it reads everything character by character... unless it's surrounded by ?'s or quotes.
01:13:47 <oklopol> okay, now it's pretty clear, but ) and !m
01:13:54 <oklopol> poh
01:13:55 <oklopol> oh
01:13:57 <oklopol> i know !m
01:14:09 <CakeProphet> quoted stuff always being considered strings... and ?'s just denoting a multicharacter version of anything you would push as a single character.
01:14:29 <CakeProphet> By default, if the interpreter has no clue what the hell you're trying to push... it just becomes a string.
01:14:52 <CakeProphet> !m is the beginning of a subroutine defintion. :D
01:14:54 <EgoBot> Huh?
01:15:03 <CakeProphet> the main one... to be exact.
01:15:16 <oklopol> yeah, i can exec !m22+^)"spam"^; as well?
01:15:28 <CakeProphet> hmmm...
01:15:31 <oklopol> yeah, i figured the !,
01:15:32 <CakeProphet> can't actually remember.
01:15:33 <oklopol> !m
01:15:36 <EgoBot> Huh?
01:15:48 <oklopol> okay, doesn't matter, the ) anyway, what is it?
01:15:50 <CakeProphet> I indeded for that to be possible... but I forgot if it actualyl does it.
01:15:57 <oklopol> hehe :D
01:16:03 <CakeProphet> That... pushes a new queue onto the stack.
01:16:09 <oklopol> okay
01:16:22 <oklopol> hmm... why?
01:16:27 <CakeProphet> ...oh wait..
01:16:35 <oklopol> would !m22+^?spam?^; work?
01:16:52 <CakeProphet> !m+22^)?spam?^;
01:16:54 <EgoBot> Huh?
01:16:56 <CakeProphet> nopw.
01:17:28 <CakeProphet> +22^?spam?^   wouldn't work because we're pushing values to a queue.
01:17:34 <oklopol> or is it !m?spam?+22^^; without the new queue?
01:17:38 <oklopol> eh
01:17:50 <oklopol> okay
01:18:01 <CakeProphet> the ^ would call +... which would add 2 and 2... and then it would call 4.
01:18:15 <CakeProphet> not knowing how the hell you can call a 4... it proceeds to explode.
01:19:02 <CakeProphet> it's a very very weird way to think...
01:19:09 <CakeProphet> totally unintuitive.
01:19:16 <oklopol> cool
01:19:41 <oklopol> the print, does it pop a queue and take values from there=?
01:19:50 <CakeProphet> the syntax will oscillate between being stack-like and queue-like depending on where you're at.
01:20:06 <CakeProphet> it pops the value off the top queue.
01:20:11 <CakeProphet> just one.
01:20:17 <oklopol> !m+22^)?spam?^; here you make 2 queues?
01:20:20 <EgoBot> Huh?
01:20:40 <CakeProphet> you would use % to call ?spam? on everything in the top queue  (% is the for-each command)
01:20:41 <CakeProphet> yeah.
01:21:12 <CakeProphet> when a queue is depeleted of all values... and something attempts to pop off another value... it junks that queue and pops one off the queue below it.
01:21:24 <oklopol> ah okay
01:21:28 <CakeProphet> which is why that ?spam? call works.
01:21:42 <oklopol> but, why can't the param be in the same queue?
01:21:53 <oklopol> like in the hello, world
01:22:00 <CakeProphet> because of the order of evaluation.  :D
01:22:11 <CakeProphet> you had to set up + 2 2  into the queue to call that correctly...
01:22:23 <CakeProphet> but... there's no way to fit in a ?spam? function -in front- of all of that...
01:22:52 <CakeProphet> you have to make a new queue... plop ?spam? in that queue... and do a call from there... making it look kinda stack-based.
01:23:05 <CakeProphet> but with the Hello, World!   it looks like prefix notation.  :D
01:23:06 <oklopol> ah okay, but here !m?spam?"Hello, World!\n" you first push the "spame", then the "hw", then because it's a FIFO, ^ reads the "spam", spam read "hw", right?
01:23:20 <CakeProphet> yup
01:23:42 <CakeProphet> I haven't cabbled much with multiple subroutines yet.
01:23:46 <CakeProphet> but they all share the same scope.
01:23:51 <CakeProphet> like most stack-based languages.
01:24:30 <CakeProphet> hmm... some o ther commands...
01:24:32 <oklopol> coroutines here too?
01:24:37 <CakeProphet> Nope.
01:24:45 <oklopol> yeah, wouldn't work that well
01:24:53 <oklopol> because of the stack nature
01:24:55 <CakeProphet> Not sure how it would work... since there's nothing you could return.
01:25:08 <oklopol> you could return normally
01:25:12 <oklopol> by pushing
01:25:15 <CakeProphet> they're "procedures" more than they are "subroutines".
01:25:18 <oklopol> but there wouldn't be much use
01:25:31 <CakeProphet> in the world of Stue... I call them ops.
01:25:39 <CakeProphet> because inventing vocabulary words is fun.
01:25:49 <oklopol> yeah :)
01:25:57 <oklopol> i made a bf for networking
01:26:42 <CakeProphet> hmmm... . is the "pop an integer off the stack... and push the integer-th value of the queue onto the queue"  command.
01:27:11 <oklopol> and i made a 3D bf with the IP being a SPACESHIP (now that's REAL COOL, right?), then i made a lang called metafuck, where you can execute the memory with it's own nulled memory
01:27:13 <oklopol> yay!
01:27:31 <oklopol> is that a question?
01:27:43 <CakeProphet> no
01:27:47 <CakeProphet> the . is just hard to see
01:27:54 <CakeProphet> haha... that sounds awesome.
01:28:07 <oklopol> what?
01:28:11 <oklopol> / which?
01:28:12 <CakeProphet> @  is the same thing as  .    but at the stack level... pop an integer off the queue, and get the integer-th queue and push it to the top of the stack.
01:28:15 <CakeProphet> the spaceship BF
01:28:36 <oklopol> okay, i like the network-thingie best, but you don't know just how sick it is.
01:28:38 <oklopol> :)
01:28:52 <CakeProphet> @  and .  are the only ways I've found to do conditionals so far...   because the comparison operations all return either 1 or 0.
01:29:23 <CakeProphet> you can use the 1 or 0 to conditionally "flip" between the top two queue... or the top two values on the top queue.
01:29:48 <oklopol> yeah, or any two values
01:29:58 <oklopol> *queues or stack indexes
01:30:01 <oklopol> not values
01:30:10 <oklopol> *stack entrys, not indexes
01:30:24 <CakeProphet> hmm... other than that... there's some debugging command that just prints out the entire Stue...
01:30:32 <CakeProphet> can't remember what character it was.
01:30:36 * CakeProphet checks his interpreter.
01:31:10 <oklopol> queue number A on cond, B otherwise -> cond*(A-B)+B @
01:31:16 <oklopol> but, prefic
01:31:17 <oklopol> *x
01:31:42 <oklopol> +*?cond?-ABB@ right?
01:31:44 <CakeProphet> hmm...
01:31:58 <CakeProphet> ~ is the PRINTSTEW command... yup.
01:32:16 <oklopol> printstew?
01:32:26 <CakeProphet> and crap between # are comments (allowed inline)
01:32:32 <CakeProphet> the debugging command.
01:32:42 <CakeProphet> it literally just prints out the entire data structure as Python would see it.
01:33:01 <oklopol> okay
01:33:21 <oklopol> python has a lovely way to print tuples, lists etc
01:33:45 <CakeProphet> [blah, blah, (blah, blah, blah), blah]
01:33:53 <CakeProphet> How do other languages do it?
01:33:56 <CakeProphet> or can they do it at all?
01:34:14 <oerjan> Interestingly Haskell has the exact same syntax for lists and strings
01:34:19 <oerjan> i mean tuples
01:34:20 <oklopol> yeah
01:34:36 <oklopol> Haskell's is nice too but i don't know it that well
01:34:43 <CakeProphet> does Haskell have hash tables?
01:34:51 <oklopol> lists look the same too, or?
01:35:12 <oerjan> Not standard, no.  They are difficult to mix with its pure functionality.
01:35:24 <CakeProphet> heh... yeah
01:35:28 <CakeProphet> a language without variables...
01:35:33 <oerjan> The Data.Map library uses binary trees.
01:35:36 <CakeProphet> makes it difficult to use a hash table effectively.
01:36:21 <oklopol> i wanna learn Haskell better :\
01:36:30 <oklopol> it's like the coolest language :D
01:36:49 <CakeProphet> Lua looks pretty interesting.
01:37:12 <CakeProphet> Like Lisp with hash tables instead of lists.
01:37:22 <CakeProphet> and Python-esque syntax.
01:41:18 <oerjan> BTW there are a couple of libraries providing variables in Haskell.  All encapsulated in the infamous monads, of course.
01:42:32 <Sukoshi> Lisp always has hash tables.
01:43:05 <Sukoshi> Both Scheme and CL.
01:43:07 <CakeProphet> no no I meant.
01:43:17 <CakeProphet> what Lisp does with lists... Lua does with hash tables.
01:43:25 <Sukoshi> Eww.
01:43:30 <CakeProphet> :P
01:44:00 <Sukoshi> Hash tables are much more costly/processor-unfriendly than a linked list is unless you have many data entries that need to be specifically retreived.
01:44:33 <oerjan> That actually is pretty cool.  Just too bad it's so much less efficient to use dictionaries for everything.
01:44:52 <Sukoshi> CakeProphet: You do know how C implements hash tables right?
01:45:02 <CakeProphet> Nope
01:45:14 <Sukoshi> Go and learn about what a hash table really is.
01:45:25 <CakeProphet> I only vageuly know how it works.
01:45:31 <oerjan> An array of pointers to linked lists, I believe.
01:45:38 <Sukoshi> No no.
01:45:42 <CakeProphet> I know it associates the key to a "hash value"... but -how- it does all this linkage is beyond me.
01:45:47 <Sukoshi> CakeProphet: Math.
01:46:00 <Sukoshi> Using a set of bit-transforms upon the hash value to produce an array index.
01:46:07 <oerjan> + a bit extra info.
01:46:23 <oerjan> or possibly pointers to binary trees, I guess.
01:46:45 <Sukoshi> Of course, there's always a chance for a misrefer, which is something you're going to suffer unless you implement a ``perfect'' hash table, whose math is more involved than I'm willing to casually talk about.
01:46:49 <CakeProphet> dictionaries are fairly fast for what they do.  (lookup values paired to a key)
01:47:23 <Sukoshi> If only my NN which does 2 * 10^6 iterations of lookups and loops could say the same thing :)
01:47:59 <CakeProphet> pfft... anything would start to get stressed out under those numbers.
01:48:01 <oerjan> I don't see how a collision-free hash table is mathematically possible.
01:48:10 <Sukoshi> oerjan: It's ... complicated.
01:48:17 <Sukoshi> Read Knuth's articles on the ``perfect'' hash table.
01:48:23 <CakeProphet> hmmm... I've never actually had a misrefer occur...
01:48:27 -!- pikhq has joined.
01:48:27 <CakeProphet> seems fairly consistent every time.
01:48:48 <Sukoshi> Those numbers perform fairly well under linked lists though CakeProphet.
01:49:20 <Sukoshi> Code isn't always about playing with 80's network protocols in a Y2K world, remember that :P
01:49:56 * CakeProphet plays entirely too much with telnet.
01:50:07 <Sukoshi> (I follow Cohen's philosophy -- hypothesize the highest load, the most iterations, the most memory lookups, the most of any stress. Make sure your program withstands that, and then it is truly a program.)
01:50:13 <CakeProphet> it's pretty annoying to work with.  >.<
01:51:07 <CakeProphet> My philosophy is:   make it do something... then bang it with a hammer until it can do it with 100000000000 times more shit.
01:51:27 <pikhq> My philosophy is simple:
01:51:38 <pikhq> Get the program to work, and then get it to work *well*.
01:51:42 <CakeProphet> oh..
01:51:50 <CakeProphet> I thought you just had a blank program.
01:51:55 <CakeProphet> er..
01:51:57 <CakeProphet> philosophy.
01:52:16 * CakeProphet dabbles with 60's network protocols... not 80's.
01:52:16 <Sukoshi> Dunno. It's very rare that I can't get something to work in a very wasteful way.
01:52:37 <Sukoshi> Let's allocate 100,000 element adjustable arrays! \o/
01:52:59 <CakeProphet> I use most of my own "protocols" actually... which is supposed to be bad for you, but oh well.
01:53:12 <CakeProphet> it's hard to use a network protocol that only you know... at any rate.  :P
01:53:13 <pikhq> Of course, inevitably for me the issue with "get the program to work first" is just that it turns out to be illegible as hell, not that it's really wasteful.
01:53:36 <Sukoshi> My legibiliity is alright.
01:53:49 <Sukoshi> I admit, my TRAIN generic method here needs some more comments, but, meh.
01:53:55 <CakeProphet> I've been told I make Python look like Perl...
01:53:57 <Sukoshi> I'll comment it before I submit it to the judges :P
01:54:24 <pikhq> Pre-rewrite BFM was a bastion of illegibility.
01:54:48 <pikhq> Optimization and two targets combined in *one pass of compilation*.
01:55:11 <Sukoshi> Meh.
02:32:02 <bsmntbombdood> CakeProphet: You might be able to pickle the code object
02:33:32 <bsmntbombdood> ihope: insert?
02:35:53 <bsmntbombdood> CakeProphet: It would be easy to just store the source code of all ~execs
02:37:44 <bsmntbombdood> or inspect.getsource
02:38:55 <bsmntbombdood> ~exec sys.stdout(__import__("inspect").getsource(self.print_callbacks))
02:38:55 <bsmnt_bot>     def print_callbacks(self):
02:38:56 <bsmnt_bot>         pprint.pprint(
02:38:56 <bsmnt_bot>             [(i[0].pattern, i[1].__name__) for i in self.raw_regex_queue])
02:38:58 <bsmntbombdood> neat
02:39:55 <bsmntbombdood> ~exec self.f = lambda x : x+1
02:40:02 <bsmntbombdood> ~exec sys.stdout(__import__("inspect").getsource(self.f))
02:40:17 <bsmntbombdood> damn
02:40:36 <bsmntbombdood> I guess that only works with code from a file
02:42:53 <bsmntbombdood> ~exec globals()["pprint"] = __import__("pprint")
02:43:06 <bsmntbombdood> ~exec pprint.pprint((1,2,3))
02:43:13 <bsmntbombdood> argh
02:45:04 <bsmntbombdood> ~exec sys.stdout( [i[1] for i in inspect.getmembers(self.f) if i[0] == "func_code"][0] )
02:45:04 <bsmnt_bot> <code object <lambda> at 0xb7cc51e0, file "<string>", line 1>
02:45:07 <bsmntbombdood> neat
02:45:37 <bsmntbombdood> ~exec self.the_code = [i[1] for i in inspect.getmembers(self.f) if i[0] == "func_code"][0]
02:45:51 <bsmntbombdood> ~exec sys.stdout(self.the_code.co_code)
02:45:51 <bsmnt_bot> |
02:45:54 <bsmntbombdood> hmp
02:46:02 <bsmntbombdood> well there you go
02:46:10 <bsmntbombdood> pickle the code object
02:47:08 <bsmntbombdood> ~exec exec self.the_code
02:47:18 <bsmntbombdood> ~exec exec self.the_code(1)
02:47:32 <bsmntbombdood> ~exec exec self.the_code in {"x":1}
02:47:57 <bsmntbombdood> ~exec exec self.the_code.co_code
02:50:59 <bsmntbombdood> I think the best bet is to store the string of source
02:53:30 <bsmntbombdood> ah ha!
02:53:40 <bsmntbombdood> ~exec sys.stdout(the_code)
02:53:45 <bsmntbombdood> ~exec sys.stdout(self.the_code)
02:53:45 <bsmnt_bot> <code object <lambda> at 0xb7cc51e0, file "<string>", line 1>
02:53:51 <bsmntbombdood> ~exec del self.f
02:53:57 <bsmntbombdood> ~exec sys.stdout(self.f)
02:54:45 <bsmntbombdood> ~exec self.f = __import__("types").FunctionType(self.the_code, globals(), "f")
02:54:58 <bsmntbombdood> ~exec sys.stdout(f)
02:55:03 <bsmntbombdood> ~exec sys.stdout(self.f)
02:55:03 <bsmnt_bot> <function f at 0xb7cc0374>
02:55:09 <bsmntbombdood> ~exec sys.stdout(self.f(1))
02:55:10 <bsmnt_bot> 2
02:55:18 <bsmntbombdood> yay!!!!
02:55:58 <bsmntbombdood> so you can get the function from the code object
02:56:03 <bsmntbombdood> well, there you have it
02:56:13 <bsmntbombdood> how to pickle functions
03:12:40 * bsmntbombdood feels clever
03:17:10 -!- CakeProphet has quit (Read error: 113 (No route to host)).
03:20:27 -!- ShadowHntr has joined.
03:34:24 -!- pikhq has quit ("leaving").
04:04:28 -!- digital_me_ has joined.
04:07:51 -!- digital_me has quit (Read error: 145 (Connection timed out)).
04:39:29 <bsmntbombdood> ~quit
04:39:29 -!- bsmnt_bot has quit.
04:39:32 -!- bsmnt_bot has joined.
04:39:46 <bsmntbombdood> ~exec self.save_callbacks(sys.stderr)
04:39:47 -!- bsmnt_bot has quit (Excess Flood).
04:39:49 -!- bsmnt_bot has joined.
04:39:54 <bsmntbombdood> heh
04:39:58 <bsmntbombdood> least I got something
04:42:28 <bsmntbombdood> ~quit
04:42:29 -!- bsmnt_bot has quit (Client Quit).
04:42:31 -!- bsmnt_bot has joined.
04:42:53 <bsmntbombdood> ~exec self.register_raw("test", lambda x : False)
04:43:13 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
04:44:15 <bsmntbombdood> ~exec sys.stdout(os.getuid())
04:44:15 <bsmnt_bot> 1343
04:44:38 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
04:45:42 <bsmntbombdood> ok, scratch that idea
04:46:07 <bsmntbombdood> TypeError: can't pickle code objects
04:47:19 <bsmntbombdood> :(
04:48:56 <oerjan> That's the saddest smiley I have seen.
04:50:59 <oerjan> Back to pickling command strings I presume...
04:51:07 <bsmntbombdood> actually, no
04:51:44 <bsmntbombdood> after yelling at me for wanting to pickle functions, the people in #python told me that the marshal module could do it
04:52:25 <bsmntbombdood> ~quit
04:52:25 -!- bsmnt_bot has quit.
04:52:27 -!- bsmnt_bot has joined.
04:52:38 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
04:54:14 -!- bsmnt_bot has quit (Remote closed the connection).
04:54:16 -!- bsmnt_bot has joined.
04:55:02 -!- bsmnt_bot has quit (Remote closed the connection).
04:55:04 -!- bsmnt_bot has joined.
04:55:35 -!- bsmnt_bot has quit (Remote closed the connection).
04:55:40 -!- bsmnt_bot has joined.
04:56:19 -!- bsmnt_bot has quit (Remote closed the connection).
04:56:21 -!- bsmnt_bot has joined.
04:57:16 <bsmntbombdood> ~quit
04:57:16 <bsmntbombdood> uuuh
04:57:16 <bsmntbombdood> ~exec self.disconnect("")
04:57:16 <bsmntbombdood> greaaaat
04:57:16 <bsmntbombdood> uuuh
04:57:16 <bsmntbombdood> DIE
04:57:16 <bsmntbombdood> ~quit
04:57:16 <bsmntbombdood> ...
04:57:17 -!- bsmnt_bot has quit (Client Quit).
04:57:21 -!- bsmntbombdood has quit (zelazny.freenode.net irc.freenode.net).
04:57:21 -!- bsmnt_bot has joined.
04:57:51 -!- bsmntbombdood has joined.
04:58:02 -!- bsmnt_bot has quit (Remote closed the connection).
04:58:04 -!- bsmnt_bot has joined.
04:58:25 <bsmntbombdood> finally
04:58:25 <bsmntbombdood> foo
04:58:27 <bsmntbombdood> ok bot is broken
04:58:35 -!- bsmntbombdood has left (?).
04:58:37 -!- bsmntbombdood has joined.
04:58:39 -!- bsmntbombdood has left (?).
04:59:15 -!- bsmntbombdood has joined.
04:59:35 <bsmntbombdood> ???
05:00:20 <bsmntbombdood> maybe it's just laggy
05:00:29 <bsmntbombdood> ok
05:00:35 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
05:00:43 <bsmntbombdood> no errors...
05:00:49 <bsmntbombdood> ~exec self.load_callbacks("/bot/test.pickle")
05:00:55 <bsmntbombdood> error.
05:01:11 <bsmntbombdood> ~quit
05:01:12 -!- bsmnt_bot has quit (Client Quit).
05:01:14 -!- bsmnt_bot has joined.
05:01:17 <bsmntbombdood> ~exec self.load_callbacks("/bot/test.pickle")
05:01:23 <bsmntbombdood> k
05:01:38 <bsmntbombdood> ~exec self.register_raw("testing", lambda x : False)
05:01:44 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
05:02:00 <bsmntbombdood> oh no
05:02:18 <bsmntbombdood> the bork
05:02:42 <bsmntbombdood> ~quit
05:02:57 -!- bsmnt_bot has quit (Remote closed the connection).
05:03:00 -!- bsmnt_bot has joined.
05:04:58 -!- bsmntbom1dood has joined.
05:05:54 -!- bsmntbombdood has quit (Nick collision from services.).
05:06:22 -!- bsmnt_bot has quit (Remote closed the connection).
05:06:25 -!- bsmnt_bot has joined.
05:06:57 <bsmntbom1dood> argh
05:07:02 <bsmntbom1dood> foo
05:07:17 -!- bsmntbom1dood has changed nick to bsmntbombdood.
05:07:29 <bsmntbombdood> k
05:07:32 <bsmntbombdood> there's like 30 seconds lag
05:08:03 -!- digital_me_ has quit ("Lost terminal").
05:09:40 <oerjan> Yeah, you are netsplitting a lot.
05:18:48 <Sukoshi> Does anyone here have some elementary signal processing knowledge?
05:19:41 <oerjan> Not much.
05:19:54 <Sukoshi> I'll ask anyways :D
05:20:09 <oerjan> Thought so :)
05:20:25 <Sukoshi> In a typical computer DSP system, does a low pass filter just perform a DFT on the time domain signal and junk the frequency points at which you cap the filter?
05:21:28 <oerjan> OK, I even misunderstood the subject - I somehow thought you were speaking of of Unix signals :)
05:21:39 <Sukoshi> Meh :D
05:22:18 <oerjan> Alas, I am completely blank on that question.
05:22:20 <oklopol> Sukoshi, that'd sound sensible.
05:22:44 <oklopol> I don't know, but... that's how i'd do it.
05:24:24 <oklopol> (You can say anything you're now sure about as long as you remember to leave right after it ->)
05:24:50 <oerjan> :DD
05:25:22 <Sukoshi> ... ;D
05:27:54 <oerjan> Well, wikipedia didn't seem to turn up anything specific.
05:29:04 <Sukoshi> It's not a very common let's-have-coffee-over-it topic.
05:31:01 <oerjan> This seems the most relevant: http://en.wikipedia.org/wiki/Lowpass_filter#Passive_digital_realization
05:32:30 <oerjan> Actually it is rather specific, but whether it is frequently used it doesn't say.
05:33:36 <Sukoshi> I'm not talking about a filter.
05:33:44 <Sukoshi> I'm talking about a DFT and a chop-off.
05:35:19 <oerjan> Also, http://en.wikipedia.org/wiki/Digital_filter
05:35:50 <oerjan> It mentions Fourier transforms and essentially chop-offs as well.
05:35:59 <Sukoshi> Yup. That's good :)
05:40:02 <bsmntbombdood> foo
05:40:06 <bsmntbombdood> good, less lag
05:40:12 <Sukoshi> bar
05:40:12 <bsmntbombdood> let's try this again
05:40:16 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
05:40:22 <bsmntbombdood> oops
05:40:28 <bsmntbombdood> ~exec self.register_raw("testing", lambda x : False)
05:40:31 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
05:40:39 <bsmntbombdood> ~exec self.load_callbacks("/bot/test.pickle")
05:40:55 <bsmntbombdood> ~exec self.print_callbacks()
05:41:00 <Sukoshi> What's that bot written in? Python I'm assuming?
05:41:02 <bsmntbombdood> crap
05:41:05 <bsmntbombdood> Sukoshi: yeah
05:41:10 <Sukoshi> Thought so.
05:41:16 <bsmntbombdood> well, that borks
05:41:19 -!- bsmnt_bot has quit (Remote closed the connection).
05:41:21 -!- bsmnt_bot has joined.
05:42:06 <bsmntbombdood> ~exec sys.stdout.write(pickle.load(open("/bot/test.pickle")))
05:42:06 <bsmnt_bot> [(<_sre.SRE_Pattern object at 0xb7d15bf0>, 'c\x03\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00C\x00\x00\x00s\x1e\x00\x00\x00|\x00\x00i\x01\x00d\x01\x00|\x02\x00i\x03\x00d\x02\x00\x83\x01\x00\x16\x83\x01\x00\x01d\x00\x00S(\x03\x00\x00\x00Ns\x07\x00\x00\x00PONG %si\x01\x00\x00\x00(\x04\x00\x00\x00t\x04
05:42:07 -!- bsmnt_bot has quit (Excess Flood).
05:42:09 -!- bsmnt_bot has joined.
05:42:50 <bsmntbombdood> ~exec sys.stdout.write([(i[0], marshal.loads(i[1])) for i in pickle.load(open("/bot/test.pickle"))))
05:42:56 <bsmntbombdood> ~exec sys.stdout.write([(i[0], marshal.loads(i[1])) for i in pickle.load(open("/bot/test.pickle")))
05:43:08 <bsmntbombdood> ~exec sys.stdout.write([(i[0], marshal.loads(i[1])) for i in pickle.load(open("/bot/test.pickle")]))
05:43:40 <bsmntbombdood> ~exec sys.stdout.write( [(i[0], marshal.loads(i[1])) for i in pickle.load(open("/bot/test.pickle")] )
05:44:08 <bsmntbombdood> Ok, I must be really tired if I can't get that to work
05:44:16 <bsmntbombdood> bedtime
05:45:10 <bsmntbombdood> ~exec sys.stdout( [ (i[0], marshal.loads(i[1])) for i in pickle.load(open("/bot/test.pickle"))] )
05:45:10 <bsmnt_bot> [(<_sre.SRE_Pattern object at 0xb7cdfbf0>, <code object pong at 0xb7c586a0, file "/bot/ircbot.py", line 147>), (<_sre.SRE_Pattern object at 0x80d8660>, <code object do_quit at 0xb7c586e0, file "/bot/ircbot.py", line 150>), (<_sre.SRE_Pattern object at 0x80d8ea0>, <code object do_raw at 0xb7c587e0, f
05:45:11 <bsmnt_bot> <code object do_ctcp at 0xb7c58720, file "/bot/ircbot.py", line 156>), (<_sre.SRE_Pattern object at 0x80d8898>, <code object do_exec at 0xb7c58520, file "/bot/ircbot.py", line 183>), (<_sre.SRE_Pattern object at 0x80cde50>, <code object do_exec at 0xb7c585a0, file "/bot/ircbot.py", line 183>), (<_sr
05:45:11 <bsmnt_bot> e "/bot/ircbot.py", line 183>), (<_sre.SRE_Pattern object at 0x8057b20>, <code object do_ps at 0xb7c58660, file "/bot/ircbot.py", line 204>), (<_sre.SRE_Pattern object at 0x80d2f60>, <code object do_kill at 0xb7c58860, file "/bot/ircbot.py", line 218>), (<_sre.SRE_Pattern object at 0x80cd078>, <code
05:45:13 <bsmnt_bot> E_Pattern object at 0xb7c90320>, <code object <lambda> at 0xb7c588e0, file "<string>", line 1>)]
05:45:17 <bsmntbombdood> That's what I wanted
05:45:27 <bsmntbombdood> ok well night
05:45:34 <bsmntbombdood> feel free to play around with it
05:50:52 <Sukoshi> Yay spam.
05:50:58 <bsmntbombdood> yay
06:06:25 <bsmntbombdood> ~exec self.f_code = marshal.loads(pickle.load(open("/bot/test.pickle"))[0][1])
06:06:36 <bsmntbombdood> ~exec sys.stdout(self.f_code)
06:06:37 <bsmnt_bot> <code object pong at 0xb7c586e0, file "/bot/ircbot.py", line 147>
06:06:59 <bsmntbombdood> ~exec self.f = types.FunctionType(self.f_code, globals())
06:07:04 <bsmntbombdood> ~exec sys.stdout(self.f)
06:07:05 <bsmnt_bot> <function pong at 0xb7c5948c>
06:08:08 <bsmntbombdood> ~exec self.f()
06:08:25 <bsmntbombdood> oooh, that's the problem
06:08:41 <bsmntbombdood> It doesn't know if they are methods or not
06:09:40 <bsmntbombdood> I wonder how to resolve this
06:12:55 -!- RodgerTheGreat has quit.
06:13:06 <bsmntbombdood> How to make python think it's a method
06:13:15 <oerjan> Put it in a class.
06:13:27 <bsmntbombdood> Then it gets the wrong self
06:13:37 <bsmntbombdood> ooh
06:15:55 <bsmntbombdood> methods are weird
06:16:04 <bsmntbombdood> if we duplicate that weirdness, we win
06:21:40 <bsmntbombdood> argh, looks like we need to pickle the instance too
06:21:45 <bsmntbombdood> ~quit
06:21:46 -!- bsmnt_bot has quit.
06:21:48 -!- bsmnt_bot has joined.
06:22:02 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
06:22:03 -!- bsmnt_bot has quit (Excess Flood).
06:22:05 -!- bsmnt_bot has joined.
06:23:10 <bsmntbombdood> ~quit
06:23:11 -!- bsmnt_bot has quit (Client Quit).
06:23:13 -!- bsmnt_bot has joined.
06:23:14 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
06:23:15 -!- bsmnt_bot has quit (Excess Flood).
06:23:18 -!- bsmnt_bot has joined.
06:23:22 <bsmntbombdood> wtf
06:23:46 <bsmntbombdood> ~quit
06:23:47 -!- bsmnt_bot has quit (Client Quit).
06:23:49 -!- bsmnt_bot has joined.
06:23:50 <bsmntbombdood> ~quit
06:23:51 -!- bsmnt_bot has quit (Client Quit).
06:23:53 -!- bsmnt_bot has joined.
06:23:55 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
06:23:56 -!- bsmnt_bot has quit (Excess Flood).
06:23:58 -!- bsmnt_bot has joined.
06:24:18 <bsmntbombdood> ~quit
06:24:19 -!- bsmnt_bot has quit (Client Quit).
06:24:21 -!- bsmnt_bot has joined.
06:24:22 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
06:25:49 <bsmntbombdood> <bsmnt_bot> PicklingError: Can't pickle <type 'instancemethod'>: it's not found as __builtin__.instancemethod
06:25:59 <bsmntbombdood> no, stupid, it's types.MethodType
06:27:45 <bsmntbombdood> we will tackle this in the morning
06:41:12 -!- oerjan has quit ("Good night").
06:58:24 -!- ShadowHntr has quit ("End of line.").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:48:58 <Sukoshi> For aspiring Lispers everywhere, here's code that automates the Trapezoidal Rule and Simpson's Rule of estimating the area under the curve between an upper-bound a lower-bound according to a curve expressesd as a function func split up into n intervals: (will paste)
08:50:37 <Sukoshi> http://paste.lisp.org/display/34869
08:50:41 <Sukoshi> Feel the power.
09:16:38 -!- ihope_ has joined.
09:29:04 -!- ihope has quit (Connection timed out).
12:07:28 -!- oklofok has joined.
12:08:15 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
12:49:36 -!- oklofok has changed nick to oklopol.
13:11:53 <SimonRC> Sukoshi: bah.  Haskell could do that in the same number of lines I suspect, or fewer.
13:12:58 <SimonRC> You should be showing off the real powerof Lisp: macros.
14:18:59 -!- jix has joined.
14:38:22 <bsmntbombdood> Sukoshi: (defun interval (low-bound up-bound n) (loop for i from low-bound to up-bound by (/ (- up-bound low-bound) n) collecting i))
14:42:55 <SimonRC> Haskell:  interval l h n = [l, l + step .. h] where step = (h - l) / n
14:43:34 * SimonRC goes
17:26:33 -!- ShadowHntr has joined.
17:36:05 -!- ShadowHntr has quit (Client Quit).
17:46:48 -!- ShadowHntr has joined.
19:19:17 -!- ShadowHntr has quit ("End of line.").
19:21:22 -!- tgwizard has joined.
20:27:05 <ihope_> I wonder how many people in the world are looking at the clock.
20:27:39 <ihope_> And I wonder how many people have claimed January 11 2007 3:23:30 PM my time to be their own personal second.
20:27:59 <ihope_> I'm not that greedy. I'm declaring the third tenth of it to be mine.
20:28:26 <ihope_> From January 11 2007 3:23:30.2 PM to January 11 2007 3:23:30.3 PM...
20:40:36 <oklopol> STOP HOGGING MY TIME!
20:58:51 <ihope_> Well, wait a minute.
20:59:05 <ihope_> Average lifespan divided by world population...
21:01:56 <ihope_> Average lifespan seems to be 66 years.
21:02:49 <ihope_> According to Google, we end up with 0.319188164 seconds per person.
21:03:26 <ihope_> Might as well round that down to 0.31415926535.
21:05:07 -!- ihope__ has joined.
21:05:35 -!- ihope__ has changed nick to ihope.
21:06:51 <ihope> Of course, the wealthy will get more time.
21:15:51 -!- CakeProphet has joined.
21:17:26 <oklopol> so, basically you just took what's yours
21:21:07 -!- ihope_ has quit (Connection timed out).
21:57:56 -!- ihope has quit ("http://tunes.org/~nef/logs/esoteric/06.08.09").
22:01:38 -!- Sgeo has joined.
22:07:11 -!- CakeProphet_ has joined.
22:08:29 -!- CakeProphet has quit (Read error: 113 (No route to host)).
22:08:35 -!- CakeProphet_ has changed nick to CakeProphet.
22:11:45 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:57:50 -!- Sgeo has quit (Remote closed the connection).
23:24:29 -!- oerjan has joined.
23:37:11 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
23:37:37 <oerjan> #esoteric, where you can get your 0.3 seconds of fame...
23:37:57 <bsmntbombdood> ?
23:38:06 <oerjan> See the recent logs
23:40:13 <bsmntbombdood> ...?
23:42:56 <oerjan> What ihope_ said 2-3 hours ago.
23:44:10 <oerjan> Ircbrowse is horribly slow today, unless it's me.
23:44:13 <bsmntbombdood> oh
23:44:27 <bsmntbombdood> ~quit
23:44:27 -!- bsmnt_bot has quit.
23:44:56 -!- bsmnt_bot has joined.
23:44:58 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
23:45:05 <bsmntbombdood> yess
23:45:19 <bsmntbombdood> ~exec self.load_callbacks("/bot/test.pickle")
23:45:48 <bsmntbombdood> argh
23:45:50 <bsmntbombdood> ~quit
23:45:57 -!- bsmnt_bot has quit (Remote closed the connection).
23:45:59 -!- bsmnt_bot has joined.
23:46:09 <bsmntbombdood> ~exec self.load_callbacks("/bot/test.pickle")
23:46:36 -!- bsmnt_bot has quit (Remote closed the connection).
23:46:38 -!- bsmnt_bot has joined.
23:46:43 <bsmntbombdood> ~exec self.load_callbacks("/bot/test.pickle")
23:46:55 <bsmntbombdood> ~exec self.print_callbacks()
23:47:01 <bsmntbombdood> I DUN IT!
23:47:08 <bsmntbombdood> ~quit
23:47:09 -!- bsmnt_bot has quit (Client Quit).
23:47:11 -!- bsmnt_bot has joined.
23:47:26 <bsmntbombdood> ~exec self.register_raw("testing asdf", lambda x : False)
23:47:29 <bsmntbombdood> ~exec self.print_callbacks()
23:47:42 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
23:47:45 <bsmntbombdood> ~quit
23:47:46 -!- bsmnt_bot has quit (Client Quit).
23:47:48 -!- bsmnt_bot has joined.
23:48:16 <bsmntbombdood> ~exec print >> sys.stdout, self.raw_regex_queue[-1]
23:48:17 <bsmnt_bot> (<_sre.SRE_Pattern object at 0x80c7cd8>, <function <lambda> at 0xb7c254c4>)
23:48:21 <bsmntbombdood> ~exec print >> sys.stdout, self.raw_regex_queue[-1].pattern
23:48:33 <bsmntbombdood> ~exec print >> sys.stdout, self.raw_regex_queue[-1][0].pattern
23:48:34 <bsmnt_bot> ^ERROR :Closing Link:.*
23:48:36 <bsmntbombdood> k
23:48:42 <bsmntbombdood> ~exec self.load_callbacks("/bot/test.pickle")
23:48:46 <bsmntbombdood> ~exec print >> sys.stdout, self.raw_regex_queue[-1][0].pattern
23:48:47 <bsmnt_bot> testing asdf
23:48:55 <bsmntbombdood> OOOOH HOO HOOO HOOOO!
23:48:59 <bsmntbombdood> it worked!
23:49:21 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
23:50:02 <bsmntbombdood> ~exec self.register_raw(".*#esoteric.*DIE BOT DIE.*", lambda x, y : True)
23:50:17 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
23:50:22 <bsmntbombdood> ~quit
23:50:22 -!- bsmnt_bot has quit (Client Quit).
23:50:24 -!- bsmnt_bot has joined.
23:50:29 <bsmntbombdood> ~exec self.load_callbacks("/bot/test.pickle")
23:50:35 <bsmntbombdood> DIE BOT DIE
23:50:36 -!- bsmnt_bot has quit (Remote closed the connection).
23:50:37 -!- bsmnt_bot has joined.
23:50:40 <bsmntbombdood> WOOO HOOOO
23:50:49 <bsmntbombdood> I have succesfully serialized a function
23:51:16 <lament> I have successfully serialized YOUR MOM!
23:52:19 <bsmntbombdood> cool
23:53:56 <bsmntbombdood> it works!
23:58:16 * bsmntbombdood is bloody brilliant

2007-01-12:

00:02:09 <bsmntbombdood> brilliant I tell you! brilliant!
00:05:54 <lament> bloody he tells us! bloody!
00:06:04 <bsmntbombdood> bloody!
00:11:20 -!- tgwizard has quit (Remote closed the connection).
00:16:29 <bsmntbombdood> hmm
00:16:39 <bsmntbombdood> I could just pickle the whole object 
00:20:14 <oerjan> DIE BOT DIE
00:20:29 <bsmntbombdood> ~exec self.load_callbacks("/bot/test.pickle")
00:20:32 <bsmntbombdood> now do it
00:20:39 <oerjan> DIE BOT DIE
00:20:39 -!- bsmnt_bot has quit (Remote closed the connection).
00:20:41 -!- bsmnt_bot has joined.
00:20:55 * oerjan feels the power
00:23:32 <bsmntbombdood> te he he
00:43:07 <bsmntbombdood> Well, it's persistant now
00:44:48 <oklopol> can i too?
00:44:54 <bsmntbombdood> yeah
00:45:05 <oklopol> DIE BOT DIE LIKE YER MOTHER!!!
00:45:11 <oklopol> :(
00:45:19 <oerjan> ~exec self.load_callbacks("/bot/test.pickle")
00:45:21 <oklopol> DIE BOT DIE LIKE YER MOTHER!!!
00:45:22 -!- bsmnt_bot has quit (Remote closed the connection).
00:45:25 -!- bsmnt_bot has joined.
00:45:32 <bsmntbombdood> heh
00:45:46 <oklopol> omg that's nice
00:46:03 <oerjan> a thereapeutic robot :D
00:46:08 <oklopol> yeah :)
00:46:22 <oklopol> ~exec print o
00:46:25 <oklopol> ~exec print "o"
00:46:32 <oklopol> meh
00:46:50 <oerjan> The sys.output problem has not been solved.
00:47:08 <oklopol> that is not fair :\
00:47:09 <oerjan> ~exec print >> sys.output "o"
00:47:14 <oerjan> ~exec print >> sys.output, "o"
00:47:26 <oklopol> >> ?
00:47:32 <oerjan> apparently renamed...
00:47:53 <bsmntbombdood> sys.stdout, as always
00:47:54 <oerjan> ~exec self.raw("PRIVMSG #esoteric :o")
00:47:55 <bsmnt_bot> o
00:48:06 <oerjan> darn my memory
00:48:25 <bsmntbombdood> I can't figure out how to fix that
00:48:48 <oklopol> why won't it help to just change the stdout here?
00:49:00 <bsmntbombdood> That's what it is
00:49:21 <bsmntbombdood> ~exec sys.stdout.write("foo")
00:49:22 <bsmnt_bot> foo
00:49:24 <bsmntbombdood> see
00:49:32 <oerjan> The problem is that the change should only affect the subthread, which may be impossible.
00:49:33 <oklopol> print is the exact same?
00:49:45 <bsmntbombdood> oerjan: right
00:49:59 <oklopol> ah okay
00:50:13 <bsmntbombdood> I change sys in the enviroment for the exec, but print borks anyway
00:50:43 <oerjan> A sub-process would solve that but make transmitting all other information awkward.
00:51:04 <bsmntbombdood> A sub proccess would require shared memory
00:51:09 <oerjan> Is it possible to redefine the print statement itself?
00:51:22 <bsmntbombdood> not that I'm aware of
00:52:10 -!- ShadowHntr has joined.
00:52:17 <oerjan> And I believe shared memory in a garbage collected language is hard, so Python probably doesn't have it.
00:52:25 <bsmntbombdood> yeah
00:52:37 <bsmntbombdood> don't think it does
00:53:05 <bsmntbombdood> It's possible to redefine the "import" statement with __import__, but I can't find the similar function for print
01:03:39 <CakeProphet> well...
01:04:13 <CakeProphet> the standard print can be altered with sys.stdout.write    ...but other than that...
01:04:37 <bsmntbombdood> CakeProphet: But I have done that
01:04:48 <bsmntbombdood> sys.stdout.write writes to this channel
01:05:19 <CakeProphet> import imp
01:05:24 <CakeProphet> has some useful stuff for import hooks.
01:05:33 <CakeProphet> to do some more interpreter magic that can't be done with __import__ easily.
01:05:46 <bsmntbombdood> I don't care about __import__, that was just an example
01:06:09 <Sukoshi> ~quit
01:06:24 <Sukoshi> Aux vorto :(
01:06:45 <bsmntbombdood> Sukoshi: The only public commands are ~exec and ~ps
01:07:11 <bsmntbombdood> You can quit it with ~exec self.disconnect(message)
01:08:49 <Sukoshi> ~ps
01:08:50 <bsmnt_bot> None
01:08:56 <Sukoshi> ~ps
01:08:57 <bsmnt_bot> None
01:08:58 <Sukoshi> ~ps
01:08:59 <bsmnt_bot> None
01:09:14 <bsmntbombdood> only ~exec commands go in ps
01:10:08 <Sukoshi> What's this ``pickling'' thingamabobber?
01:10:23 <bsmntbombdood> Python object serialization
01:10:32 <bsmntbombdood> I was using it to provide persistance for callbacks
01:10:51 * Sukoshi pities those without lexical and dynamic bindings.
01:13:34 * CakeProphet has some nifty stuff you ould use to persitent the entire global namespace.
01:13:41 <CakeProphet> I can store functions if nessicary.
01:14:02 <bsmntbombdood> sure, just pickle globals()
01:14:09 <CakeProphet> the pickle protocol can only store references to functions on the top level of a module.
01:14:17 <CakeProphet> same with classes.
01:14:27 <bsmntbombdood> meh whatever
01:14:27 <CakeProphet> because it doesn't actually store the class itself... just a reference name.
01:14:42 <bsmntbombdood> Did you see my way of persisting functions?
01:14:44 <CakeProphet> but... with enough abuse... you can make it work for any function.  :P
01:14:54 <CakeProphet> Nope.
01:15:20 <bsmntbombdood> we basically pickle [(i[0], marshal.dumps(i[1].func_code), inspect.ismethod(i[1])) for i in self.raw_regex_queue]
01:15:54 <CakeProphet> Eh... that would work.
01:16:00 <CakeProphet> for my MUD I use a class.
01:16:08 <CakeProphet> that wraps functions... and just store the source code.
01:16:18 <bsmntbombdood> getting it out is a little more complicated, because we have to convert functions to methods
01:16:49 <CakeProphet> the actual function isn't pickled... but the source is... upon a __call__ it recompiles the function if it doesn't exist or if the source string has been altered.
01:16:58 <bsmntbombdood> http://bsmntbombdood.mooo.com/chroot_ircbot.py
01:17:19 <CakeProphet> so you can edit the definition of a function inplace.
01:17:42 <bsmntbombdood> How do you get the source?
01:17:59 <CakeProphet> depends.
01:18:08 <CakeProphet> If it's something in the hard source... I use inspect.
01:18:24 <bsmntbombdood> Right, that parts easy
01:18:32 <CakeProphet> as for mid-runtime defined functions... I just capture the source as its defined and instantiate a new func object.
01:18:53 <bsmntbombdood>  hmm
01:18:59 <CakeProphet> since it's a MUD... and it uses commands-mapped-to-functions... I can just hard-code that part into the "def" command.
01:19:15 <bsmntbombdood> ?
01:19:29 <bsmntbombdood> You can redefine def?
01:19:34 <CakeProphet> no no.
01:19:39 <CakeProphet> it's not Python... it's MUD commands.
01:19:44 <bsmntbombdood> oh
01:20:03 <bsmntbombdood> So you have your own dsl
01:20:10 <CakeProphet> the player could type  "def WHEEFUNC(arg, arg)"   and a text-editor would pop up or something.
01:20:16 <CakeProphet> dsl?
01:20:19 <CakeProphet> wassat?
01:20:38 <bsmntbombdood> domain specific language
01:20:47 <CakeProphet> if you wanna call it that.
01:21:27 <CakeProphet> it's just   "command stuff"    where stuff is matched to a command-specific parsing regex.
01:21:46 <bsmntbombdood> regexes!
01:22:17 <CakeProphet> I still have that way to do it..
01:22:26 <CakeProphet> but I decided in the end to make a new version that ditches all of that.
01:22:48 <CakeProphet> and I'm going to make my own language for the MUD... that resembles ORK and uses coroutines heavily.
01:24:08 <bsmntbombdood> I wonder if you could write a parser using only regexes
01:24:23 <CakeProphet> sure... depends on the language though.
01:24:33 <CakeProphet> Stue... for example... can be parsed entirely with regex.
01:24:39 <CakeProphet> as could ORK.
01:24:42 <bsmntbombdood> Using backreferences to get the actual values
01:24:54 <CakeProphet> Python's regex has named groups.
01:24:57 <CakeProphet> which is super handy for that.
01:25:06 <bsmntbombdood> yeah
01:25:17 <CakeProphet> Glass could probably be parsed with regex.
01:25:20 <CakeProphet> and BF too...  :P
01:25:58 <CakeProphet> some things that probably can't be parsed too easily with regex would be like... HTML and English.
01:27:49 <oerjan> Actually simple regexes cannot parse nested parenthesis-like structures.
01:28:16 <CakeProphet> I think really parsing english is just a matter of amassing a huge database of words, slang terms, colloquialisms, acronyms, terminology, expressions, common names, etc.
01:28:24 <oerjan> Which rules out both Glass (/\) and BF ([])
01:28:33 <bsmntbombdood> hrm
01:28:42 <bsmntbombdood> yeah, I guess so
01:29:01 <oerjan> it's the difference between regular and context-free languages
01:29:08 <bsmntbombdood> But you say simple...are there complex ways to do it?
01:29:32 <CakeProphet> I've got a parsing library that extends off of regex to allow recursive structures.
01:29:41 <oerjan> Well I was hedging my bets for what strange extensions might exist :)
01:29:43 <CakeProphet> it uses some form of "forewarding" or something.
01:30:28 <CakeProphet> I guess if you a metacharacter that meant "a backreference to the group I'm in".
01:30:33 <CakeProphet> you could let the regex engine handle it.
01:31:53 <oerjan> There may of course be tricks to use regexes heavily together with explicit recursion.
01:33:47 <oerjan> For example, in BF you might use "[[^][]*]" to get everything between the first and last loop, and then have another regex to split _that_ up.
01:34:02 <bsmntbombdood> hmph
01:34:25 <bsmntbombdood> except you have to escape the []
01:34:46 <bsmntbombdood> "\[[^\]\[]*\]"
01:34:50 <oerjan> Eh, wait that was wrong.
01:34:56 <bsmntbombdood> er
01:35:00 <oerjan> In fact I meant:
01:35:34 <bsmntbombdood> "\[.*\]"
01:35:57 <oerjan> "\[^][]*\[(.*)\][^][]*\]"
01:36:22 <bsmntbombdood> huh?
01:36:55 <oerjan> first skip to the first [, then keep everything to the last ], then skip the rest.
01:37:16 <oerjan> Don't know if it's useful, just thought of it.
01:37:41 <bsmntbombdood> You can't get it to match the right ]
01:38:12 <oerjan> Gah, I forgot the final \[^][]*
01:38:45 <oerjan> i mean i had an extra \]
01:39:04 <oerjan> cannot read my own regexps :)
01:39:41 <bsmntbombdood> you can't get nested loops
01:39:52 <oerjan> I suppose real parser combinators are better.
01:40:24 <oerjan> What is wrong with "\[^][]*\[(.*)\][^][]*" ?
01:40:39 <bsmntbombdood> I can't read it :)
01:40:53 <oerjan> Gah. An extra \
01:41:01 <CakeProphet> regex should probably go the oher way around..
01:41:05 <CakeProphet> or at least... have an option to do.
01:41:15 <CakeProphet> use escape characters for the meta characters..
01:41:22 <CakeProphet> instead of escape characters for the regular characters.
01:41:30 <oerjan> What is wrong with "[^][]* \[ (.*) \] [^][]*"/v ?
01:41:39 <CakeProphet> all the slashes make it weird to read.
01:41:42 <bsmntbombdood> there's a sexp regex format
01:42:10 <CakeProphet> but I guess all the escape characters for metachars would just muck up the readability too.
01:42:11 <oerjan> I am trying to use the Perl format, which is what I know somewhat.
01:42:12 <CakeProphet> so..
01:42:39 <CakeProphet> I always use non-greedy *'s on .'s
01:42:42 <CakeProphet> .*?
01:42:44 <bsmntbombdood> that CL-PPCRE uses
01:42:50 <CakeProphet> otherwise it'll eat up your regex.
01:43:10 <oerjan> That /v should be /x
01:43:28 <oerjan> (for embedded whitespace for legibility.)
01:43:56 <CakeProphet> verboose mode comes in handy.
01:44:05 <CakeProphet> ignores whitespaces unless they're in brackets.
01:44:40 <oerjan> OK then: "^ [^][]*? \[ (.*) \] [^][]* $"/x ?
01:45:15 <CakeProphet> hmmm..
01:45:24 <CakeProphet> the tilde seems like a good escape character.
01:45:30 <bsmntbombdood> won't work
01:45:32 <oerjan> Actually that ? is useless.
01:45:40 <bsmntbombdood> wait
01:45:45 <CakeProphet> it's rarely used.... and it's not quite so weird and choppy looking as \
01:45:46 <bsmntbombdood> That might actually work
01:46:01 <bsmntbombdood> CakeProphet: writing your own pattern matcher?
01:46:08 <CakeProphet> Nah.
01:46:16 <CakeProphet> Any pattern matcher I wrote would be non-character-specific.
01:46:31 <CakeProphet> with an optional ability to match per-character.
01:46:43 <bsmntbombdood> oerjan, I think you've got something
01:46:59 <CakeProphet> ~[^~]
01:47:01 <CakeProphet> hmmm...
01:47:13 <CakeProphet> ![^!]
01:47:17 <EgoBot> Huh?
01:47:17 <CakeProphet> I kind of like !'s
01:47:20 <CakeProphet> but it's used.
01:47:35 <oerjan> The question is how to parse the interior further.
01:48:00 <bsmntbombdood> recurse
01:48:14 <oerjan> It needs a different expression for sure.
01:48:57 <bsmntbombdood> uh yeah, yours.doesn't work
01:49:43 <bsmntbombdood> matched agains "[ ] [ ]", it matches the whole thing
01:50:44 <oerjan> Yes, and then " ] [ " needs to be split up further.
01:51:11 <bsmntbombdood> I don't know of any way to do it other than counting, and regexes can't count
01:51:30 <CakeProphet> Lisp can be parsed... erm... linearly.
01:51:38 <bsmntbombdood> ?
01:51:48 <oerjan> I believe I said I meant to use more than one regexp.
01:51:51 <CakeProphet> character by character.
01:52:10 <bsmntbombdood> yeah
01:52:22 <bsmntbombdood> it still needs to count parens
01:52:41 <CakeProphet> "(" simply means accumulate another branch to the parse tree...  ")" mean return to the last node... "  and '  would start a string and symbol mode respectively.
01:52:44 <bsmntbombdood> increment on "(", decrement on ")", return buffer when count == 0
01:53:00 <CakeProphet> ...yeah.
01:53:32 <oerjan> Well, even if it could work it would end up rather complicated.
01:53:40 <CakeProphet> Yup.
01:54:07 <CakeProphet> parsers tend to be pretty damn weird to code by hand  (i.e. without a parsing language)
01:54:59 <bsmntbombdood> I think I'm going to write a quit parser for nested (), just as an excersize
01:56:51 <oerjan> Recursive descent is not that bad.
01:57:00 <oerjan> When it works.
02:01:27 -!- CakeProphet_ has joined.
02:02:40 <oerjan> Is everyone else finding the net awfully slow these last days?  And not just IRC either.
02:02:54 <bsmntbombdood> yes
02:03:01 <bsmntbombdood> I was just thinking that
02:03:46 <CakeProphet_> The tubes are clogged?
02:03:59 <bsmntbombdood> need some billaird balls
02:07:46 <bsmntbombdood> ok, no idea how to do this
02:08:07 <oerjan> do what?
02:08:12 <bsmntbombdood> I at least got the code to get the part in between the parentheses
02:08:24 <oerjan> What is a quit parser?
02:08:34 <bsmntbombdood> *quick
02:09:00 <oerjan> Darn, here I though I was up to some new interesting technology :D
02:09:44 <oerjan> Use either an explicit stack, or recursion.
02:09:50 <bsmntbombdood> yeah
02:11:38 <bsmntbombdood> I'm not sure what the parse tree should look like
02:12:07 <oerjan> A list of expressions, some of which are themselves lists of expressions?
02:12:13 <bsmntbombdood> (a(b)) => [["a", ["b"]]] ? 
02:12:38 <oerjan> A single outer set should be enough.
02:12:56 <bsmntbombdood> a(b(c))
02:13:03 <bsmntbombdood> er, yeah
02:13:06 <oerjan> eh, right.
02:13:09 -!- CakeProphet_ has quit (Read error: 104 (Connection reset by peer)).
02:13:09 -!- CakeProphet__ has joined.
02:13:19 <bsmntbombdood> gah, I have no idea what I'm doing
02:13:32 <oerjan> actually your first seemed good.
02:13:42 <bsmntbombdood> what should (a(b)c) parse to?
02:13:59 -!- CakeProphet has quit (Read error: 113 (No route to host)).
02:14:03 -!- CakeProphet__ has changed nick to CakeProphet.
02:14:10 <bsmntbombdood> [["a", ["b"], "c"]] ?
02:14:21 <oerjan> I think so.
02:15:06 <CakeProphet> my web browser is acting weird.
02:15:09 <oerjan> for clarity, you might want two different functions, parse_list and parse_expr
02:15:09 <CakeProphet> it can't get to anything.
02:15:16 <CakeProphet> while everything else internet-wise works fine.
02:15:23 <bsmntbombdood> CakeProphet: wow
02:15:38 <CakeProphet> it just hangs up... :/
02:15:42 <oerjan> i also have web sites dropping out frequently.
02:16:01 <CakeProphet> it just sits loading forever...
02:16:10 <CakeProphet> without ever saying "lol no connection kthxbai"
02:16:12 <oerjan> Same with me, until it gives up.
02:16:18 <bsmntbombdood> yep
02:16:32 <CakeProphet> meanwhile telnet and IRC work hunky dory.
02:16:33 <oerjan> Oh, mine does give up eventually.
02:17:26 <CakeProphet> I can reach the esolang wiki and..
02:17:27 <CakeProphet> gmail.
02:18:14 <oerjan> Perhaps they are close to you? Anyhow the esolang wiki has always been on and off in my experience.
02:19:00 <oerjan> Maybe the spam is finally taking over :/
02:19:59 <CakeProphet> hmm... working fine for now..
02:20:02 <CakeProphet> a little bump though.
02:20:08 <CakeProphet> bumpy
02:21:31 <oerjan> Now I cannot get to BBC news...
02:21:53 <oerjan> Now I can.
02:27:25 <bsmntbombdood> weird
02:27:40 <oerjan> ?
02:27:50 <bsmntbombdood> the web
02:28:18 -!- pikhq has joined.
02:28:27 <bsmntbombdood> argh I can't do this
02:28:30 <bsmntbombdood> the parser
02:28:41 <oerjan> What's the problem?
02:28:47 <bsmntbombdood> ...I don't know
02:29:43 <oerjan> What are you doing at ( and ) ?
02:30:12 <bsmntbombdood> incrementing the count, decrementing the count and recursing if count == 0
02:30:41 <oerjan> Eh, recursing should be done whenever you hit a (
02:30:51 <bsmntbombdood> ?
02:31:03 <oerjan> Paste?
02:31:28 <bsmntbombdood> it's not even anything
02:31:47 <bsmntbombdood> oh I know
02:32:02 <bsmntbombdood> i need to return the string if it doesn't have any of () in it
02:32:14 <oerjan> If you are using recursion, you don't need any counting.
02:32:26 <bsmntbombdood> eh?
02:33:14 <oerjan> Just return when you would decrement and call a subfunction when you would increment.
02:34:14 <oerjan> The depth of the recursion stack automatically keeps track of the count.
02:37:12 <oerjan> And by the way, this is easiest in functional style: the result value of the function should be the parse tree of what that invocation has parsed.
02:37:25 <bsmntbombdood> right
02:38:45 <oerjan> On the other hand the pointer to the current character needs to be common for all invocations, so each can take over where another stopped.
02:39:09 <oerjan> Easy with a file-like object, I presume.
02:39:35 <bsmntbombdood> they just pass a substring
02:40:19 <oerjan> Right, in that case it needs to be passed upwards as well because the caller needs to take over where the called function stopped, as well.
02:40:33 <bsmntbombdood> argh
02:41:28 <oerjan> I believe in Python it is easier to use a common object with a pointer.
02:42:34 <bsmntbombdood> file like object it is, then
02:42:55 <CakeProphet> Python doesn't really recognize such a thing as a "pointer".
02:43:13 <CakeProphet> everything is implicitly a reference... 
02:43:34 <bsmntbombdood> And index into an indexable object is a "pointer"
02:43:46 <bsmntbombdood> s/And/An/
02:45:01 <oerjan> That's what I meant anyhow.
02:45:32 <oerjan> Also, doing it this way has the advantage that you can easily parse directly from a file.
02:45:33 <CakeProphet> but if it's something like a string... there's very little difference in a reference to a string and a copy of a string.
02:45:36 <CakeProphet> due to immutability.
02:45:49 <CakeProphet> lists and dictionaries... on the other hand.
02:46:36 <oerjan> Just pretend I said "index", OK? :)
02:46:59 <CakeProphet> hmm... is an index a "pointer"?
02:47:34 <oerjan> Well, a pointer is an index into memory.
02:48:34 <CakeProphet> it doesn't matter much in Python though.
02:48:48 <bsmntbombdood> You have to use an index to emulate a pointer in python
02:49:02 <CakeProphet> mutability and immutability tend to outweigh pointers.
02:49:49 <CakeProphet> x = [[].[].[]]; y = x[0]; y.append(1);  print x    #[[1],[].[]]
02:49:54 <bsmntbombdood> well in c, everything is immutable
02:49:55 <CakeProphet> That's a "pointer"
02:50:24 <CakeProphet> anything assigned to a list is just a pointer... unless you use the copy method... or use the list() function.
02:50:52 <CakeProphet> x = [[].[].[]]; y = x[0].copy(); y.append(1);  print x    #[[],[].[]]
02:52:06 <CakeProphet> y becomes a "pointer" implicitly for any variable that references a list.... same with dictionaries and classes/instances.
02:52:10 <oerjan> This is all well and good, but we knew it already.  I just used a loaded word OK?
02:52:29 <CakeProphet> nah nah... not the wording... I'm just trying to figure out... what you're trying to do..
02:52:55 <bsmntbombdood> some hardcore pointer manipulation makes me all warm and fuzzy inside
02:53:20 <oerjan> I was suggesting bsmntbombdood turned his string into an input file-like object so it could be scanned/parsed easier.
02:53:29 <CakeProphet> StringIO?
02:53:52 <oerjan> Which means he somehow needs an index into it.
02:54:13 <CakeProphet> import cStringIO as stringio;   x = stringio(); x.write("wheeeee"); print x.getvalue()
02:54:15 <oerjan> There's a library for it?  Not entirely surprising.
02:54:25 <CakeProphet> yup.
02:54:36 <CakeProphet> cStringIO is the faster version of it though... so I'd use it.
02:55:07 <CakeProphet> it's basically just a string-file... good pretty much anywhere a file is   (it uses all the same methods... with an added "getvalue" method)
02:55:11 <bsmntbombdood> It's also a drop in replacement, so it doesn't matter what I use
02:56:38 <CakeProphet> Half of Python's awesomeness lies in the sheer amount of junk in its library.
02:56:54 <bsmntbombdood> oerjan: what do I do on ) ?
02:57:28 <CakeProphet> You place that accumulated bits into the next index of the node?
02:57:32 <oerjan> Just return.
02:57:59 <CakeProphet> That's what I'd guess... basically just convert it into tuples (or lists)
02:58:01 <oerjan> Perhaps not advancing the index, so that the parent also gets to see the )
02:58:05 <CakeProphet> lists would work better... being mutable.
02:58:43 <oerjan> Yes, return the accumulated list.
02:58:53 <CakeProphet> Generally speaking... if you're doing massive numbers of string, list, or tuple concats in a Python program... you're probably doing it the wrong way.
02:59:11 <bsmntbombdood> CakeProphet: I do string concats a lot :/
02:59:17 <CakeProphet> ewww.
02:59:19 <CakeProphet> they're slow.
02:59:26 <CakeProphet> list operations are much faster.
03:00:10 <CakeProphet> because when you work with a list... you don't have to construct an entirely new string object each and every time... as you do with concatenation.
03:02:03 <CakeProphet> it's really on a problem when you have a large number of successive concatenations on a progressively increasing string.
03:02:15 <CakeProphet> r/on/only
03:02:23 <oerjan> I guess stringIO doesn't actually construct the string until you call get_value?
03:02:31 <CakeProphet> Righto.
03:02:46 <CakeProphet> among other things.
03:02:51 <CakeProphet> it's a "mutable string".
03:03:20 <CakeProphet> but usually lists are the way to go when messing with strings.
03:03:23 <bsmntbombdood> there was a mutable string class once I think
03:04:26 <bsmntbombdood> arggggh
03:04:29 <CakeProphet> compared     "\n".join(SomeListOfStrings)    to     x = "";  for string in SomeListOfStrings: x += string + "\n"
03:04:35 <bsmntbombdood> parse("(a(b))") => ['', ['a', []]]
03:04:48 <CakeProphet> What's wrong?
03:04:55 <CakeProphet> oh.
03:04:58 <CakeProphet> hmm.
03:05:00 <CakeProphet> no
03:05:01 <CakeProphet> wait
03:05:03 <CakeProphet> don't see it.
03:05:12 <bsmntbombdood> ?
03:05:48 <bsmntbombdood> http://pastebin.ca/313805
03:06:32 <CakeProphet> bsmntbombdood,  haha... that's exactly the kind of problem I was referring to.  :P
03:06:40 <bsmntbombdood> ...yep
03:07:24 <CakeProphet> why a while loop?
03:08:03 <bsmntbombdood> because
03:08:48 <CakeProphet> ...
03:09:08 <CakeProphet> it looks like you're just recursively calling parse() on the exact same string  ( s )
03:09:16 <bsmntbombdood> How else would I do it?
03:09:19 <oerjan> Why the buff?
03:09:38 <oerjan> s shouldn't be a string but a file-like object.
03:09:48 <bsmntbombdood> CakeProphet: s isn't a string
03:09:55 <CakeProphet> file.
03:09:57 <CakeProphet> ah.
03:10:24 <CakeProphet> you couild use partition... if you wanted.
03:11:09 <bsmntbombdood> why?
03:11:24 <CakeProphet> "Wheee(wha wha wha (wha wha wha))".partition("(")  == ("Wheeee", "(", "wha wha wha (wha wha wha))"
03:11:29 <oerjan> You are missing a tree.append(buff) before the return.
03:11:31 <CakeProphet> so you don't have to use that god awful buffer.
03:11:51 <bsmntbombdood> oerjan: oh, right
03:12:07 <bsmntbombdood> now it kind of works
03:12:09 <oerjan> And also you should check for buff==""
03:12:19 <CakeProphet> make a buff a list.
03:12:24 <CakeProphet> and append characters to the list.
03:12:33 <CakeProphet> much much quicker.
03:13:23 <oerjan> Perhaps...
03:13:38 <CakeProphet> no... that's the way you would want to do it.
03:13:40 <CakeProphet> :P
03:13:46 <CakeProphet> strings aren't meant to do stuff like tha.
03:13:48 <CakeProphet> t
03:13:52 <bsmntbombdood> okeey, it works
03:13:54 <oerjan> I wasn't responding to you. :)
03:13:57 <CakeProphet> oh.
03:14:23 <bsmntbombdood> http://pastebin.ca/313811
03:14:58 <oerjan> It might be an idea to do the collection of non-() as a second while loop inside the first. Then you don't have to worry about "" testing.
03:15:00 <CakeProphet> yeah... buff should definetely be a list... the string concats will get slow.
03:15:16 <oerjan> And it would be easy to do a join at the end of it.
03:15:24 <CakeProphet> "".join(buff)
03:16:32 <oerjan> However, then you need to be careful about when you read the next character. Unless the files have an undo method.
03:16:53 <bsmntbombdood> CakeProphet: http://pastebin.ca/313814
03:16:55 <bsmntbombdood> happy?
03:16:58 <CakeProphet> yup.
03:17:01 <bsmntbombdood> oerjan: they dont
03:17:14 * CakeProphet wishes file objects had an iterator for character-by-character stuff
03:17:25 <CakeProphet> you could make one pretty easy though.
03:18:14 <oerjan> I think there is still a bug in that if there is eof while buff is non-empty.
03:18:23 -!- digital_me has joined.
03:18:39 <bsmntbombdood> oerjan: indeed there is
03:18:58 <CakeProphet> for loops over files only go line-by-line...
03:19:57 <bsmntbombdood> http://pastebin.ca/313817
03:20:00 <CakeProphet> def chariter(file): for line in file: for char in line: yield char
03:20:20 <CakeProphet> for char in chariter(s):   <code>
03:20:27 <CakeProphet> that'll solve pretty much all your problems.
03:20:58 <oerjan> Oh, and it definitely does not catch mismatched parentheses.
03:20:59 <CakeProphet> as a general rule of thumb... while loops tend to be infrequently used in Python.
03:21:31 <oerjan> The problem here is that the index of the for loop needs to be updated after the recursion.
03:21:46 <bsmntbombdood> yeah
03:21:54 <bsmntbombdood> and python is stupid about that
03:21:59 <CakeProphet> index of the for loop?
03:22:02 <CakeProphet> what for?
03:23:15 <oerjan> I mean, the parent function should not reparse the characters parsed by the child.
03:23:56 <CakeProphet> just cut it off each time.
03:24:29 <lament> "There's still a bug" - well said
03:24:34 <oerjan> What does cut off mean?  Can two for loops share an iterator?
03:25:01 <bsmntbombdood> argh, parsign is hard
03:25:31 <oerjan> For proper error handling you need to use lookahead for the ")"
03:25:59 <oerjan> So that the parent takes care of checking if it was actually there.
03:26:00 <bsmntbombdood> to get the next character you could use s.getvalue()[s.pos+1]
03:26:23 <oerjan> Now _that_ is inefficient.
03:26:31 <bsmntbombdood> yep
03:30:28 <oerjan> On second thought, you don't need lookahead if the child knows whether it needs an end parenthesis.
03:31:20 <oerjan> Which it does unless it actually is the topmost parent.
03:31:30 <oerjan> *child = function
03:32:33 <oerjan> And the topmost parent, on the other hand, knows that it must not have a )
03:32:47 <oerjan> So an extra argument could fix that.
03:33:03 <bsmntbombdood> ugh
03:33:07 <bsmntbombdood> I hate doing that
03:33:37 <oerjan> Or you could make two different functions.
03:37:31 <CakeProphet> how about this?  http://pastebin.ca/index.php
03:37:37 <CakeProphet> it doesn't do error checking... but meh.
03:37:49 <oerjan> I doubt that is your URL.
03:38:06 <CakeProphet> ...erm... yeah
03:38:14 <CakeProphet> http://pastebin.ca/313825
03:39:06 <CakeProphet> oh... wait.
03:39:10 <CakeProphet> duh.
03:39:12 <CakeProphet> obvious mistake.
03:40:32 <CakeProphet> it needs to check for the ending parenthesis.
03:44:05 <bsmntbombdood> whats that list[::n] syntax?
03:44:21 <CakeProphet> step.
03:44:29 <CakeProphet> (1,2,3)[::2]  == (1,3)
03:44:36 <CakeProphet> it's kinda weird.
03:44:39 <CakeProphet> but strangely useful.
03:45:04 <CakeProphet> http://pastebin.ca/313826
03:45:06 <CakeProphet> new one
03:45:08 <CakeProphet> with a fix.
03:45:11 <CakeProphet> dunno if it works... but eh.
03:45:14 <CakeProphet> it's how I would have done it.
03:45:26 <bsmntbombdood> ...using partition is cheating
03:46:09 <CakeProphet> ...how's that?
03:46:18 <CakeProphet> it's not recursive.
03:46:25 <CakeProphet> it's not regular expressions.
03:46:30 <bsmntbombdood> You are only allowed to step through characters one by one
03:46:30 <CakeProphet> it's damn useful.  :P
03:47:04 <CakeProphet> at it's heart... the partition source code probably steps through each character one by one.
03:47:06 <CakeProphet> so...
03:47:08 <CakeProphet> :P
03:47:32 <bsmntbombdood> I wanted a "real" parser
03:47:55 <CakeProphet> sure sure... just substitute what partition does into that and you'll have a character-by-character "real parser".
03:48:14 <bsmntbombdood> then it becomes waaay long
03:48:16 <bsmntbombdood> er than mine
03:48:39 <CakeProphet> of course it does.
03:50:28 <CakeProphet> for loop is the way to go over while.
03:50:39 <CakeProphet> while can't anticipate EOFs ;)
03:50:43 <CakeProphet> not easily.
03:51:07 <CakeProphet> using whle loops for iterating is a sin anyhow.
03:51:51 <oerjan> Does that code actually work with nested parentheses?
03:51:58 <CakeProphet> mine?
03:52:04 <CakeProphet> Don't know.
03:52:06 <CakeProphet> haven't tested it.
03:52:07 <oerjan> Yes.
03:52:09 <CakeProphet> it'll probably have bugs.
03:52:12 <CakeProphet> but... oh well.
03:52:42 <CakeProphet> the way I envision it... it would.
03:52:49 <CakeProphet> but... I doubt it works as I imagine.
03:53:24 <oerjan> Does partition include the "("'s in the list?
03:53:28 <bsmntbombdood> and what's the point of replace("\n", "")?
03:53:39 -!- pikhq has quit ("leaving").
03:53:46 <CakeProphet> newlines aren't signifigant... or so I'm lead to believe.
03:53:56 * CakeProphet was thinking of Lisp when he made it.
03:54:10 <bsmntbombdood> oerjan: partitition(sep) => (head, sep, tail)
03:54:22 <CakeProphet> it puts it in the middle.
03:54:25 <bsmntbombdood> CakeProphet: They aren't
03:54:31 <oerjan> Oh, so never more than one sep?
03:54:40 <CakeProphet> which I safely ignore via [::2]
03:54:42 <CakeProphet> nope.
03:54:47 <CakeProphet> split is the one that does them all.
03:54:56 <CakeProphet> it returns a list.
03:55:07 <CakeProphet> partition is just a 3-tuple of the first encountered seperator.
03:55:26 <bsmntbombdood> "a b c".split(" ") => ['a', 'b', 'c']
03:55:29 <oerjan> I doubt that it works when there are no ")"s in the string...
03:55:38 <oerjan> I mean "("
03:55:50 <bsmntbombdood> "a b c".partition(" ") => ('a', ' ', 'b c')
03:55:54 <CakeProphet> "a b c".split(" ") => ("a", " ", "b c")
03:55:56 <CakeProphet> yeah
03:56:01 <CakeProphet> partition
03:56:05 <bsmntbombdood> CakeProphet: no
03:57:20 * CakeProphet is still thinking abouit that esoteric parsing language.
03:57:33 <CakeProphet> parsing is a pain in the ass... and needs simplification... esoterically.
03:57:49 <oerjan> Anyhow if I understand your code right, it hardly works on anything containing more than a single set of parentheses.
03:58:37 <oerjan> Wait a moment, not even that.
03:58:48 <oerjan> You are checking for ")" in the wrong branch.
04:00:19 <bsmntbombdood> whoa, mine works when you leave off closing parentheses
04:00:38 <oerjan> In fact, partition used this way cannot do more than regexes.
04:02:05 <oerjan> Which we discussed previously, and I think we agreed it would at least become very complicated to parse nested parentheses using them, if at all possible.
04:03:46 <oerjan> bsmntbombdood: That's because there is no difference between eof and ), essentially.
04:03:56 <oerjan> In the code.
04:04:14 <bsmntbombdood> hmm, right
04:05:06 <oerjan> And as I implied, without extra arguments only the parent knows whether there must be a ")" or not.
04:05:17 <CakeProphet> oh ho..
04:05:19 <CakeProphet> I beg to differ.
04:05:24 <CakeProphet> [["I've", 'got', [['magic', 'in', [[[['my', 'pocket', [['really', 'have']]]]]]]]]]]
04:05:37 <CakeProphet> parsed from...  print whee("(I've got (magic in ((my pocket) but) you can't (really have) it)")
04:05:48 <CakeProphet> it messes it up some.
04:05:59 <CakeProphet> oh wait.
04:06:05 <CakeProphet> no it doesn't... hmmm...
04:06:07 <bsmntbombdood> [["I've got ", ['magic in ', [['my pocket'], ' but'], " you can't ", ['really have'], ' it']]]
04:06:13 <bsmntbombdood> is what my parser gets
04:08:51 <oerjan> It misses the part after ")". As I said, the partition(")") is in the wrong branch.
04:09:08 <CakeProphet> It wouldn't work properly in the other one.
04:09:17 <CakeProphet> or.. it would work less properly.
04:09:45 <oerjan> Which strangely means that you call it recursively with something not well-formed.
04:09:51 <CakeProphet> see it works "backwards"... sorta.
04:10:19 <oerjan> You at least need to take case of the [3] part.
04:10:27 <oerjan> I mean [2]
04:10:32 <oerjan> *care
04:19:00 <CakeProphet> I'm awaiting a stroke of genius.
04:19:10 <CakeProphet> where I realize the grand pattern of parsing.
04:19:14 <CakeProphet> and make the ultimate parsing language.
04:19:15 <CakeProphet> but...
04:19:18 <CakeProphet> isn't happening.
04:20:09 <oerjan> Unfortunately it has already been done.  It is called monadic parser combinators in Haskell :)
04:20:37 <bsmntbombdood> moniadic parser combinators!
04:20:41 <oerjan> Well, that or Prolog diff lists, perhaps.
04:20:44 <bsmntbombdood> that's a buzzword if I ever saw one
04:21:20 <CakeProphet> for languages with symbols... there's some basic general re-ocurring patterns.
04:21:32 <bsmntbombdood> tokens
04:21:39 <bsmntbombdood> lex+yacc
04:21:57 <CakeProphet> enclosures (parentesis),  flippers (quotes), funnyhats(decorate syntax in Python
04:22:04 <CakeProphet> :P
04:22:16 <CakeProphet> hmmm...
04:22:57 <CakeProphet> you have things that serve as delimiters... usually operators... sometimes things like whitespace and newlines.
04:23:07 <bsmntbombdood> tokens
04:23:19 <CakeProphet> yes yes... tokens... you have to -make- them.
04:23:23 <bsmntbombdood> lex
04:23:30 <CakeProphet> which is what I'm trying to accomplish.
04:23:38 <bsmntbombdood> lex+yacc!
04:23:45 <CakeProphet> wait!
04:23:49 <CakeProphet> who needs tokens?
04:23:51 <CakeProphet> I mean really..
04:23:53 <oerjan> expr_list = many (liftM Left (notOneOf "()") <|> liftM Right (between (char "(") (char ")") expr_list)
04:24:43 <bsmntbombdood> CakeProphet: yacc does
04:26:16 <CakeProphet> esoteric parsers don't need "tokens".
04:26:25 <CakeProphet> they need coupons.
04:26:36 <CakeProphet> which cannot even be defined in terms of the English language.
04:26:38 <CakeProphet> so I won't even bother.
04:26:41 <bsmntbombdood> You might combine both stages into one, but you are still going to be tokenizing
04:26:47 <CakeProphet> Nope.
04:26:56 <bsmntbombdood> yes
04:27:03 <CakeProphet> esoteric parsers are so magificent they don't even need to parse things.
04:28:29 <oerjan> esoteric languages just run the string directly, searching forward or backward.  At least I _think_ I saw someone trying to do this the other day ;)
04:29:52 <CakeProphet> pretty much... ignoring strings..
04:30:11 <CakeProphet> you want to find the parenthesis you can parse..
04:30:30 <oerjan> There is such a thing as a parenthesis.
04:30:43 <CakeProphet> interpreter it... substitute the results... and parse the next parse-able parenthesis thing.
04:31:06 <CakeProphet> thats's how you would do it non-recursively.
04:31:35 <oerjan> I think there might be a need for a fundamentalist ORK, incorporating such extensions as the "There is no such thing as a" statement.
04:31:43 <CakeProphet> find what matches the base pattern... evaluate it... repeat over and over and over.
04:31:50 <CakeProphet> eventually you'll wear away the recursive-icity.
04:32:30 <oerjan> That is of course what /// does.
04:32:41 <CakeProphet> I've always been interested in data is defined by what it isn't.
04:32:53 <CakeProphet> anti-objects.
04:33:28 <oerjan> There was a thread on anti-objects on Lambda the Ultimate recently.
04:33:37 <CakeProphet> Let's say you have an interpreter that... when run without a program... will compute everything.
04:33:53 <CakeProphet> the program will define what not to compute...
04:34:05 <CakeProphet> so to compute one null you would to manually decompute everything.
04:34:49 <CakeProphet> What's a networking framework?  Well... it's definetely not AI, a parser, time travel, the hello world program, a symbolic manipulator, nor a date simulator.
04:35:01 <CakeProphet> so just make all of those and you'll have your networking framework.
05:29:19 -!- digital_me has quit ("Lost terminal").
05:38:30 -!- CakeProphet has quit (No route to host).
05:44:54 <bsmntbombdood> whoa neat
05:45:03 <bsmntbombdood> http://python.org/doc/lib/compiler.html
05:45:42 <bsmntbombdood> It parses python into syntax trees
05:49:16 <bsmntbombdood> that's awesome
05:49:29 <bsmntbombdood> I think that's the way to modify the print statement
05:50:39 -!- calamari has joined.
05:52:20 <bsmntbombdood> maybe not, though
05:53:22 <bsmntbombdood> You can write python as syntax trees :)
05:54:51 <bsmntbombdood> Function(None, "f", ["x"], [], 0, None, Stmt([Return(Name("x"))]))
05:59:18 <oerjan> You might do a search and replace on "print" in do_exec, inserting >> sys.stdout, if there isn't a >> there already. A bit brittle, perhaps.
06:00:03 <bsmntbombdood> very brittle
06:00:56 <bsmntbombdood> Hacking the compiler would be more fun ;)
06:02:02 <bsmntbombdood> change Stmt([Printnl([Name('x')], None)]) to Stmt([Discard(CallFunc(Getattr(Getattr(Name('sys'), 'stdout'), 'write'), [Name('what')], None, None))])
06:02:12 <bsmntbombdood> er, s/what/x/
06:20:15 -!- calamari has quit ("Leaving").
06:28:23 -!- ShadowHntr has quit (Connection timed out).
07:59:10 -!- Arrogant has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:08:55 -!- oerjan has quit ("leaving").
09:06:35 -!- Arrogant has quit ("Leaving").
10:34:40 -!- ihope__ has joined.
10:35:26 -!- ihope__ has changed nick to ihope.
12:05:10 -!- jix__ has joined.
12:10:11 -!- jix__ has changed nick to jix.
14:57:29 -!- tgwizard has joined.
15:29:20 -!- ngtr has joined.
15:29:59 -!- ngtr has changed nick to andreou.
16:29:12 -!- ihope has quit (Connection timed out).
16:30:13 -!- andreou has changed nick to ngtr.
17:18:49 <SimonRC> bsmntbombdood: Bah.  Many languages are in denial about their need for algebraic datatypes
17:59:53 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
18:31:56 <bsmntbombdood> SimonRC: what?
18:31:58 -!- ShadowHntr has joined.
18:32:19 <oklopol> what were you making earlier?
18:33:13 <oklopol> some kinda parser?
18:34:53 * SimonRC listens to _The News Quiz_.
18:36:23 <SimonRC> bsmntbombdood: Algebraic Datatypes are an enlightening system of describing datastructures.  I much prefer them to classes or structs
18:36:35 <bsmntbombdood> oklopol: A simple parser
18:36:55 <SimonRC> ADTs are great for things like parsers.
18:37:10 <bsmntbombdood> What are they?
18:38:36 <oklopol> for regexes?
18:38:42 <SimonRC> A good start http://en.wikipedia.org/wiki/Algebraic_data_type
18:38:55 <bsmntbombdood> oklopol: no
18:39:02 <oklopol> okay
18:39:11 <bsmntbombdood> oklopol: for nested parentheses
18:39:16 <oklopol> i read it all but i'm half asleep
18:39:16 <oklopol> okay
18:39:16 <SimonRC> ADTs generalise structs and unions, for a start.
18:39:21 <oklopol> that was hard?
18:39:31 <oklopol> just the parenthesis thing?
18:39:43 <bsmntbombdood> oklopol: For someone who knows nothing about parsing, yes
18:39:53 <oklopol> i'll try in python
18:40:03 <SimonRC> bsmntbombdood: waitamo, did you just say you parsed parentheses with a regex?
18:40:07 <oklopol> in c++ that would take 20 min
18:40:11 <bsmntbombdood> SimonRC: no
18:40:28 <SimonRC> Ah, good, I though mathematics might be falling apart.
18:40:57 <bsmntbombdood> nope, oklopol just misread the earlier conversation
18:41:54 <oklopol> i didn't think you used regex for smth, i thought you were making a regex parser
18:43:42 <oklopol> k, does def a(b) take b as a reference if it's int
18:43:47 <oklopol> if b is int i mean
18:43:56 <bsmntbombdood> oklopol: no
18:44:00 <SimonRC> oklopol: which language?
18:44:04 <oklopol> python
18:44:04 <bsmntbombdood> ints are immutable
18:44:11 <oklopol> how do i pass as ref?
18:44:16 <oklopol> [4]?
18:44:19 <oklopol> not 4
18:44:20 <oklopol> a var
18:44:27 <oklopol> that's idiotic
18:44:28 <bsmntbombdood> oklopol: you don't
18:44:29 <SimonRC> (The answer would be yes in QBASIC.)
18:44:38 <bsmntbombdood> SimonRC: Python, I assumed
18:44:38 <oklopol> okay
18:45:04 <oklopol> i can't pass as an int as a ref easily?
18:45:19 <oklopol> okay, then i see where you were having trouble :DD
18:45:27 <oklopol> i'll have to use a stack then
18:45:54 <SimonRC> use a list containging a singel int
18:46:11 <bsmntbombdood> A list works, but it's ugly
18:46:44 <oklopol> i always code ugly with python, it's what python knows best imo
18:47:09 <oklopol> (okay, i just don't grasp functional languages)
18:48:03 <bsmntbombdood> python is functional
18:48:11 <SimonRC> snork
18:48:26 <oklopol> yes, i know
18:48:33 <oklopol> and i don't grasp it
18:48:42 <SimonRC> They are diking out map and rejecting multi-line lambdas
18:48:52 * SimonRC goes to eat dinner.
18:52:20 <bsmntbombdood> SimonRC: I know, it's stupid
18:52:32 <bsmntbombdood> but a list comprehension is just as usable as map
18:54:49 <bsmntbombdood> define map(f,seq): return [f(i) for i in seq]
18:55:06 <oklopol> okay, made it
18:55:11 <oklopol> but did it the ugly way
18:55:30 -!- ngtr has left (?).
18:57:58 -!- andreou has joined.
18:58:49 <andreou> greets
19:01:20 <andreou> greets anyone
19:01:24 <andreou> i'm back from the dead
19:02:19 <andreou> or back into the dead ... no one here?
19:03:03 <oklopol> some
19:04:18 <andreou> heh hey you
19:05:21 <bsmntbombdood> who's andreou ?
19:05:48 <andreou> i frequented the channel a few years ago
19:11:05 <oklopol> is there a pastebin? i have an obsession to share my python code
19:11:31 <bsmntbombdood> pastebin.ca
19:13:13 <oklopol> http://www.pastebin.ca/314421
19:14:54 <oklopol> python really shows you how much you suck when you use the ide since errors hide your code 5 miles up...
19:15:08 <oklopol> infinite recursion errors that is
19:15:58 <oklopol> >>> parentise("I've got (magic in ((my pocket) but) you can't (really have) it",[0])
19:15:59 <oklopol> ["I've", 'got', ['magic', 'in', [['my', 'pocket'], 'but'], 'you', "can't", ['really', 'have'], 'it']]
19:16:05 <oklopol> i'm not sure if that's right
19:16:15 <oklopol> and my algorithm is terrible :)
19:16:32 <oklopol> i iterate everything twice
19:19:41 <oklopol> oh, i forgot the slash
19:21:59 <oklopol> http://www.pastebin.ca/314437
19:22:02 <oklopol> betterz
19:28:00 * bsmntbombdood wonders how closures are implemented
19:29:01 <oklopol> in mine?
19:29:59 <bsmntbombdood> no
19:30:05 <oklopol> but?
19:30:11 <bsmntbombdood> ?
19:30:32 <oklopol> in python?
19:30:47 <bsmntbombdood> in any language
19:34:00 <oklopol> http://bsmntbombdood.mooo.com/testclosure.c
19:34:01 <oklopol> :)
19:34:20 <bsmntbombdood> heh
19:34:25 <bsmntbombdood> I doubt it's like that
19:34:30 <oklopol> i gotta compliment my memory
19:34:51 <bsmntbombdood> very nice
19:35:36 <oklopol> i gotta compliment that more tho, ingenious
19:36:39 <oklopol> thought of generalizing that with templates but never got into doing it
19:37:50 <bsmntbombdood> Hmm, I thought of a way of generalizing that code somewhat
19:38:27 <bsmntbombdood> except no
19:39:17 <oklopol> omg, managed to shut the lights with a throw of a ball
19:39:28 <oklopol> except no why?
19:40:50 <bsmntbombdood> no to the idea I had
19:41:35 <oklopol> okay :D
19:42:02 <oklopol> it could easily do that to any function given the function after it and before it :DD
19:42:40 <oklopol> curry(funcbefore,funcafter,firstvarvalue);
19:43:14 <oklopol> would search first variable in the function, variables being \0xDEADBEE(0,1,2,3,4, etc.) and currying
19:44:08 <oklopol> and return the function of course
19:44:17 <andreou> dhcpd is running as pid 666.
19:44:29 <andreou> this tells things about the upcoming net-installation...
19:45:39 <bsmntbombdood> heh
19:47:37 <andreou> well, has anyone installed debian on an old-world mac using netboot?
19:48:55 <andreou> no? wll, i'm screwed then.
19:57:09 -!- CakeProphet has joined.
20:38:59 <andreou> this deal sucks.
20:43:01 <fizzie> I think I might have, but I don't remember _anything_ about it, and I don't even have the silly box any more. Besides, come to think of it, I think I installed using the tried-and-true method of "move the hd to something more sensible".
20:45:00 <andreou> it's just insane. netbsd goes without a hitch, why not debian as well?
20:45:47 <fizzie> Right, the hd-switching it was. It was the sparc I had to net-boot, it did only "rarp and tftp to the answering rarpd", and it was OpenBSD I was installing. Got confused.
20:46:09 * andreou indulges in a huge piece of spinnach-cheese-pie, putting all the problems behind
20:47:19 <andreou> obsd-sparc goes without a flaw
20:47:30 * andreou has the sparcclassic buzzing to his right as a proof
20:49:46 <andreou> come to think of it, sparcs are very sensible boxes
20:50:02 <andreou> maybe i should just sell or give away all the junk lying around and about and get a U10 or something
20:54:36 <fizzie> I had a sensible sparcstation 5 as a interweb firewall/router box, but it retired when I moved to this 100baseT network, since I didn't want to start looking for suitable sbus cards. It's currently in a closet.
20:55:57 <andreou> eh i'm still on 10baseT, although the previous workstation had GE-grade NICs.
20:56:16 <andreou> threw it out, too many MIPS, too many movies
20:56:26 -!- ihope__ has joined.
20:57:06 -!- ihope__ has changed nick to ihope.
21:21:30 <andreou> today is "can't" day.
21:23:00 <andreou> i'm really waiting for the s/a/u/ day
22:00:48 <Sukoshi> toduy is "cun't" duy
22:00:49 <Sukoshi> There.
22:01:00 <andreou> ;p
22:01:28 <fizzie> There's no trailing g, so isn't it simply "Toduy is "can't" day."? 
22:01:55 <Sukoshi> Oh. True.
22:02:13 <andreou> pedants
22:02:50 <Sukoshi> But it's right, and there's no denying it, and it's a common occurance.
22:16:50 * ShadowHntr has Solaris 10 on his Ultra 5...
22:19:49 <fizzie> Don't they call that "slowlaris"? 
22:20:12 <andreou> a U5 is a perfect non-solaris box
22:21:43 <fizzie> The Ultra 10s (and the few Blade 1000s) in this university run Solaris 10, too.
22:28:54 <bsmntbombdood> you geeks and your non-x86 hardware
22:29:27 <andreou> a matter of pocket, not of brain.
22:29:35 <andreou> though, well...
22:29:52 <bsmntbombdood> I don't have any cool hardware :(
22:30:23 <fizzie> Well, those U10s aren't really mine. And since my SS5 and the Indy are both in the closet, and the old mac is gone, the only non-x86 hardware here in use are the PPC iBooks.
22:31:25 <andreou>  plural? capitalist pig...
22:35:55 <fizzie> The other iBook is my wife's, actually. I could barely afford my own.
22:37:21 <fizzie> I would accept the labeling if they were MacBook Pros or something. :p
22:56:56 -!- digital_me has joined.
22:58:58 <bsmnt_bot> hi digital_me
23:47:54 -!- jix has joined.
23:49:49 -!- jix has quit (Client Quit).
23:50:15 -!- tgwizard has quit (Remote closed the connection).

2007-01-13:

00:49:45 <CakeProphet> hmmm...
00:49:46 <CakeProphet> alright...
00:49:54 <CakeProphet> I'm going to build a hybrid of Python and Lisp.
00:50:11 <CakeProphet> It'll basically look like Python with Lispisms and Lisp syntax.
00:50:13 <bsmntbombdood> fail
00:51:28 <CakeProphet> (an.example of [some stuff for program in lisp-python-hybrid if (build-it True)])
00:54:08 -!- pikhq has joined.
00:59:13 -!- wooby has joined.
01:00:31 <bsmntbombdood> CakeProphet: huh?
01:01:36 -!- digital_me_ has joined.
01:02:28 <oklopol> built-in or build-it?
01:02:49 <oklopol> CakeProphet, i don't wanna be an ass but you typed necessary nessicary again :)
01:11:57 -!- digital_me has quit (Read error: 110 (Connection timed out)).
01:12:12 <andreou> aah... perl is broken on netbsd/macppc pkgsrc
01:12:48 <pikhq> Solution: don't use Perl, the only language where an unobfuscated coding contest is a challenge.
01:13:20 <pikhq> (Malbolge is excepted from that, on account of Malbolge not being an actual *language*)
01:13:38 <andreou> it's a dependency
01:14:05 <pikhq> Like a crack addict? :p
01:15:51 <andreou> w3m demands it
01:16:57 <pikhq> Solution: realise elinks > w3m. ;)
01:18:19 <andreou> elinks?
01:18:30 <andreou> i was going for links-gui
01:19:06 <andreou> i see elinks doesn't support inline images. i'm still going for links-gui and praying.
01:19:25 <andreou> (it seems unix turns one towards god)
01:19:48 <pikhq> That's because Unix is a diety unto itself.
01:20:14 <andreou> en erratic deity
01:20:15 <pikhq> Although it's but a servant of the Most High Editor. ;)
01:20:28 <pikhq> It's Chaotic Neutral, in D&D terms.
01:21:24 <andreou> i'm clueless about D&D, but i'm certain that an old-fashioned lovecraftian banishing would take care of the problematics raised. or an even more old-fashioned luddist reprogramming with an axe.
01:21:30 <andreou> still, i'm bound and attached.
01:21:45 <bsmntbombdood> ~exec self.print_callbacks()
01:22:10 <bsmntbombdood> !exec class foo: pass
01:22:12 <EgoBot> Huh?
01:22:45 <bsmntbombdood> ~exec exec "class foo:\n\tpass\nglobals()["foo"] = foo"
01:22:51 <bsmntbombdood> ~exec sys.stdout(foo)
01:23:08 <bsmntbombdood> ~exec exec "class foo:\n\tpass\nglobals()["foo"] = foo" in globals()
01:23:12 <bsmntbombdood> ~exec sys.stdout(foo)
01:23:26 <bsmntbombdood> ~exec exec "class foo:\n\tpass\nglobals()[\"foo\"] = foo" in globals()
01:23:39 <bsmntbombdood> argh
01:23:45 <bsmntbombdood> ~exec exec "class foo:\n\tpass\n" in globals()
01:23:49 <bsmntbombdood> ~exec sys.stdout(foo)
01:23:49 <bsmnt_bot> __main__.foo
01:23:53 <bsmntbombdood> yes
01:24:00 <bsmntbombdood> ~exec self.foo = foo()
01:24:31 <bsmntbombdood> ~exec self.foo.__class__.f = lambda self : bot.raw("PRIVMSG #esoteric :foo")
01:24:38 <bsmntbombdood> ~exec self.foo.f
01:24:45 <bsmntbombdood> ...
01:25:00 <andreou> foo
01:25:01 <bsmntbombdood> ~exec sys.stdout(self.foo.f)
01:25:02 <bsmnt_bot> <bound method foo.<lambda> of <__main__.foo instance at 0xb7cc5f2c>>
01:25:07 <bsmntbombdood> ~exec self.foo.f()
01:25:08 <bsmnt_bot> foo
01:25:31 <bsmntbombdood> ~exec self.register_raw("abcd foo", self.foo.f)
01:25:47 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
01:25:51 <bsmntbombdood> ~quit
01:25:52 -!- bsmnt_bot has quit.
01:25:55 -!- bsmnt_bot has joined.
01:26:03 <bsmntbombdood> ~exec self.load_callbacks("/bot/test.pickle")
01:26:12 <bsmntbombdood> ~exec self.print_callbacks()
01:26:34 <bsmntbombdood> ~exec self.do_callbacks("abcd foo")
01:26:40 <bsmntbombdood> damn
01:27:14 -!- Sgeo has joined.
01:27:14 <bsmntbombdood> still doesn't work with methods not of IRCbot
01:27:17 <bsmntbombdood> :(
01:28:51 -!- andreou has changed nick to ka-pow.
01:29:00 -!- ka-pow has changed nick to andreou.
01:29:52 <bsmntbombdood> kapow!
01:29:55 <bsmntbombdood> ping ping ping
01:29:59 <bsmntbombdood> pow pow
01:31:51 -!- digital_1e_ has joined.
01:39:54 -!- digital_me_ has quit (Read error: 110 (Connection timed out)).
01:49:27 -!- CakeProphet has quit (Read error: 131 (Connection reset by peer)).
01:49:52 -!- CakeProphet has joined.
01:51:18 <andreou> still drizzling, still compiling
01:54:25 <andreou> and it's four am, time to faint
01:54:32 -!- andreou has quit ("as if it vanished").
01:54:44 <bsmntbombdood> oh crap
01:54:57 <bsmntbombdood> bsmnt_bot doesn't work with private messages
01:55:25 -!- CakeProphet_ has joined.
01:56:02 <bsmntbombdood> My internet is still borked
02:07:47 -!- CakeProphet_ has quit (Read error: 113 (No route to host)).
02:08:09 -!- CakeProphet_ has joined.
02:08:30 -!- CakeProphet has quit (No route to host).
02:08:45 -!- CakeProphet_ has changed nick to CakeProphet.
02:26:11 -!- calamari has joined.
02:33:59 -!- ihope__ has joined.
02:35:26 -!- ihope has quit (Nick collision from services.).
02:35:28 -!- ihope__ has changed nick to ihope.
02:35:39 -!- digital_1e_ has changed nick to digital_me.
03:11:46 -!- ihope has quit (Connection timed out).
03:24:34 -!- CakeProphet has quit (Read error: 113 (No route to host)).
03:24:55 -!- CakeProphet_ has joined.
03:25:02 -!- CakeProphet_ has changed nick to CakeProphet.
04:00:19 -!- digital_me has quit ("Lost terminal").
04:02:12 -!- digital_me has joined.
05:00:46 -!- Sgeo has quit ("Leaving").
05:14:49 -!- pikhq has quit ("leaving").
05:36:23 -!- digital_me has quit ("Lost terminal").
05:53:33 -!- calamari has quit ("Leaving").
06:23:39 -!- wooby has quit.
06:47:37 -!- ShadowHntr has quit (Read error: 110 (Connection timed out)).
07:55:23 -!- oklopol has quit (zelazny.freenode.net irc.freenode.net).
07:55:23 -!- bsmntbombdood has quit (zelazny.freenode.net irc.freenode.net).
07:55:23 -!- Sukoshi has quit (zelazny.freenode.net irc.freenode.net).
07:55:23 -!- puzzlet has quit (zelazny.freenode.net irc.freenode.net).
07:55:23 -!- sekhmet has quit (zelazny.freenode.net irc.freenode.net).
07:58:43 -!- oklopol has joined.
07:58:43 -!- bsmntbombdood has joined.
07:58:43 -!- Sukoshi has joined.
07:58:43 -!- puzzlet has joined.
07:58:43 -!- sekhmet has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:00:24 <CakeProphet> whooo netsplit.
08:52:08 <CakeProphet> hmmm...
08:52:13 <CakeProphet> a language without data structures.
09:45:06 <lament> BASIC.
10:07:56 -!- oerjan has joined.
10:52:25 -!- oerjan has quit ("leaving").
13:30:42 -!- CakeProphet_ has joined.
13:31:48 -!- CakeProphet has quit (Read error: 113 (No route to host)).
13:31:52 -!- CakeProphet_ has changed nick to CakeProphet.
13:36:49 -!- tgwizard has joined.
13:46:45 -!- andreou has joined.
14:11:34 -!- oklofok has joined.
14:12:04 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
14:50:46 -!- Sgeo has joined.
14:55:29 -!- andr- has joined.
14:55:33 -!- andreou has left (?).
14:55:44 -!- andr- has changed nick to andreou.
15:01:46 -!- Sgeo has quit ("Leaving").
15:02:06 -!- Sgeo has joined.
15:12:45 -!- tgwizard has quit (Remote closed the connection).
15:20:49 -!- Rent-A-Tard has joined.
15:22:05 <Rent-A-Tard> Please write "John, I'm only dancing!"
15:22:19 <Rent-A-Tard> Please write the lyrics of "John, I'm only dancing!"*
15:39:36 -!- jix has joined.
15:48:15 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
16:05:41 -!- oklofok has changed nick to oklopol.
16:28:55 -!- digital_me has joined.
16:35:03 -!- pikhq has joined.
16:53:24 <andreou> so,
16:53:37 <andreou> is there still a cat's eye or any other esolang-related website?
16:56:33 <oklopol> http://esolangs.org/wiki/Main_Page
16:57:01 <andreou> thanks
17:15:48 -!- digital_me has quit ("Lost terminal").
17:19:16 <Rent-A-Tard> Please write the lyrics of "John, I'm only dancing!"*
17:19:27 <Rent-A-Tard> Why isn't this working? Please tell me why ;)
17:28:50 <pgimeno> hm
17:29:35 <pgimeno> maybe my last comment in http://esolangs.org/wiki/Talk:IRP should be taken into consideration
17:35:23 <pikhq> Join #irp.
17:36:34 <Rent-A-Tard> !bf +[.+]
17:36:39 <EgoBot> <CTCP>
17:37:11 -!- EgoBot has quit (Excess Flood).
17:37:23 -!- EgoBot has joined.
17:37:54 <Rent-A-Tard> !bf +[>.+<-]
17:38:33 <Rent-A-Tard> !bf ++++++.
17:38:36 <EgoBot> 
17:38:46 <Rent-A-Tard> !bf +++++++++++++++++++++.
17:38:49 <EgoBot> 
17:39:04 <Rent-A-Tard> nice
17:39:20 <pikhq> Learning Brainfuck?
17:40:16 -!- ihope has joined.
17:40:45 <Rent-A-Tard> yeah
17:40:48 <Rent-A-Tard> !bf ++++++++++++[>+++++++>+++++++++>+++>+++++++++<<<<-]>.>----.---.>----.>++++.<<----.>>+++..++++.--------.+++.<<+++.>[>>++>+<<<-]>>------.>.++.<<<<+.>>-----.++.>>.
17:40:51 <EgoBot> The password: "emo"
17:40:55 <Rent-A-Tard> yay!
17:40:56 <Rent-A-Tard> :D
17:41:16 -!- Rent-A-Tard has changed nick to Rent-A-WAY-Tard.
17:48:22 <ihope> There, think that'll stop the Talk:Piet-Q spambots?
17:50:42 <ihope> It's worth a shot, anyway.
17:57:24 * pikhq hugs BFM some more. . .
18:06:40 -!- andreou has quit ("BitchX-1.1-final © 1996-2000 Colten Edwards").
18:10:20 -!- tgwizard has joined.
18:28:39 -!- calamari has joined.
18:48:49 -!- jix has joined.
18:54:09 <pikhq> Ugh. . .
18:54:17 * pikhq sees Calamari, the Squid Boy.
18:54:57 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
18:56:17 -!- andreou has joined.
18:57:10 -!- oerjan has joined.
18:57:46 <calamari> hi pikhq 
19:28:42 -!- andreou has quit ("[BX] Reserve your copy of BitchX-1.1-final for the Nintendo 64 today!").
19:29:22 -!- jix__ has joined.
19:51:46 -!- andreou has joined.
20:00:26 -!- RodgerTheGreat has joined.
20:08:35 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
20:15:00 -!- jix__ has joined.
20:29:30 -!- Sph1nx has joined.
20:35:42 -!- Sph1nx has quit ("äÏ Ó×ÉÄÁÎÉÑ ×ÓÅÍ!").
21:00:08 -!- jix__ has quit (Read error: 110 (Connection timed out)).
21:04:21 -!- jix__ has joined.
21:35:50 -!- Rent-A-WAY-Tard has changed nick to Rent-A-Tard.
21:35:56 <Rent-A-Tard> gimme junkfood.
21:36:27 * oerjan scrapes something out of the garbage can.
21:36:41 * RodgerTheGreat sprinkes on some soy sauce
21:38:44 <Rent-A-Tard> Eats it all.
21:38:47 <Rent-A-Tard> Thank you :)
21:39:02 <oerjan> You're welcome.
21:40:33 * bsmntbombdood smells blood
21:40:54 <oerjan> No no, no blood, just entrails.
21:41:10 <bsmntbombdood> ~ctcp #esoteric ACTION uses /me
21:41:11 * bsmnt_bot uses /me
21:42:04 <oerjan> And _possibly some strange fungi.
21:42:22 <bsmntbombdood> there's fungus among us!
21:42:47 <oerjan> Is it humongous?
21:43:10 <RodgerTheGreat> I could've sworn the fungus in the trash was gone- I saw a huge mound of slime mold crawl away a couple days ago.
21:43:44 <RodgerTheGreat> although I'm not entirely certain that should be reassuring.
21:45:52 <oerjan> I told it to find some other slime to hang out with.
21:46:46 <bsmntbombdood> ~~~~~~~~~~~~~~~~~~~~~~~~~~exec self.raw("")
21:46:51 <bsmntbombdood> ~exec self.raw("")
21:46:57 <RodgerTheGreat> damnit. it probably came back, then.
21:47:18 <oerjan> No no, I saw it head towards the courthouse.
21:47:23 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :this is a boring saturday")
21:47:24 <bsmnt_bot> this is a boring saturday
21:47:28 -!- digital_me has joined.
21:47:35 <RodgerTheGreat> hi, digital_me 
21:48:43 * bsmnt_bot prods digital_me
21:49:38 <andreou> EgoBot do you have a manual?
21:49:56 <oerjan> !help
21:49:59 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
21:50:01 <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
21:50:38 <andreou> !help help
21:50:40 <oerjan> !ps d
21:50:41 <EgoBot> Use: help [command]  Function: displays help on a command, or lists commands
21:50:43 <EgoBot> 1 oerjan: ps
21:50:50 <andreou> !help bf_txtgen
21:50:53 <EgoBot> Use: bf_txtgen <text>  Function: use textgen.java with 1000 generations to generate an efficient BrainFuck text generator.
21:51:04 <oerjan> !daemon cat lazyk i
21:51:08 <EgoBot> While parsing "./tmp/daemon.cat": Invalid character!
21:51:08 <oerjan> !cat Testing
21:51:09 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
21:51:19 -!- EgoBot has joined.
21:51:22 <oerjan> Darn
21:51:28 <andreou> you killed the bot, you bastard
21:51:40 <andreou> nah, it takes to to fake southpark
21:51:43 <bsmntbombdood> ~exec self.register_raw(r"\S+ PRIVMSG (\S+) :~help", lambda x, y: bot.raw("PRIVMSG %s :no one can help you" % y.group(1)))
21:51:46 <bsmntbombdood> ~help
21:51:47 <bsmnt_bot> no one can help you
21:52:00 <oerjan> We do that all the time.  I guess we should name it Kenny.
21:52:02 <bsmntbombdood> :)
21:52:18 <andreou> !bf_textgen a shorty
21:52:20 <EgoBot> Huh?
21:52:45 <oerjan> I don't know why it didn't accept that lazyk program.
21:52:49 <andreou> !bf_txtgen shorty
21:52:56 <bsmntbombdood> ~exec self.save_callbacks("/bot/test.pickle")
21:53:08 <andreou> !help ps
21:53:10 <EgoBot> Use: ps  Function: display the current processes
21:53:26 <EgoBot> 66 +++++++++++++[>+++++++++>++++++++>><<<<-]>--.>.<----.+++.++.+++++. [810]
21:53:41 <andreou> !ps
21:53:43 <EgoBot> 1 andreou: ps
21:53:49 <oerjan> I see it doesn't mention the d option to ps.
21:54:05 <bsmntbombdood> !exec sys.stderr(open("/bot/test.pickle").read())
21:54:07 <EgoBot> Huh?
21:54:12 <bsmntbombdood> ~exec sys.stderr(open("/bot/test.pickle").read())
21:54:18 <andreou> !bf_txtgen bereshith bara elohim eth ha-shamayim ve-eth ha-aretz
21:54:36 <andreou> !ps
21:54:37 <EgoBot> 1 andreou: bf_txtgen
21:54:39 <EgoBot> 2 andreou: ps
21:54:56 <bsmntbombdood> What's a good rate limiting algorithm for my bot?
21:55:07 <andreou> rate limiting?
21:55:21 <bsmntbombdood> so it doesn't send too fast
21:55:24 <oerjan> Well, you could use the limit in the original IRC RFC I guess:
21:55:41 <bsmntbombdood> and excess flood and die
21:55:51 <oerjan> Max 1 message every other second.
21:56:03 <andreou> well dcc doesn't flood
21:56:06 <bsmntbombdood> that's not very many messages
21:56:08 <oerjan> (1/2)
21:56:17 <EgoBot> 364 ++++++++++++++[>++++++++>+++++++>++++++++>++<<<<-]>>.+++.>++.<.<+++.>+++.>---------.<<+.>.>>++++.<-------.-.<<--.>>.>.<++++.<++++.+++.>+++.+.<--.>>.<<--------.<++.>+++.>>.<-.-------.>+++++++++++++.<<<-.>.>.<<------.>>.<<++++++++++++.>+.++++.>>-------------.<<<---.>>++++.>+++++++++++++.<.<+++++++.>+++.>-------------.<.-------.>+++++++++++++.<.<--.>++++.<++.<++++. [861]
21:56:35 <oerjan> But with a 10 second leeway.
21:56:36 <andreou> hell, i wish i had GPM so i could c&p the code
21:56:38 <bsmntbombdood> ~ps
21:56:39 <bsmnt_bot> 0: 'sys.stderr(open("/bot/test.pickle").read())', 146.41 seconds
21:56:42 <bsmntbombdood> ~kill 0
21:56:48 <bsmntbombdood> ~ps
21:56:49 <bsmnt_bot> None
21:56:53 <bsmntbombdood> yay, it worked
21:57:40 <bsmntbombdood> right now IRCFileWrapper does "if lines_sent > 3: time.sleep(lines_sent/10.)"
21:59:41 <Rent-A-Tard> What're you discussing?
22:00:03 <Rent-A-Tard> I love crashing EgoBot
22:00:04 <bsmntbombdood> I'll change it to time.sleep(max([lines_sent/10., 2])
22:00:07 <bsmntbombdood> Rent-A-Tard: my bot
22:00:23 <Rent-A-Tard> !bf +[.+]
22:00:26 <EgoBot> <CTCP>
22:00:28 <Rent-A-Tard> Ahh
22:00:40 <Rent-A-Tard> What is it supposed to do?
22:00:52 <bsmntbombdood> nothing except execute python, right now
22:00:58 -!- EgoBot has quit (Excess Flood).
22:01:02 <bsmntbombdood> s/nothing/nothing but/
22:01:09 <bsmntbombdood> er
22:01:11 <Rent-A-Tard> A
22:01:13 -!- EgoBot has joined.
22:01:14 <Rent-A-Tard> •a
22:01:19 <Rent-A-Tard> a
22:01:42 <Rent-A-Tard> !bf +[.+]
22:01:46 <EgoBot> <CTCP>
22:01:49 <bsmntbombdood> Rent-A-Tard: you can execute some python code with "~exec $code"
22:02:18 -!- EgoBot has quit (Excess Flood).
22:02:19 <oerjan> !ps d
22:02:25 <oerjan> Whoops
22:02:33 -!- EgoBot has joined.
22:02:36 <oerjan> !ps d
22:02:40 <andreou> is it the +[.+]?
22:02:41 <EgoBot> 1 oerjan: ps
22:02:49 <oerjan> Yep.
22:02:51 <bsmntbombdood> andreou: yeah
22:02:58 <andreou> well, let's stop it then.
22:03:10 <bsmntbombdood> ~exec while True: self.raw("")
22:03:10 -!- bsmnt_bot has quit (Excess Flood).
22:03:11 <oerjan> Note that the default bf is the 16-bit one, I believe.
22:03:14 <Rent-A-Tard> ~ps help
22:03:15 <Rent-A-Tard> ^^
22:03:36 <bsmntbombdood> heh
22:03:39 <oerjan> !daemon cat lazyk -e i
22:03:42 -!- bsmnt_bot has joined.
22:03:42 <EgoBot> While parsing "./tmp/daemon.cat": Invalid character!
22:03:47 <Rent-A-Tard> !bf +[.+]
22:03:51 <EgoBot> <CTCP>
22:03:53 <andreou> goddamn, what the hell has bush to do with ecology and, more importantly, on my radio?
22:04:01 <bsmntbombdood> ~exec while True: self.raw("")
22:04:02 -!- bsmnt_bot has quit (Excess Flood).
22:04:04 -!- bsmnt_bot has joined.
22:04:07 <bsmntbombdood> that's fun :)
22:04:09 <oerjan> Gah, just doesn't work.
22:04:14 <andreou> Rent-A-Tard comeon, stop it. it beeps every time i switch to this screen
22:04:22 -!- EgoBot has quit (Excess Flood).
22:04:33 -!- EgoBot has joined.
22:04:37 <Rent-A-Tard> okay
22:04:47 <oerjan> !daemon cat ,[.,]
22:04:53 <Rent-A-Tard> I'll design something else
22:05:02 <oerjan> !cat Let's do it the usual way.
22:05:04 <Rent-A-Tard> !bf ++++++++++++[>+++++++>+++++++++>+++>+++++++++<<<<-]>.>----.---.>----.>++++.<<----.>>+++..++++.--------.+++.<<+++.>[>>++>+<<<-]>>------.>.++.<<<<+.>>-----.++.>>.
22:05:06 <EgoBot> Huh?
22:05:10 <EgoBot> The password: "emo"
22:05:11 <Rent-A-Tard> I just wrote that up...
22:05:16 <Rent-A-Tard> Yay!
22:05:19 <Rent-A-Tard> It works!
22:05:27 <oerjan> !daemon cat bf ,[.,]
22:05:36 <oerjan> !cat Now then.
22:05:37 <bsmntbombdood> ~exec for i in xrange(1000): sys.stderr(i)
22:05:38 <EgoBot> Now then.
22:05:50 -!- bsmnt_bot has quit (Excess Flood).
22:05:52 -!- bsmnt_bot has joined.
22:05:53 <bsmntbombdood> finally
22:06:01 <bsmntbombdood> it took 10 messages
22:06:11 <bsmntbombdood> s/10/11/
22:07:20 <oerjan> You should also do a test with a sleep in it.
22:07:31 <bsmntbombdood> ...?
22:07:36 <bsmntbombdood> go ahead
22:08:01 <Rent-A-Tard> !bf  
22:08:01 <Rent-A-Tard> >++>+++++[<[<++>-]<[>+<-]>>-]<<.
22:08:37 <Rent-A-Tard> !bf >++>+++++[<[<++>-]<[>+<-]>>-]<<.
22:08:40 <bsmntbombdood> oops
22:08:42 <oerjan> I don't know the Python syntax for sleep. Or the unit.
22:08:52 <Rent-A-Tard> !bf >++>+++++[<[<++>-]<[>+<-]>>-].
22:08:55 <Rent-A-Tard> !bf >++>+++++[<[<++>-]<[>+<-]>>-]<.
22:08:58 <EgoBot> @
22:09:03 <bsmntbombdood> IRCFileWrapper.write had a sleep(.2) in it
22:09:06 <bsmntbombdood> ~quit
22:09:06 -!- bsmnt_bot has quit (Client Quit).
22:09:08 -!- bsmnt_bot has joined.
22:09:10 <bsmntbombdood> ~exec for i in xrange(1000): sys.stderr(i)
22:09:11 -!- bsmnt_bot has quit (Excess Flood).
22:09:13 -!- bsmnt_bot has joined.
22:09:16 <Rent-A-Tard> !bf >+++>+++++[<[<++>-]<[>+<-]>>-]<.
22:09:20 <EgoBot> `
22:09:21 <bsmntbombdood> that only took 3 messages
22:09:55 <bsmntbombdood> ~exec for i in xrange(1000): sys.stderr("\n" * i)
22:09:58 <oerjan> Not reliable then.
22:10:09 <bsmntbombdood> ~ps
22:10:10 <bsmnt_bot> None
22:10:12 <Rent-A-Tard> !bf >+>+++++[<[<++>-]<[>+<-]>>-]<.
22:10:14 <bsmntbombdood> ~exec for i in xrange(1000): sys.stderr("a\n" * i)
22:10:14 <EgoBot>  
22:10:35 -!- ShadowHntr has joined.
22:10:40 <Rent-A-Tard> !bf >+++>++++[<[<++>-]<[>+<-]>>-]<.
22:10:42 <bsmntbombdood> ~kill 0
22:10:44 <EgoBot> 0
22:10:46 <Rent-A-Tard> !bf >+++>++++[<[<++>-]<[>+<-]>>-].
22:10:50 <bsmntbombdood> ~ps
22:11:04 <bsmntbombdood> erm
22:11:05 <Rent-A-Tard> !bf >+++>++++[<[<++>-]<[>+<-]>>-]<<.
22:11:13 <bsmnt_bot> None
22:11:28 <oerjan> Hmm...
22:11:35 <bsmntbombdood> ~exec for i in xrange(1000): sys.stderr(("%s\n" % i) * i)
22:11:39 <Rent-A-Tard> !bf >+++>++++[<[<++>-]<[>+<-]>>-]<<.
22:11:47 <oerjan> !daemon lion lazyk
22:11:55 <oerjan> !lion Testing
22:11:58 <EgoBot> Huh?
22:12:42 <oerjan> The lazyk setup is broken.
22:12:58 <bsmntbombdood> well, my rate limiting works so far
22:13:02 <bsmntbombdood> up to 9 lines
22:14:07 <oerjan> My timing suggestion was to find out how quickly you can spam continuously :)
22:14:14 * pikhq recommends Rent-A-Tard play with BFM. . .
22:14:16 <bsmntbombdood> 3 messages
22:14:23 <bsmntbombdood> oh
22:14:27 <bsmntbombdood> ~ps
22:14:29 <pikhq> It's a very good method for making complex Brainfuck programs. ;)
22:14:42 <pikhq> http://pikhq.nonlogic.org/bfm.tar.bz2
22:14:45 <bsmntbombdood> ~kill 0
22:14:49 <pikhq> (end shameless plug)
22:14:57 <calamari> oerjan: it's hard to know for sure.. sometimes messages get delayed then you get a flood
22:15:14 -!- bsmnt_bot has quit (Remote closed the connection).
22:15:17 -!- bsmnt_bot has joined.
22:15:54 <bsmntbombdood> ~exec for i in xrange(1000): self.raw("PRIVMSG #bsmnt_bot_errors :%s" % i )
22:15:55 -!- bsmnt_bot has quit (Excess Flood).
22:15:57 -!- bsmnt_bot has joined.
22:16:03 <bsmntbombdood> ~exec for i in xrange(1000): self.raw("PRIVMSG #bsmnt_bot_errors :%s" % i)
22:16:03 -!- bsmnt_bot has quit (Excess Flood).
22:16:06 -!- bsmnt_bot has joined.
22:16:08 <bsmntbombdood> weird
22:16:16 <bsmntbombdood> no messages even got sent to the channel
22:16:28 <bsmntbombdood> ~exec for i in xrange(1000): time.sleep(.1); self.raw("PRIVMSG #bsmnt_bot_errors :%s" % i)
22:16:35 -!- bsmnt_bot has quit (Excess Flood).
22:16:37 -!- bsmnt_bot has joined.
22:16:39 <bsmntbombdood> 8
22:16:45 <bsmntbombdood> ~exec for i in xrange(1000): time.sleep(.2); self.raw("PRIVMSG #bsmnt_bot_errors :%s" % i)
22:16:57 -!- bsmnt_bot has quit (Excess Flood).
22:17:00 -!- bsmnt_bot has joined.
22:17:00 <bsmntbombdood> 11
22:17:04 <bsmntbombdood> ~exec for i in xrange(1000): time.sleep(.3); self.raw("PRIVMSG #bsmnt_bot_errors :%s" % i)
22:17:24 -!- bsmnt_bot has quit (Excess Flood).
22:17:26 -!- bsmnt_bot has joined.
22:17:27 <bsmntbombdood> 14
22:17:37 <bsmntbombdood> ~exec for i in xrange(1000): time.sleep(.4); self.raw("PRIVMSG #bsmnt_bot_errors :%s" % i)
22:18:05 -!- bsmnt_bot has quit (Excess Flood).
22:18:08 -!- bsmnt_bot has joined.
22:18:11 <bsmntbombdood> 19
22:18:31 <bsmntbombdood> aaw, it was looking like a nice additive sequence there
22:18:37 <bsmntbombdood> ~exec for i in xrange(1000): time.sleep(.5); self.raw("PRIVMSG #bsmnt_bot_errors :%s" % i)
22:19:05 <oerjan> Well it shouldn't be, after all _some_ sleep should allow it to continue indefinitely.
22:19:14 -!- bsmnt_bot has quit (Excess Flood).
22:19:16 <bsmntbombdood> yeah
22:19:17 -!- bsmnt_bot has joined.
22:19:22 <bsmntbombdood> that was 23
22:19:29 <bsmntbombdood> ~exec for i in xrange(1000): time.sleep(.7); self.raw("PRIVMSG #bsmnt_bot_errors :%s" % i)
22:20:28 -!- bsmnt_bot has quit (Excess Flood).
22:20:30 -!- bsmnt_bot has joined.
22:20:32 <bsmntbombdood> 34
22:20:38 <bsmntbombdood> ~exec for i in xrange(1000): time.sleep(.9); self.raw("PRIVMSG #bsmnt_bot_errors :%s" % i)
22:20:45 <oerjan> Nice and linear...
22:21:06 <oerjan> I guess 46 :)
22:22:07 -!- bsmnt_bot has quit (Excess Flood).
22:22:10 -!- bsmnt_bot has joined.
22:22:12 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:22:13 <bsmntbombdood> 49
22:22:20 <oerjan> Hmm..
22:22:26 <bsmntbombdood> ~exec for i in xrange(1000): time.sleep(1.1); self.raw("PRIVMSG #bsmnt_bot_errors :%s" % i)
22:24:34 -!- bsmnt_bot has quit (Excess Flood).
22:24:37 -!- bsmnt_bot has joined.
22:26:26 <bsmntbombdood> 68
22:26:33 <bsmntbombdood> ~exec for i in xrange(1000): time.sleep(1.5); self.raw("PRIVMSG #bsmnt_bot_errors :%s" % i)
22:27:35 <andreou> btw does python still have a lambda or was it removed?
22:27:43 <bsmntbombdood> still does
22:31:32 <pikhq> Is Python still not a Lisp?
22:31:41 -!- bsmnt_bot has quit (Excess Flood).
22:31:44 -!- bsmnt_bot has joined.
22:31:51 <bsmntbombdood> 158 messages
22:32:36 * bsmntbombdood can't remember the way to use and/or as if/else
22:33:12 <oerjan> (x and y) or z
22:33:19 <bsmntbombdood> y is false
22:33:37 <oerjan> (x and (y or True)) or z
22:33:55 <bsmntbombdood> then y doesn't get returned
22:35:15 <CakeProphet> hmmm
22:35:31 <bsmntbombdood> oh, i know, i can reverse my conditions
22:36:00 <CakeProphet> Python has conditional expressions.
22:36:31 <bsmntbombdood> Only in 2.5, and that's lame
22:37:40 <bsmntbombdood> ~quit
22:37:41 -!- bsmnt_bot has quit.
22:37:43 -!- bsmnt_bot has joined.
22:37:50 <bsmntbombdood> now the rate limit is adjustable
22:38:18 <bsmntbombdood> ~exec sys.stdout("foo")
22:38:18 <bsmnt_bot> foo
22:38:33 <bsmntbombdood> ~exec sys.stdout("foo\n")
22:38:33 <bsmnt_bot> foo
22:38:36 <bsmntbombdood> good
22:38:42 <oerjan> [(lambda : y),(lambda : z)]((x and 1) or 2)-1)()
22:39:15 <bsmntbombdood> hot damn!
22:39:22 <bsmntbombdood> and oerjan takes the prize!
22:39:31 <oerjan> For extreme situations :)
22:39:48 <bsmntbombdood> except the syntax isn't quite right
22:40:42 <pikhq> !exec sys.stderr("Obey me!")
22:40:46 <EgoBot> Huh?
22:40:51 <pikhq> ~exec sys.stderr("Obey me!")
22:40:56 <pikhq> You know what I mean.
22:41:03 <bsmntbombdood> pikhq: sys.stdout goes here
22:41:13 <pikhq> bsmntbombdood: And sys.stderr goes nowhere.
22:41:26 <bsmntbombdood> no, sys.stderr goes the #bsmnt_bot_errors 
22:41:32 <pikhq> Ah.
22:42:51 <oerjan> I forgot a (, what else?
22:42:58 <bsmntbombdood> oerjan:  [(lambda : y),(lambda : z)][((x and 1) or 2) - 1]()
22:43:16 <bsmntbombdood> is what it should be
22:43:38 <bsmntbombdood> very clever
22:44:28 <bsmntbombdood> you could probably take out the lambdas though
22:44:42 <bsmntbombdood> [y,z][((x and 1) or 2) - 1]
22:44:59 <oerjan> Not if you want it to short-circuit the y and z expressions.
22:45:08 <bsmntbombdood> right
22:46:39 <bsmntbombdood> I just switched my condition and did self.rate_limit = rate_limit or (lambda x : (x > 3 and min([(x-2)/10., 2])) or 0)
22:47:44 <bsmntbombdood> good old lisp :/
22:47:46 <oerjan> Yes, the sledgehammer is only needed if both branches can be false.
22:47:50 <bsmntbombdood> (if x y z)
22:48:29 <bsmntbombdood> no need for this crazyness
22:58:26 -!- Rent-A-Tard has quit (Read error: 131 (Connection reset by peer)).
23:00:47 -!- pmhaddad has joined.
23:01:26 -!- pmhaddad has left (?).
23:02:59 -!- wooby has joined.
23:22:21 <bsmntbombdood> FOOO
23:24:03 <pikhq> BAR
23:24:22 <bsmntbombdood> BAZ
23:24:39 <pikhq> QUX
23:25:08 <bsmntbombdood> EGGS
23:25:23 <pikhq> YOU BORK THE PATTERN
23:25:30 <oerjan> MAYONAISE
23:26:10 * pikhq thinks of a way to get target-language specific implementations of macros in BFM. . .
23:26:27 <bsmntbombdood> there's more than one target language?
23:26:41 <pikhq> My personal build targets C, Tcl, and Brainfuck.
23:26:54 <pikhq> (the interpreter just compiles to Tcl and executes that)
23:27:08 <pikhq> Well, that's not *entirely* true.
23:27:19 <bsmntbombdood> I should write a compiler
23:27:35 <pikhq> It compiles to a simplified BFM subset, which can be interpreted by a Tcl interpreter with the right procs in place.
23:29:52 <bsmntbombdood> What language should I write a compiler for
23:29:59 <pikhq> BFM.
23:30:23 <oerjan> Homespring.
23:30:37 <bsmntbombdood> Homespring?
23:30:57 <oerjan> A very fishy language.
23:31:04 <pikhq> Indeed.
23:32:50 <pikhq> Compile Homespring to BFM!
23:33:08 <RodgerTheGreat> ,powers<
23:33:14 <pikhq> Or maybe just make a Brainfuck interpreter in Homespring.
23:33:29 <pikhq> (it has yet to be proven Turing complete)
23:33:36 <RodgerTheGreat> how about a homespring interpreter in BF?
23:33:53 <pikhq> That's less evil.
23:34:01 <RodgerTheGreat> you'd have to build some tricky data structures to do it properly
23:34:23 <pikhq> But at least it's *possible*.
23:34:24 <RodgerTheGreat> has anyone made a good tree implementation in BF?
23:34:51 <pikhq> Implementing any Turing complete language in Homespring may very well be impossible.
23:34:53 <RodgerTheGreat> ooh. they'd be *trivial* in Def-BF
23:34:53 <bsmntbombdood> I want a language that's more than turing complete
23:35:21 <oerjan> There are a few on the wiki.
23:35:37 <pikhq> bsmntbombdood: You want an oracle machine?
23:35:44 <bsmntbombdood> WHat's that?
23:35:48 <RodgerTheGreat> the only problem is that they tend to lack implementation
23:35:58 <RodgerTheGreat> bsmntbombdood: it isn't a machine, I'll tell you that
23:36:30 <pikhq> It's like a Turing machine, except it's got an oracle for telling the Turing machine the solution to a certain set of problems that are unsolvable by a Turing machine.
23:36:36 <bsmntbombdood> It would be possible to simulate it though, wouldn't it?
23:36:53 <RodgerTheGreat> bsmntbombdood: no. that's the entire point.
23:36:59 <pikhq> For example, consider a Turing machine with a halting oracle.
23:37:05 <RodgerTheGreat> an oracle cannot be a deterministic device.
23:37:17 <pikhq> This oracle could tell the machine if a certain program halts.
23:37:23 <pikhq> The machine itself could *not*.
23:37:46 <bsmntbombdood> can an x86 proccesor be implemented in a turing machine?
23:38:03 <RodgerTheGreat> of course
23:38:14 <RodgerTheGreat> but an x86 processor can't be an oracle
23:38:18 <oerjan> There are some uses of oracles in complexity theory where you put an oracle on a machine _weaker_ than Turing-complete.  Then the result may still be implementable.
23:38:18 <pikhq> bsmntbombdood: Of course. An x86 processor is, after all, Turing complete (with the exception of addressing restrictions).
23:38:40 <bsmntbombdood> pikhq: An oracle machine is turing complete, but a turing machine can't implement it
23:39:02 <RodgerTheGreat> it's not just turing complete, it's *super*-turing
23:39:11 <pikhq> bsmntbombdood: An oracle machine is super-Turing.
23:39:25 <bsmntbombdood> Well I was thinking that a normal proccesor might be more than turing complete
23:39:29 <pikhq> I'm listing the largest computational class that each machine is a member of.
23:39:52 <pikhq> A normal CPU's capabilities are a *subset* of the Turing machine's.
23:39:57 <RodgerTheGreat> bsmntbombdood: you may not completely understand the meaning of turing-completeness
23:40:12 <bsmntbombdood> I might not
23:40:27 <pikhq> bsmntbombdood: A turing-complete system can calculate anything that can be described as a deterministic algorithm.
23:40:27 <RodgerTheGreat> I'd advise you to read up on it- the wiki article on the subject is fascinating reading
23:41:57 <bsmntbombdood> pikhq: Then I understand the meaning of turing completeness
23:42:04 <RodgerTheGreat> this is what Alan turing had to say about oracles- "Let us suppose that we are supplied with some unspecified means of solving number-theoretic problems; a kind of oracle as it were. We shall not go any further into the nature of this oracle apart from saying that it cannot be a machine" (Undecidable p. 167, a reprint of Turing's paper Systems of Logic Based On Ordinals)."
23:42:42 <pikhq> RodgerTheGreat: His thoughts were not entirely correct.
23:42:54 <RodgerTheGreat> in what sense?
23:42:55 <pikhq> A quantum oracle could, in fact, be a machine.
23:43:04 <pikhq> The same for a real-RNG oracle.
23:43:25 <RodgerTheGreat> quantum operations have not been *proven* to be non-deterministic.
23:43:34 <oerjan> A quantum computer is not super-Turing as far as we know.
23:43:46 <oerjan> Non-determinism is not enough for super-Turing.
23:43:59 <pikhq> But my point for real-RNG oracles?
23:44:11 <RodgerTheGreat> oerjan: but it is at the very least a requisite for creating an oracle
23:44:51 <pikhq> Near as I can fathom, real RNGs could not be created via a deterministic algorithm.
23:45:23 <oerjan> Oracles are in fact deterministic by the usual definition: They always give the same answer to the same question.
23:45:33 <RodgerTheGreat> which would further imply that they could not be created via a deterministic system
23:46:55 <RodgerTheGreat> if a machine always gave the same answer to the same question, then it would be deterministic in the sense that it's behavior was governed by a predictable system
23:47:40 <pikhq> oerjan: A RNG oracle wouldn't be deterministic.
23:48:03 <pikhq> It wouldn't always give the same answer to the question "What is a random number I could use?".
23:48:50 <oerjan> However, a RNG oracle would not increase a Turing machine's ability to solve problems with well-definite answers.
23:49:26 <RodgerTheGreat> that's because it's an entirely different kind of device
23:49:32 <pikhq> It wouldn't increase the ability to solve *deterministic* algorithms, but it would give the ability to solve some *nondeterministic* algorithms.
23:49:43 <oerjan> Because a Turing machine always has the option of calculating _all_ possible paths.
23:49:43 <RodgerTheGreat> but both are examples of a super-turing machine
23:50:17 <pikhq> Since it can do something a plain ol' Turing machine can't, it is, by definition, super-Turing.
23:50:36 <oerjan> I suppose.
23:51:00 <RodgerTheGreat> I'm just pointing out that random oracles and halting oracles are seperate types of devices
23:51:39 <pikhq> RodgerTheGreat: They differ in that one could be built, and another could *not*.
23:51:39 <RodgerTheGreat> a random oracle won't help you solve the halting problem, but it *can* do something a turing machine can't
23:51:50 <bsmntbombdood> Can't you solve the halting problem by just running it?
23:52:11 <pikhq> bsmntbombdood: The halting problem has been proven to not be solvable by a Turing machine.
23:52:24 <oerjan> No, because the Turing machine needs to halt with an answer, even if the program doesn't.
23:52:37 <bsmntbombdood> oh, right
23:52:40 <RodgerTheGreat> you can solve the halting problem in limited instances. You cannot solve the halting problem for a nontrivial program in a nontrivial amount of time
23:53:27 <pikhq> In addition, a Turing machine with a halting oracle can't solve the halting problem for any arbitrary algorithm running on itself.
23:54:12 <bsmntbombdood> in a pure functional language, can the compiler easily (not NP complete) determine the inverse of a function?
23:54:30 <RodgerTheGreat> that would require a more powerful oracle, resulting in an infinite regression- rather like the homonculus theory of consciousness.
23:55:18 <oerjan> bsmntbombdood: Not easily, no.
23:55:27 <RodgerTheGreat> an oracle can't solve the halting problem for a machine incorporating itself, but it may be able to solve the halting problem for another oracle.
23:55:56 <oerjan> And the pure functionality hasn't really got anything to do with it.
23:56:09 <bsmntbombdood> oerjan: yeah it does
23:56:13 <pikhq> RodgerTheGreat: Exactly.
23:56:14 <oerjan> Apart from the function you are taking inverses of, I presume.
23:56:18 <bsmntbombdood> it would be impossible to do in a function with side effects
23:56:33 <bsmntbombdood> s/in a/for a/
23:57:47 <pikhq> I can come up with an example of a pure function that is uninvertable at all. ;)
23:57:56 <oerjan> Are we assuming that the function is one-to-one?  If not then I believe finding an inverse of a polynomial-time function is in fact at least NP-complete.
23:58:01 <pikhq> mod10(x) returns x mod 10.
23:58:24 <bsmntbombdood> pikhq: not one to one
23:58:31 <oerjan> If it is one-to-one then it may be somewhat simpler than NP-complete, I believe that is an unsolved problem.
23:58:42 <pikhq> bsmntbombdood: I'm not thinking ATM. . .
23:58:49 <bsmntbombdood> The inverse could be a set for not one to one functions though
23:59:27 <oerjan> I came upon that issue on Wikipedia when investigating Sudoku. (In a sense the article there is subtly wrong)

2007-01-14:

00:00:08 <oerjan> Well, showing that an inverse _exists_ for a point is precisely NP-complete.
00:00:25 <oerjan> Finding _all_ inverses may be more than NP-complete.
00:00:55 <bsmntbombdood> Can't it do it the math way?
00:01:36 <oerjan> (All this assuming that the original function is polynomial-time, otherwise you would need N-something else.
00:02:53 <pikhq> bsmntbombdood: Sure, if the function is invertable.
00:03:40 <bsmntbombdood> aren't all pure functions invertable?
00:03:51 <bsmntbombdood> assuming you can return a set for non-one to one functions
00:04:02 <oerjan> Of course not.  There are _constant_ functions!
00:04:39 <bsmntbombdood> return the set of all possible inputs, then
00:04:54 <oerjan> OK then.  That is the inverse as a relation.
00:04:54 <bsmntbombdood> use minimal executation or whatever haskell calls it
00:04:59 <pikhq> The inverse would, obviously, not be a function. ;)
00:05:40 <oerjan> Lazy.  It won't help in the least.  As I say, determining whether the inverse set is non-empty _is_ NP-complete if the original function is in P.
00:06:29 <oerjan> I mean, for general P functions.  Not every single one, of course.
00:07:32 <oerjan> Hmm, there is a subtlety there.
00:08:06 <oerjan> It could in fact be worse, if the inverses may be much larger than the function value.
00:08:16 -!- wooby has quit.
00:10:31 <oerjan> What you are asking in essence boils down to whether purely functional languages can easily solve NP-complete problems (the answer being no).
00:11:50 <oerjan> On the other hand, a purely functional language will allow you to write easily down an expression for the inverse.  It's just not going to execute very fast.
00:14:12 <oerjan> You might want to read the recent Good Math/Bad Math blog thread about P/NP.  The issue of defining NP by checking answers is very relevant to your question.
00:15:10 <oerjan> Enough spamming :)
00:17:24 <bsmntbombdood> hmph
00:18:05 <bsmntbombdood> Shouldn't you be able to do it algebraicly?
00:18:48 <oerjan> But solving boolean equations is NP-complete.
00:19:45 <bsmntbombdood> What do you mean boolean equations?
00:20:19 <oerjan> Equations using True, False, and, or, not.
00:20:33 <bsmntbombdood> hrm
00:22:01 <oerjan> Put it another way:  When you "simplify" algebraic equations, in numbers or booleans, the expressions can blow up exponentially in size.
00:23:26 <oerjan> Just try to write out (a+1)(b+1)(c+1)...(z+1) using the distributive law...
00:23:46 <bsmntbombdood> yeah
00:24:20 <oerjan> If they didn't, then you would have an easy proof of P=NP.
00:25:40 <bsmntbombdood> Next I get asked to solve an equation in math class i'll say that it's NP and NP is too hard
00:25:43 <bsmntbombdood> :P
00:25:59 <oerjan> Heh :)
00:26:40 <oerjan> In fact if you were to ask for _integer_ solutions to your equations then it would not be just NP, but Turing-complete.
00:27:09 <bsmntbombdood> heh, a language based on it
00:30:39 <bsmntbombdood> I should write some kind of interpreter for my calculator
00:44:22 * bsmntbombdood feels like learning haskell
00:44:45 <bsmntbombdood> what's a good tutorial?
00:44:53 <andreou> all the useless things we do with our time
00:47:29 <oerjan> Check out www.haskell.org
00:47:55 <oerjan> I see they have changed their main page style since last I was there...
00:48:42 * bsmntbombdood reads http://www.cs.utah.edu/~hal/docs/daume02yaht.pdf
00:49:11 <andreou> mercury caused many revamps last year
00:50:01 <oerjan> mercury? on the haskell wiki?
00:50:20 -!- ihope has quit (Read error: 110 (Connection timed out)).
00:50:28 <andreou> mercury, in the skies
00:50:34 <bsmntbombdood> lazy evaluation sounds really neat
00:51:35 <oerjan> It is, although it has some bad effects such as it being very hard to reason about memory use.
00:53:31 <oerjan> Are we talking astronomy or astrology?
00:54:24 <pikhq> Yes.
00:54:57 <oerjan> Now that clears it up.
00:55:25 <andreou> astrology, of course, couldn't be any other way in #esoteric 
00:55:47 <oerjan> Well it could be mythology too.
00:56:01 <andreou> man, it's not a /myth/
00:56:12 <oerjan> Religion then.
00:56:28 <andreou> i have hard facts & proofs
00:57:06 <andreou> ("my guru said so")
00:57:11 <oerjan> And, more importantly and what confused me initially, it could have been the programming language Mercury, a logic language with much inheritance from Haskell.
00:57:23 <andreou> ah curious coincidence
00:57:34 <oerjan> Syncronicity!
00:57:39 <andreou> btw has anyone managed to get goedel to work? or, at least, steal its gramar and re-implement it?
00:57:42 <oerjan> There are no coincidences :)
00:57:50 <andreou> *grammar
00:58:35 <oerjan> Haven't looked at that.
00:59:30 <bsmntbombdood> gah
00:59:40 <bsmntbombdood> no parentheses in haskell bugs me
00:59:53 <oerjan> You can add parentheses all you want :)
00:59:57 <bsmntbombdood> I know
01:00:08 <bsmntbombdood> sqrt 4*2 => 4.0
01:00:11 <oerjan> But I tend to get rid of as many as possible, using $
01:00:16 <bsmntbombdood> that just doesn't make sense
01:00:26 <bsmntbombdood> oerjan: I don't know what $ is
01:00:37 <oerjan> Ah for functions.
01:00:51 <oerjan> You will note that math does the same for sin and cos.
01:01:26 <oerjan> Well, sqrt $ 4*2 => 2.8...
01:02:31 <oerjan> When you want to apply a function to something complicated, you can use $ instead of spaces.
01:02:45 <bsmntbombdood> does anything bind more tightly than function application?
01:03:06 -!- bsmntbombdood has left (?).
01:03:09 -!- bsmntbombdood has joined.
01:03:17 <bsmntbombdood> oops
01:03:19 <oerjan> The @ pattern match operator, which is considered a bug by some.
01:04:07 <oerjan> And of course brackets.
01:04:42 <oerjan> http://haskell.org/onlinereport/exps.html
01:05:24 <oerjan> Actually the @ doesn't really occur in expressions, but patterns.  So for expressions, no.
01:05:48 <bsmntbombdood> "f1 f2 x" ends up as "f1(f2, x)" right?
01:06:20 <bsmntbombdood> and "f1 $ f2 x" ends up as "f1(f2(x))"
01:06:39 <oerjan> More or less.
01:07:11 <oerjan> Although f1(f2, x) in Haskell is something different.
01:08:18 <oerjan> There are functions curry and uncurry to convert between f1 x y and f1 (x,y)
01:10:12 <oerjan> Actually there are various things that bind more tightly than application but they all involve brackets somehow.
01:23:49 -!- andreou has quit ("-").
01:24:12 -!- ihope has joined.
01:25:45 <bsmntbombdood> ooh pretty
01:25:52 <ihope> Pretty?
01:26:02 <bsmntbombdood> foldr max 0 list
01:26:06 <ihope> That reminds me of some electronics thing I wanted to do for some reason.
01:26:52 <bsmntbombdood> maxlist l = foldr max 0 l
01:27:10 <oklopol> foldr max l ?
01:27:10 <oerjan> Pretty, but a bit buggy if the list has only negative elements.
01:27:16 <oklopol> foldr2 max l
01:27:30 <oklopol> isn't there something like that?
01:27:49 <bsmntbombdood> oerjan: yeah
01:27:52 <ihope> foldr1?
01:28:00 <oklopol> maybe
01:28:22 <oerjan> It's foldr1
01:28:55 <oklopol> seems i don't remember everything anymore :\
01:29:23 <oklopol> but, wouldn't be buggy that way
01:29:42 <oerjan> Except for an empty list.  Can't have everything :)
01:29:57 <oklopol> would it crash then?
01:30:18 <bsmntbombdood> maxlist [] => 0
01:31:02 <oerjan> foldr1 would crash, yes.
01:31:05 <oklopol> maxlist l = foldr1 max l
01:31:08 <oklopol> yeah
01:31:29 <oklopol> i don't know haskell syntax well enought to do an if :)
01:31:49 <oklopol> but i think i remember all the functions there are
01:31:51 <oklopol> in-built
01:32:20 <oklopol> not by name tho
01:32:26 <oklopol> foldr2 lol
01:33:24 -!- wooby has joined.
01:33:56 <oerjan> Of course, maximum is itself a builtin, using foldr1.
01:39:51 <bsmntbombdood> of course, I only know of like 5 builtins
01:39:55 <bsmntbombdood> :P
01:41:29 <bsmntbombdood> hmph, emacs doesn't indent haskell very well
01:44:26 <oerjan> Haskell's indentation is very flexible, but it interacts with other tokens in such a way that emacs would need a complete parser to understand it.
01:47:30 <pikhq> Someone write a complete parser in Elisp, then.
01:47:42 <pikhq> The indentation system is flexible enough to handle it.
01:50:17 <bsmntbombdood> so, should one use "f $ -1" or "f (-1)"?
01:50:40 <oerjan> The latter I assume.
01:51:30 -!- andreou has joined.
01:52:48 <oerjan> $ is best for avoid many nested parentheses (although I use it a bit more than that). For example instead of f1 (f2 1 (f3 y z (f4 x))) you can have f1 $ f2 1 $ f3 y z $ f4 x
01:52:58 <oerjan> *avoiding
01:53:51 <ihope> Is f $ -1 valid?
01:53:59 <oerjan> When you want to chain many functions.
01:54:11 <oerjan> I am pretty sure it is.
01:54:45 <oerjan> Yes it is.
01:54:47 <ihope> Seems to be valid, yes.
01:56:43 <bsmntbombdood> While reading this tutorial, i'm crying at all the ineficientness
01:57:15 <oerjan> Like?
01:57:52 <bsmntbombdood> A recursive definition of filter
01:58:15 <oerjan> What's inefficient about that?
01:59:20 <oerjan> Note that if it is tail recursive the recursion may be optimized away.
01:59:57 <bsmntbombdood> tail recursion modulo cons?
02:01:04 <oerjan> I believe the ghc compiler optimizes away certain kinds of immediately used conses.
02:01:16 <bsmntbombdood> Then I guess it's not that bad
02:03:50 <bsmntbombdood> my_filter f [] = []
02:03:55 <bsmntbombdood> my_filter f (x:xs) = if f x then x:my_filter f xs else my_filter f xs
02:06:48 <ihope> filter_reverse f xs = filter_reverse' f xs rs; filter_reverse' _ [] rs = rs; filter_reverse' f (x:xs) rs | f x = filter_reverse' f xs (x:rs); filter_reverse' f (x:xs) rs | otherwise = filter_reverse' f xs rs
02:08:46 -!- digital_me has quit (Read error: 104 (Connection reset by peer)).
02:08:48 <oklopol> filter_reverse f xs = filter_reverse' f xs []; should be the beginning?
02:10:03 <oklopol> someone please explain if not :\
02:10:19 <oerjan> You don't need to repeat the function before a second guard.
02:10:29 <oerjan> oklopol: I think so too.
02:10:53 <ihope> oklopol: yes, it should be.
02:11:13 <ihope> Or just say rs = [] :-)
02:13:32 -!- tgwizard has quit (Remote closed the connection).
02:27:12 <ihope> Now, bsmntbombdood, I take it there's a reason you haven't cloaked your bot.
02:27:34 <ihope> !exec self.raw("JOIN #tapthru")
02:27:38 <EgoBot> Huh?
02:27:41 <ihope> ...
02:27:43 <ihope> ~exec self.raw("JOIN #tapthru")
02:33:12 <oerjan> ~exec self.disconnect()
02:33:23 <oerjan> ~exec self.disconnect
02:33:57 <oerjan> ~exec self.raw("PART #tapthru")
02:35:22 <oerjan> ~exec self.raw("QUIT :Resetting")
02:35:23 -!- bsmnt_bot has quit ("Resetting").
02:35:26 -!- bsmnt_bot has joined.
02:37:46 -!- ShadowHntr has quit (Read error: 110 (Connection timed out)).
02:38:07 <ihope> ~exec self.raw("QUIT :Resetting")
02:38:07 -!- bsmnt_bot has quit (Client Quit).
02:38:10 -!- bsmnt_bot has joined.
02:38:17 <ihope> Wonderful.
02:39:10 <oerjan> Except for some reason it gave a quit message different from what you wrote...
02:40:11 <pikhq> ~exec self.raw("QUIT :Oooh! Oooh!")
02:40:12 -!- bsmnt_bot has quit (Client Quit).
02:40:14 -!- bsmnt_bot has joined.
02:40:31 <pikhq> Someone pull up the RFC.
02:40:32 <oerjan> Weird...
02:40:47 <oerjan> ~exec self.raw("QUIT :Now what?")
02:40:47 -!- bsmnt_bot has quit (Client Quit).
02:40:49 -!- bsmnt_bot has joined.
02:41:08 <pikhq> ~exec self.raw("QUIT")
02:41:09 -!- bsmnt_bot has quit (Client Quit).
02:41:11 -!- bsmnt_bot has joined.
02:41:23 <pikhq> ~exec self.raw("JOIN #gnu")
02:41:28 <oerjan> ihope used exactly the same command as I the first time, with different result.
02:41:39 <pikhq> ~exec self.raw("PRIVMSG #gnu :Foo.")
02:41:41 <oerjan> And now no messages are passed on.
02:41:52 <pikhq> ~exec self.raw("PART #gnu")
02:42:02 <pikhq> Can you say "bot abuse"?
02:42:08 <oerjan> ~exec self.do_exec = None
02:42:14 <oerjan> Yes.
02:42:27 <oerjan> ~exec self.raw("QUIT :Now what?")
02:42:28 -!- bsmnt_bot has quit (Client Quit).
02:42:30 -!- bsmnt_bot has joined.
02:42:32 <oerjan> Darn.
02:42:43 <ihope> ~exec self.exec_execer = 3
02:42:56 <ihope> ~exec 3
02:42:57 <oerjan> ~exec self.raw("QUIT :Now what?")
02:43:11 <ihope> ~exec This is my apple.
02:43:35 <ihope> ~quit
02:43:39 <ihope> Meh.
02:43:49 <ihope> Um.
02:43:50 <pikhq> ~exec self.raw("PRIVMSG #esoteric :Goodbye.")
02:43:59 <oerjan> Success!
02:44:11 <pikhq> !exec self.exec_execer = self
02:44:14 <EgoBot> Huh?
02:44:18 <pikhq> ~exec self.exec_execer = self
02:44:19 -!- Plouj- has joined.
02:44:27 <ihope> Wow, you made Plouj- join.
02:44:30 <oerjan> We have saved the bot from the evil villains :)
02:44:42 <ihope> Indeed.
02:44:49 <pikhq> You've also killed all legitimate uses.
02:45:19 <ihope> What's the command to make it quit, again?
02:45:21 <ihope> ~raw QUIT
02:45:35 <ihope> ~pexec self.raw("QUIT")
02:45:44 <Plouj-> you guys must be really old, eh
02:45:51 <pikhq> ~cat Foo.
02:45:56 <ihope> If 14 years old is really old...
02:46:02 <pikhq> I fear you've *really* destroyed it.
02:46:02 <oerjan> I believe ~exec is the only one that we could use.
02:46:14 <Plouj-> 14?!
02:46:25 <pikhq> bsmntbombdood: You might want to restart the bot.
02:46:35 <oerjan> That was the idea.  Otherwise one of us would just have been tempted to do something evil again.
02:46:50 <pikhq> -_-'
02:46:59 <oerjan> We had to kill the bot to save it.
02:47:08 <ihope> How ironic.
02:47:50 <ihope> ~die
02:47:57 <ihope> ~DIE
02:57:10 <oklopol> DIE BOT DIE LIKE YER MOTHER!!!
02:57:50 <andreou> all this... wrath...
02:58:04 <andreou> #esoteric should sponsor TV ads to keep kids away from programming
02:58:19 <oklopol> ihope, you really 14?
02:58:20 <pikhq> You will become like us!
02:58:28 <pikhq> andreou: Just one issue: some *want* to be just like us.
02:58:43 <andreou> they're wrong
02:58:51 <andreou> they should listen to Us.
02:58:51 * pikhq was one of those kids
02:59:09 <andreou> i think most of the lurkers here are
02:59:23 <andreou> coding at night, psychotherapy at morning
03:03:52 <bsmntbombdood> pikhq: wtf did you do
03:03:58 -!- bsmnt_bot has quit (Remote closed the connection).
03:04:00 -!- bsmnt_bot has joined.
03:04:16 <pikhq> bsmntbombdood: I didn't!
03:04:23 <pikhq> It was oerjan!
03:05:12 <bsmntbombdood> heh
03:05:55 <oerjan> Actually it was ihope, i just tempted him to it.
03:13:25 <oerjan> ~exec sys.stdout(os.list_dir("/bot"))
03:13:35 <oerjan> hm...
03:13:48 <bsmntbombdood> os.listdir
03:13:57 <oerjan> ~exec sys.stdout(os.listdir("/bot"))
03:13:58 <bsmnt_bot> ['betterbot.py', 'test.pickle', 'start.sh', 'better.sh', 'ircbot.py']
03:14:01 <andreou> cheers
03:14:05 -!- andreou has quit.
03:14:09 -!- andreou has joined.
03:14:15 -!- andreou has quit (Remote closed the connection).
03:14:47 -!- ShadowHntr has joined.
03:17:37 <oerjan> ~exec open("/bot/ircbot.py", "w"); self.raw("QUIT")
03:17:58 <oerjan> why, how curious :)
03:18:05 <bsmntbombdood> oerjan: obviously, you don't have write permission to the source
03:18:28 <bsmntbombdood> that's an easy root exploit right there
03:19:28 <pikhq> ~exec open("/foo", "w")
03:19:36 <pikhq> But can you write anywhere?
03:19:44 <pikhq> . . . Oh, right. It's chrooted, isn't it?
03:19:48 <bsmntbombdood> yeah
03:19:53 <pikhq> ~exec self.raw("QUIT")
03:19:54 -!- bsmnt_bot has quit.
03:19:56 <pikhq> Smart of you.
03:19:59 -!- bsmnt_bot has joined.
03:20:03 <bsmntbombdood> whoa
03:20:05 <bsmntbombdood> wtf
03:20:21 <oerjan> You didn't know about that?
03:20:44 <pikhq> ~exec self.raw("QUIT :I win!")
03:20:45 -!- bsmnt_bot has quit (Client Quit).
03:20:47 -!- bsmnt_bot has joined.
03:20:58 <bsmntbombdood> oh, I misread
03:22:05 <bsmntbombdood> pikhq: Yeah, like i'm going to give you access the whole filesystem ;)
03:22:52 <pikhq> bsmntbombdood: Well, there *is* an exploit for breaking out of chroots.
03:23:05 <bsmntbombdood> needs root, doesn't it?
03:23:28 <pikhq> It needs cd.
03:24:00 <pikhq> ~exec os.list_dir("./")
03:24:07 <bsmntbombdood> os.listdir
03:24:16 <pikhq> ~exec sys.stdout(os.listdir("./"))
03:24:16 <bsmnt_bot> ['bin', 'bot', 'etc', 'lib', 'usr']
03:24:31 <pikhq> ~exec os.changedir("..")
03:24:40 <pikhq> ~exec sys.stdout(os.listdir("./"))
03:24:41 <bsmnt_bot> ['bin', 'bot', 'etc', 'lib', 'usr']
03:24:51 <pikhq> Thought that was it. Damn it, must have forgotten.
03:25:08 <bsmntbombdood> I've seen that exploit, and iirc it needs root
03:25:30 <pikhq> Ah.
03:25:35 <bsmntbombdood> ~exec sys.stdout(os.getuid())
03:25:36 <bsmnt_bot> 1343
03:25:47 <bsmntbombdood> :)
03:27:20 <bsmntbombdood> But whoever tells me the contents of /home/bsmntbombdood/proof.txt gets a prize
03:29:03 <pikhq> ~exec fid=open("/home/bsmntbombdood/proof.txt", "r")
03:29:16 <bsmntbombdood> hah, yeah right
03:29:19 <bsmntbombdood> pikhq: #bsmnt_bot_errors 
03:29:31 <pikhq> bsmntbombdood: Hey, it was worth a try.
03:29:31 <bsmntbombdood> <bsmnt_bot> IOError: [Errno 2] No such file or directory: '/home/bsmntbombdood/proof.txt'
03:29:54 <pikhq> I can tell you the contents of ~/proof.txt, then.
03:29:59 <pikhq> ^d
03:30:20 <bsmntbombdood> ?
03:30:26 <pikhq> EOF.
03:30:34 <bsmntbombdood> oh
03:31:30 -!- Plouj- has left (?).
03:32:42 <bsmntbombdood> BORING?!
03:35:45 <oklopol> ~exec OOOOSO
03:36:10 <oklopol> sleepzors ->
03:37:39 <bsmntbombdood> how can "let" in haskell be functional
03:37:57 <oerjan> ~exec (lambda f : f(f)) (lambda f : f(f))
03:37:58 -!- bsmnt_bot has quit (Excess Flood).
03:38:01 -!- bsmnt_bot has joined.
03:38:25 <bsmntbombdood> weird
03:38:26 <oerjan> It defines a name for an expression.
03:39:02 <bsmntbombdood> not executing has a different effect than executing it
03:39:26 <oerjan> How so?
03:39:58 <bsmntbombdood> it has to be executed before what follows
03:40:33 <oerjan> In fact it doesn't.  It only defines the names, their expressions are not used unless the names are.
03:42:19 <pikhq> ~exec sys.stdin("This is just wrong.")
03:42:40 <bsmntbombdood> wrong indeed
03:42:47 <oerjan> On the other hand the case statement fits your objection better.
03:43:07 <bsmntbombdood> hmmm, I should provide an channel interface to sys.stdin
03:43:09 * pikhq wonders if it's possible to write to stdin in any language. . .
03:44:29 <bsmntbombdood> it could be in a language where there's only one IO stream
03:44:35 <oerjan> Well, in Kayak and Lazy K, stdin turns into stdout according to how the program changes it.
03:44:36 <bsmntbombdood> stdout and stdin are the same
03:44:49 * pikhq also wonders if that language is called INTERCAL
03:45:19 -!- ihope has quit (Connection timed out).
03:45:19 <pikhq> read(stdout);write(stdin, "whoo"); See? Evil.
03:45:20 <oerjan> Apart from the I/O commands being READ OUT and WRITE IN...
03:54:51 -!- zantrua has joined.
03:56:13 -!- zantrua has quit (Read error: 104 (Connection reset by peer)).
03:57:35 -!- zantrua has joined.
03:58:03 <zantrua> Hello all.
03:59:37 -!- zantrua has quit (Read error: 131 (Connection reset by peer)).
04:02:15 -!- bsmnt_bot has quit (Remote closed the connection).
04:02:18 -!- bsmnt_bot has joined.
04:04:07 -!- bsmnt_bot has quit (Excess Flood).
04:04:10 -!- bsmnt_bot has joined.
04:06:13 -!- bsmnt_bot has quit (Excess Flood).
04:06:20 -!- bsmnt_bot has joined.
04:06:49 -!- bsmnt_bot has quit (Excess Flood).
04:06:54 -!- bsmnt_bot has joined.
04:10:10 -!- bsmnt_bot has quit (Excess Flood).
04:10:15 -!- bsmnt_bot has joined.
04:10:33 -!- bsmnt_bot has quit (Excess Flood).
04:10:39 -!- bsmnt_bot has joined.
04:10:46 -!- bsmnt_bot has quit (Client Quit).
04:10:49 -!- bsmnt_bot has joined.
04:10:57 -!- bsmnt_bot has quit (Excess Flood).
04:11:05 -!- bsmnt_bot has joined.
04:11:55 <pikhq> ~exec sys.stdout("QUIT :Excess Flood")
04:11:56 <bsmnt_bot> QUIT :Excess Flood
04:12:06 <pikhq> . . .
04:12:20 <pikhq> ~exec self.raw("QUIT :Excess Flood")
04:12:20 -!- bsmnt_bot has quit (Client Quit).
04:12:21 <bsmntbombdood> ...
04:12:22 <pikhq> That's what I meant.
04:12:24 -!- bsmnt_bot has joined.
04:12:30 -!- bsmnt_bot has quit (Excess Flood).
04:12:39 -!- bsmnt_bot has joined.
04:12:50 -!- bsmnt_bot has quit (Excess Flood).
04:12:59 -!- bsmnt_bot has joined.
04:13:05 <pikhq> ~exec quit
04:13:40 * pikhq leaves
04:13:43 -!- pikhq has quit ("leaving").
04:17:13 -!- calamari has quit ("Leaving").
04:28:32 -!- bsmnt_bot has quit (Excess Flood).
04:28:40 -!- bsmnt_bot has joined.
04:29:48 -!- bsmnt_bot has quit (Remote closed the connection).
04:29:52 -!- bsmnt_bot has joined.
04:30:23 -!- bsmnt_bot has quit (Excess Flood).
04:30:29 -!- bsmnt_bot has joined.
04:31:30 <oerjan> Good grief, "HNOP. Ashley Yakeley updated the status of HNOP, the Haskell library for doing nothing."
04:31:47 <bsmntbombdood> heh
04:32:38 <oerjan> "It has recently been split into two Cabal packages: 'nop', a library of no-op services, and 'hnop', a program that uses nop to do nothing."
04:32:43 -!- bsmnt_bot has quit (Excess Flood).
04:32:46 -!- bsmnt_bot has joined.
04:33:15 <oerjan> And strangely enough it is _not_ merely a joke.
04:34:25 -!- bsmnt_bot has quit (Remote closed the connection).
04:34:27 -!- bsmnt_bot has joined.
04:34:34 -!- bsmnt_bot has quit (Remote closed the connection).
04:34:37 -!- bsmnt_bot has joined.
04:36:47 -!- bsmnt_bot has quit (Excess Flood).
04:37:01 -!- bsmnt_bot has joined.
04:37:19 -!- bsmnt_bot has quit (Excess Flood).
04:37:23 -!- bsmnt_bot has joined.
04:37:43 -!- bsmnt_bot has quit (Excess Flood).
04:37:51 -!- bsmnt_bot has joined.
04:38:27 -!- bsmnt_bot has quit (Remote closed the connection).
04:38:32 -!- bsmnt_bot has joined.
04:38:38 -!- bsmnt_bot has quit (Remote closed the connection).
04:38:44 -!- bsmnt_bot has joined.
04:39:23 -!- bsmnt_bot has quit (Remote closed the connection).
04:39:29 -!- bsmnt_bot has joined.
04:40:20 -!- bsmnt_bot has quit (Remote closed the connection).
04:40:25 -!- bsmnt_bot has joined.
04:40:46 -!- bsmnt_bot has quit (Remote closed the connection).
04:40:51 -!- bsmnt_bot has joined.
04:41:20 -!- oerjan has quit ("leaving").
04:41:56 <oklopol> cool
04:42:05 <oklopol> maybe i'll make a language for doing nothing
04:42:25 <oklopol> nopbol
04:42:26 <bsmntbombdood> heh guys sorry about the spam
04:42:34 <oklopol> spam is nice
04:42:45 -!- bsmnt_bot has quit (Remote closed the connection).
04:42:48 -!- bsmnt_bot has joined.
04:46:53 -!- bsmnt_bot has quit (Excess Flood).
04:46:58 -!- bsmnt_bot has joined.
04:47:07 <bsmntbombdood> ~raw PART #esoteric 
04:47:08 -!- bsmnt_bot has left (?).
04:48:07 -!- bsmnt_bot has joined.
04:49:41 -!- bsmnt_bot has quit (Remote closed the connection).
04:49:48 -!- bsmnt_bot has joined.
04:50:07 -!- bsmnt_bot has quit (Remote closed the connection).
04:50:10 -!- bsmnt_bot has joined.
04:54:24 -!- bsmnt_bot has quit (Excess Flood).
04:54:33 -!- bsmnt_bot has joined.
04:54:37 -!- bsmnt_bot has quit (Remote closed the connection).
04:54:44 -!- bsmnt_bot has joined.
04:54:47 -!- bsmnt_bot has quit (Remote closed the connection).
04:54:53 -!- bsmnt_bot has joined.
04:55:52 -!- bsmnt_bot has quit (Remote closed the connection).
04:55:58 -!- bsmnt_bot has joined.
04:56:13 -!- bsmnt_bot has quit (Remote closed the connection).
04:56:24 -!- bsmnt_bot has joined.
04:56:50 -!- bsmnt_bot has quit (Client Quit).
04:56:53 -!- bsmnt_bot has joined.
05:00:01 -!- bsmnt_bot has quit (Excess Flood).
05:00:05 -!- bsmnt_bot has joined.
05:06:26 -!- bsmnt_bot has quit.
05:06:30 -!- bsmnt_bot has joined.
05:06:40 -!- bsmnt_bot has quit (Excess Flood).
05:06:46 -!- bsmnt_bot has joined.
05:08:05 <bsmntbombdood> heh
05:11:55 -!- bsmnt_bot has quit (Remote closed the connection).
05:15:10 -!- bsmnt_bot has joined.
05:18:33 -!- bsmnt_bot has quit (Remote closed the connection).
05:18:35 -!- bsmnt_bot has joined.
05:19:34 -!- bsmnt_bot has quit (Remote closed the connection).
05:19:36 -!- bsmnt_bot has joined.
05:20:01 -!- bsmnt_bot has quit (Remote closed the connection).
05:20:53 -!- bsmnt_bot has joined.
05:21:26 -!- bsmnt_bot has quit (Remote closed the connection).
05:22:32 -!- bsmnt_bot has joined.
05:23:11 -!- bsmnt_bot has quit (Remote closed the connection).
05:23:13 -!- bsmnt_bot has joined.
05:26:39 -!- bsmnt_bot has quit (Read error: 131 (Connection reset by peer)).
05:26:42 -!- bsmnt_bot has joined.
05:27:30 -!- bsmnt_bot has quit (Remote closed the connection).
05:27:33 -!- bsmnt_bot has joined.
05:29:29 -!- bsmnt_bot has quit (Remote closed the connection).
05:29:31 -!- bsmnt_bot has joined.
05:30:28 -!- bsmnt_bot has quit (Remote closed the connection).
05:30:31 -!- bsmnt_bot has joined.
05:31:40 -!- bsmnt_bot has quit (Read error: 131 (Connection reset by peer)).
05:31:43 -!- bsmnt_bot has joined.
06:15:42 -!- bsmnt_bot has quit (Remote closed the connection).
06:16:07 -!- bsmnt_bot has joined.
06:16:19 -!- bsmnt_bot has quit (Remote closed the connection).
06:16:50 -!- bsmnt_bot has joined.
06:17:51 -!- bsmnt_bot has quit (Read error: 131 (Connection reset by peer)).
06:17:54 -!- bsmnt_bot has joined.
06:18:02 -!- bsmnt_bot has quit (Remote closed the connection).
06:18:04 -!- bsmnt_bot has joined.
06:18:11 -!- bsmnt_bot has quit (Remote closed the connection).
06:18:20 -!- bsmnt_bot has joined.
06:19:12 <CakeProphet> mmm... I like writing interpreters.
06:19:28 -!- bsmnt_bot has quit (Remote closed the connection).
06:19:43 -!- bsmnt_bot has joined.
06:19:44 <CakeProphet> it's always fun to imagine the semantics reducing to the most fundamental parts of the language.
06:21:58 <oklopol> This is great, my language is the nicest language I've ever seen for writing recursive data structures, but all you can do is nop :)
06:22:50 <oklopol> I guess the beautiful syntax and the nice way of structuring makes up for the fact you can't really do anything?
06:23:01 <CakeProphet> Sure.
06:23:20 * CakeProphet is trying to find a clever languagge joke that won't offend anyone.
06:23:33 <CakeProphet> Like "It worked for Ruby" or something...
06:23:47 <CakeProphet> but nothing comes to mind.
06:24:28 <oklopol> I'm not making a joke language.
06:25:17 <oklopol> This might actually be a very good language for teaching structures for example :)
06:25:49 <CakeProphet> a weird variation of lambda calculus might work for that.
06:26:07 <CakeProphet> for abstraction and stuff.
06:26:09 <oklopol> I still haven't understood that language
06:26:19 <CakeProphet> me neither.
06:26:22 <CakeProphet> not the specifics.
06:26:24 <oklopol> Might work for what?
06:27:02 <CakeProphet> but in general.... it's a very clear demonstration of how invidual basic parts can be grouped together to form abstracted procedures.
06:27:44 <CakeProphet> if you assign certain strings of lambdas a given name... and substitute the name instead of the functions whenever they arise
06:28:37 <CakeProphet> and continue doing that... you can quickly amass a logical stucture.
06:29:12 <CakeProphet> quick always seems to be the most powerful way to demonstrate abstraction.
06:29:20 <CakeProphet> if you can write it out quickly.
06:31:36 <oklopol> hmm... what is the most complex thing written in lambda calculus?
06:31:55 <oklopol> I've heard it's nothing.
06:31:56 <oklopol> :)
06:56:10 -!- Sgeo has quit (Remote closed the connection).
07:24:27 -!- ShadowHntr has quit ("End of line.").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:53:25 -!- sebbu has joined.
10:49:46 -!- tgwizard has joined.
11:12:05 -!- jix has joined.
11:13:15 -!- jix has quit (Client Quit).
12:40:44 -!- jix has joined.
12:56:03 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
12:59:14 -!- jix has joined.
13:04:51 -!- andreou has joined.
13:05:02 <andreou> greets
13:48:56 -!- ihope has joined.
13:49:18 -!- ihope has quit (Client Quit).
14:10:02 -!- andreou has quit ("BitchX: faster than a speeding bullet, more powerful than a locomotive").
14:10:26 -!- andreou has joined.
15:53:04 -!- ihope has joined.
15:54:16 <ihope> ~exec self.raw("PRIVMSG #esoteric :uelauelaue")
15:54:17 <bsmnt_bot> uelauelaue
15:54:19 <ihope> Yay!
15:57:15 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
16:24:40 <ihope> bsmnt_bot: exec self.raw("PRIVMSG #esoteric laueluaeleualeu")
16:52:45 <andreou> eh how do i find any ircops? /who -what?
17:21:57 -!- andreou has quit ("recycle").
17:33:26 -!- andreou has joined.
17:41:40 <ihope> /stats p
17:41:52 <ihope> Or something else. Lemme see...
17:43:15 <ihope> I guess /who *@freenode/staff*
17:43:28 <ihope> ...Or not.
17:44:02 <ihope> Then it's probably/who *freenode/staff*
17:45:04 <andreou> the latter is true, i found a few, but they're all idle :)
17:45:48 <ihope> notabot might not be.
17:46:05 <andreou> 27 hrs :)
18:03:39 -!- CakeProphet has quit ("haaaaaaaaaa").
18:05:48 <SimonRC> ~
18:10:04 <ihope> ~?
18:13:30 <SimonRC> #!
18:28:37 -!- ShadowHntr has joined.
18:29:52 <bsmntbombdood> ~?#
18:30:57 <bsmntbombdood> woot
18:30:59 <bsmntbombdood> cons x y = \f -> f x y
18:30:59 <bsmntbombdood> car c = c (\x y -> x)
18:30:59 <bsmntbombdood> cdr c = c (\x y -> y)
18:35:11 * bsmntbombdood is clever
18:38:51 -!- digital_me has joined.
18:41:27 <ihope> bsmntbombdood: congrats, you just expressed the standard definition of an ordered pair in lambda calculus in Haskell notation.
18:42:49 <bsmntbombdood> yep
18:45:43 <ihope> (,), fst, snd...
18:49:28 <bsmntbombdood> How do we represent the empty list?
18:53:11 <bsmntbombdood> and why doesn't my_map f list = cons (f (car list)) (my_map f (cdr list)) work?
19:14:14 <bsmntbombdood> I can't figure out what's wrong
19:20:55 <ihope> Lists would be completely different.
19:21:42 <ihope> A list would be represented as its own foldr function.
19:23:39 <ihope> cons x xs = \c e -> c x (xs c e)
19:23:41 <ihope> ...I think.
19:23:50 <ihope> empty = \c e -> e
19:24:09 <ihope> foldr c e xs = xs c e
19:24:31 <bsmntbombdood> huh?
19:24:40 -!- andreou has quit ("-").
19:25:16 <ihope> I think that's how lists are generally represented in lambda calculus.
19:25:22 <ihope> That's the typable way.
19:26:05 <ihope> And by typable way, I mean using Haskell's type system.
19:27:06 <ihope> Either the Hindley-Milner type system or the Damas-Milner type system. Both different names for the same thing, I think.
19:29:53 -!- CakeProphet has joined.
19:42:09 * bsmntbombdood requests SICP from the library
20:01:37 -!- ihope has quit ("http://tunes.org/~nef/logs/esoteric/06.08.09").
20:04:13 <SimonRC> I accidently discovered a simple way of turing algebraic datatypes into collections of lambda calculus functions.
20:04:37 <SimonRC> Each value of the type takes one function per constructor.
20:05:31 <SimonRC> A constructor calls one of its arguments with the containted data and ignores the other arguments.
20:05:52 <SimonRC> e.g. a list datum takes two arguments.
20:06:46 <SimonRC> The first is called for a cons, and is passed the car and cdr of the list.  The second is called for a nil and takes no arguments.
20:07:18 <SimonRC> cons a b = (\x y -> x a b)
20:07:31 <SimonRC> nil = (\x y -> y)
20:07:33 <SimonRC> tada!
20:55:14 -!- Sgeo has joined.
21:34:11 -!- andreou has joined.
21:40:16 -!- jix__ has joined.
21:43:21 -!- jix__ has changed nick to jix.
21:57:56 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:02:09 -!- sebbu has quit (Read error: 110 (Connection timed out)).
22:31:28 <ShadowHntr> and that is in haskell ?
22:31:36 <ShadowHntr> i'd much rather do that in FORTRAN... ;)
22:33:46 -!- wooby has quit.
22:36:06 <CakeProphet> hmmm..
22:36:30 <CakeProphet> Is this the proper regex pattern for an ORK class definition?
22:36:32 <CakeProphet> re.compile(r"there is such a thing as an? (?P<name>.*?)\.? *$(?P<body>(.*?$)*)", re.MULTILINE|re.IGNORECASE)
22:36:46 <CakeProphet> oh wait...
22:37:44 <CakeProphet> re.compile(r"there is such an? (?P<metaclass>.*?)  as an? (?P<name>.*?)\:? *$(?P<body>(.*?$)*)", re.MULTILINE|re.IGNORECASE)
22:37:58 <CakeProphet> I forgot the first part ends with a colon... and that I'm including metaclasses :D
22:53:24 -!- ihope has joined.
22:56:11 <CakeProphet> hmmm...
22:56:17 <CakeProphet> yeah it looks about right,.
22:59:05 <ihope> Yes, it does.
22:59:14 <ihope> Well, almost, anyway.
22:59:28 <ihope> It's just a little bit off
22:59:46 <ihope> Now, care to tell me just what it is that looks about right?
22:59:53 <CakeProphet> hrhr
23:00:17 <CakeProphet> "there is such an? (?P<metaclass>.*?)  as an? (?P<name>.*?)\:? *$(?P<body>(.*?$)*)"    with multiline and ignorecase turned on.
23:00:34 <CakeProphet> well... the colon isn't optional.
23:00:36 <CakeProphet> or is it?
23:00:43 <CakeProphet> I always see it.
23:00:46 <CakeProphet> but it could be omitted.
23:02:42 * CakeProphet is written an ORK interpreter... and then adding some crap to it to create the Sophia dialect.
23:03:44 <ihope> You is written?
23:04:21 <CakeProphet> ...yes
23:04:32 <CakeProphet> I meant "is writing"... but that sounds nifty.
23:04:50 -!- wooby has joined.
23:05:08 <CakeProphet> I mean also include inheritance... but maybe not directly.
23:05:48 <CakeProphet> or it could just be    "There is such a <metaclass> as a <class> which is a <superclass>"      which doesn't quite sound as ORKY as I'd like it to.
23:06:06 <CakeProphet> ORK is verbose in a terse way... that's getting a little superfluous.  ;)
23:07:23 -!- andreou has quit ("recycling").
23:08:59 <ihope> ...What?
23:10:09 <CakeProphet> ...huh?
23:10:57 <ihope> Superfluously verbose terseness?
23:12:16 <CakeProphet> No.
23:12:20 <CakeProphet> just verbose terseness.
23:12:31 <CakeProphet> each statement is nice and direct... but overly verbose too.
23:12:50 <CakeProphet> with the inheritance add-on I just proposed... it would sound less to the point
23:13:31 -!- andreou has joined.
23:14:26 <ihope> Can you put that in words less than four letters long?
23:15:21 <CakeProphet> nah... it's not length that's the problem.
23:15:29 <CakeProphet> it's semantical baggage.  :D
23:15:45 <CakeProphet> There is such a thing as a master of all beings which is an apple
23:15:55 <CakeProphet> does not sound as good as
23:16:04 <CakeProphet> there is such a thing as a master of all beings
23:19:41 <CakeProphet> There is such a thing as a master of all beings
23:19:50 <CakeProphet> a master of all beings is very much like an apple
23:19:54 <CakeProphet> yay inheritance...
23:24:56 <andreou> can anyone get ftp://ftp.cs.bris.ac.uk/pub/goedel/latest/goedel-src.tar.Z or is the FTP boinked?
23:25:58 <GregorR> andreou: No go for me.
23:26:34 <CakeProphet> hmm.. I always have a hard time understand how declarations slow down execution speed... they still need to be computed.
23:28:38 <CakeProphet> oh.
23:28:41 <CakeProphet> speed up execution speed.
23:30:18 * SimonRC goes
23:30:52 * CakeProphet dances.
23:31:49 -!- andreou has quit ("new /netbsd, rejoice").
23:35:41 -!- pikhq has joined.
23:39:13 -!- andreou has joined.
23:44:05 -!- tgwizard has quit (Connection timed out).

2007-01-15:

00:06:54 <bsmntbombdood> we can have nil = \x y -> y
00:07:00 <bsmntbombdood> t = \x y -> x
00:08:52 <bsmntbombdood> if p x y = p x y
00:25:29 <ihope> Let's just pretend we can compute the uncomputable.
00:27:12 <pikhq> Let's just pretend that 1+1=3.
00:27:16 <bsmntbombdood> let's
00:27:49 <pikhq> Or, in the factory language. . .
00:27:55 <pikhq> LET 1+1=3
00:27:57 <pikhq> >:D
00:28:02 -!- ihope has changed nick to i.
00:28:07 <andreou> hm can 3 be overloaded in scheme to be 2?
00:28:08 -!- i has changed nick to ihope.
00:28:33 <bsmntbombdood> (set! 2 3)
00:28:41 <bsmntbombdood> (not really)
00:28:46 <andreou> no, tried that ;p
00:28:55 -!- ihope has changed nick to \050.
00:29:05 -!- \050 has changed nick to ihope.
00:29:16 <andreou> there's always (define three 3) (define two three)... but that doesn't really matter.
00:29:20 <andreou> or count
00:29:45 <bsmntbombdood> Happy Happy Joy Joy.
00:29:52 <andreou> off to try the kernel
00:29:54 -!- andreou has quit ("kernel time").
00:33:07 -!- andreou has joined.
00:38:25 <ihope> Joy is not the same as luck, and there is no such thing as joy luck.
00:38:53 <ihope> Sad, isn't it?
00:40:06 <andreou> consider yourself lucky if you have joy
00:40:15 <andreou> and be joyful if you have (good) luck
00:40:30 <andreou> they're like ( and )
00:41:53 <lament> wha.t
00:42:23 * pikhq joins bsmntbombdood in singing "Happy Happy Joy Joy".
00:46:15 <bsmntbombdood> That's what the MIT scheme interpreter says on exit
00:47:31 <pikhq> Ren & Stimpy fans, I see.
00:49:37 -!- ihope has quit (Read error: 104 (Connection reset by peer)).
01:03:40 * bsmntbombdood plays with bsmnt_bot 
01:03:55 <bsmntbombdood> someone suggested a change, what was it?
01:16:05 -!- digital_me_ has joined.
01:27:12 -!- digital_me has quit (Read error: 110 (Connection timed out)).
01:41:37 -!- calamari has joined.
01:46:17 * andreou happily plays around with chicken scheme until he's fit for bathing
01:56:53 <bsmntbombdood> #'
02:00:13 -!- ihope has joined.
02:02:54 <bsmntbombdood> foo
02:03:53 <ihope> bar
02:04:13 <bsmntbombdood> eggs
02:04:19 <ihope> ham
02:11:21 -!- pikhq has quit ("leaving").
02:33:32 -!- ihope has quit (Read error: 110 (Connection timed out)).
02:49:53 -!- ShadowHntr has quit (Connection timed out).
03:40:06 -!- andreou has quit ("\").
04:03:40 -!- wooby has quit.
04:38:23 -!- wooby has joined.
05:20:33 <CakeProphet> hmmm... I need to learn C++
05:20:37 <CakeProphet> not because I want to.
05:20:42 <oklopol> true
05:20:46 <oklopol> because it's the best
05:20:49 <CakeProphet> but because I'm going to be using it soon... with little to no experience.
05:20:59 <oklopol> :)
05:21:41 <CakeProphet> see... the people I'm "working", who have little knowledge about programming, seem utterly sure that C++ is the best language to use for their purposes.
05:22:04 <CakeProphet> I told them the best language for me to use would be the one I'm most familiar with... in this case Python, or Lisp (vaguely) as an alternative.
05:22:30 <CakeProphet> but... not good enough... so..
05:22:34 <CakeProphet> now I need to learn C++
05:22:37 <CakeProphet> who knows... it might be fun.
05:22:58 <oklopol> c++ is fun
05:23:06 <CakeProphet> It looks rather boring to me.
05:23:13 <CakeProphet> nothing terribly exciting.
05:23:17 <oklopol> haha :)
05:23:58 <CakeProphet> and static typing is a drag if you've always used duck typing.
05:24:19 <oklopol> with c++ i best have the feeling i can do anything, you have such direct access to the memoryt
05:24:22 <oklopol> *-t
05:24:36 <oklopol> i have a python question for you
05:24:40 <CakeProphet> meh... I've never actually -needed- direct access to the memory.
05:24:41 <oklopol> but not now
05:24:47 <oklopol> bus leaved in 2 minutes
05:24:49 <oklopol> not neede
05:24:52 <oklopol> wanted.
05:24:56 <oklopol> you should want
05:24:58 <CakeProphet> I haven't wanted it either.
05:24:59 <oklopol> now to go ->
05:25:09 <CakeProphet> I'm not even sure what I'd do with it.
05:25:53 <CakeProphet> hmmm.. where can I get the full specification of the standard C++ implementation?
05:26:00 <CakeProphet> I can't seem to find anything but paper books.
05:29:40 <CakeProphet> I would just play around with it...
05:29:43 <CakeProphet> but that seems like too much work.
05:29:50 <CakeProphet> I mean... you have to compile it and all.
05:31:23 <CakeProphet> and I'm not really sure how to access the compiler from windows.
05:43:51 -!- oerjan has joined.
05:45:32 <oerjan> Hi bsmntbombdood 
05:45:36 <bsmntbombdood> hi
05:46:01 <oerjan> I noticed that the Haskell tutorial you said you were reading was not the most recent version.
05:46:32 <CakeProphet> One thing that irks me about C++ is I haven't figured out how it's consistent.
05:46:53 <bsmntbombdood> CakeProphet: c++ is hideous
05:47:11 <CakeProphet> In Python everything is universally consistent... but so far I haven't found this to be true in C++
05:47:16 <CakeProphet> it might jsut be my lack of understanding though.
05:47:40 <oerjan> Has anyone claimed C++ is consistent?
05:47:46 <CakeProphet> Nope.
05:48:00 <CakeProphet> I'm just trying to find out if it is.
05:48:27 <bsmntbombdood> static typing is sooo annoying in high level languages
05:48:36 <oerjan> On the other hand (and I say this having never tried to program in it) people are complaining about how its features have lots of unexpected interactions.
05:49:23 <oerjan> Apparently you have to learn a lot of rules for what not to do in combination.
05:49:42 <CakeProphet> I find that true of common lisp.
05:49:46 <CakeProphet> with all the macros.
05:50:07 <CakeProphet> it's hard to keep all straight when you're learning.
05:50:16 <oerjan> Ah yes.  I suppose that is a reason why Scheme invented the hygienic macro system.
05:53:16 <CakeProphet> hmmm..
05:53:27 <bsmntbombdood> gah, all these languages, so little time
05:53:39 <CakeProphet> could you define a C++ macro that substitutes all newline characters with ;\n?
05:54:03 <bsmntbombdood> c++ doesn't have macros
05:54:11 <CakeProphet> if you're like me... and lazy and don't feel like getting into the habit of using semicolons and have no real use for writing multiple statements in one line?
05:54:21 <CakeProphet> eh... it has flimsy textual substititions with #define
05:54:24 <CakeProphet> which it calls "macros"
05:54:33 <CakeProphet> they're not lisp macros, no.
05:54:36 -!- ShadowHntr has joined.
05:54:45 <bsmntbombdood> CakeProphet: just use semicolons
05:55:01 <CakeProphet> Yeah, it's no big deal.
05:55:10 <CakeProphet> but any step of laziness I can take would be great.
05:55:24 <bsmntbombdood> no one will be able to understand your code, and it will break
05:56:00 <CakeProphet> Why's that?
05:56:03 <oerjan> I think you mean "no real use for writing a statement over multiple lines"
05:56:07 <bsmntbombdood> if (p)
05:56:11 <bsmntbombdood>    foo()
05:56:15 <bsmntbombdood> teh bork
05:56:33 <oerjan> He didn't say to leave out brackets.
05:56:42 <bsmntbombdood> that turns into "if (p); foo();"
05:57:05 <bsmntbombdood> oerjan: you don't need brackets there
05:57:57 <oerjan> He could simply follow a Python-like rule: either use brackets or put the sub-statement on the same line.
05:59:24 <CakeProphet> meh.. I can use C++'s ways no problem.
05:59:27 <oerjan> On the other hand I am not sure whether { ; is permitted in all cases.
05:59:34 <CakeProphet> no use sticking to old modes of thought.
06:00:04 <bsmntbombdood> I think "{ ;" will work, it's just a line with no stuff on it
06:00:14 <CakeProphet> hmm... I do kind of wonder how C++ actually works though...
06:00:28 <bsmntbombdood> ugly
06:00:31 <CakeProphet> the more I read into it the more it starts to sound like how I thought a programming langauge would work back before I learned how to program.
06:00:35 <oerjan> Will it work for switch statements?
06:00:49 <CakeProphet> I probably wouldn't use switch anyways
06:00:52 <CakeProphet> it's kind of silly.
06:01:04 <bsmntbombdood> I think so
06:01:45 <CakeProphet> Does C++ use the same evaluation as Python does for crap?
06:01:49 <CakeProphet> well..
06:01:50 <CakeProphet> what I mean by that.
06:02:20 <CakeProphet> I remember someone finding it odd that  "\n".join(SomeList)   was a valid python expression.
06:02:28 <CakeProphet> and they were primarily a C/C++ programmer.
06:02:59 <bsmntbombdood> can't call methods on a char*
06:03:10 <CakeProphet> some I'm wondering if C++ uses variables and statements as I knew them
06:03:35 <CakeProphet> ah.
06:03:40 <CakeProphet> oh okay.
06:03:52 <fizzie> On the other hand, some Python programmers might find it odd that  4["foob"]  is a valid C expression. :p
06:04:22 <CakeProphet> That's not too odd... it wouldn't work in Python, and I have no clue what it means...
06:04:38 <fizzie> It means the same as "foob"[4]", ie. 'b'.
06:04:40 <oerjan> It means exactly the same as "foob"[4]
06:04:49 <fizzie> Uh, '\0', I mean.
06:04:52 <CakeProphet> ...oh... well that -is- odd.
06:05:02 <CakeProphet> no the syntax... but what the syntax produces.
06:05:06 <fizzie> It's because a[b] is sort-of defined as *(a+b), and + is commutative.
06:05:06 <oerjan> because p[q] = *(p+q), so commutative.
06:05:12 <bsmntbombdood> Right, because C's array syntax is just sugar
06:05:21 <oerjan> Darn speaking in each other's mouths
06:05:28 <bsmntbombdood> x[i] == *(x+i)
06:05:49 <bsmntbombdood> wow, three of us said exactly the same thing
06:06:10 <CakeProphet> hmmm..
06:06:12 <CakeProphet> so....
06:06:23 <CakeProphet> how does it differenciate if it's communative?
06:06:36 <oerjan> It's + that is commutative.
06:06:40 <bsmntbombdood> CakeProphet: Have you programmed in a language with pointers before?
06:06:50 <CakeProphet> would it just as easily been the "foob" slice of 4?  (which obviously doesn't make any sense... but it could have been read that way)
06:06:54 <CakeProphet> nope.
06:07:03 <bsmntbombdood> I hope you'll find them enlightening
06:07:16 <bsmntbombdood> I love playing with pointers :)
06:07:23 <oerjan> "foob" in a sense means the position of the 'f'
06:07:37 <CakeProphet> I basically conceptualize them to be like mutable data structures in Python... they point to the exact same chunk of memory rather than a new "copy" of it.
06:07:51 <bsmntbombdood> CakeProphet: pretty much
06:07:53 <oerjan> so "foob"+4 means the position of, well, I suppose not 'b', that was an error.
06:08:11 <bsmntbombdood> oerjan: no, "foob"+4 is correct
06:08:15 <CakeProphet> Alright... then I know how to use pointers.
06:08:28 <bsmntbombdood> CakeProphet: Except, pointers are more usefull
06:08:35 <CakeProphet> I just need to remember that everything is implicitly a copy of the original value unless I use a pointer.
06:08:38 <oerjan> Not in C. "foob"[0] == 'f'
06:08:52 <bsmntbombdood> oerjan: yes...
06:09:16 <CakeProphet> I could see the possible uses... I just question the way its implemented.
06:09:28 <CakeProphet> I would have made pointers implicit... and copies of the value explicit.
06:09:47 <oerjan> So "foob"[4]=='\000', the implicit NUL at end of string.
06:09:49 <CakeProphet> But I'm sure there's a reason.
06:09:57 <bsmntbombdood> oerjan: uh huh
06:10:29 <bsmntbombdood> so 4["foob"] == '\0'
06:10:45 <oerjan> Pointers may be more efficient in some cases, I guess.
06:11:18 <CakeProphet> I think C just has a different idea of what a variable is than me.
06:11:27 <bsmntbombdood> Pointers are more than just mutability, because the pointers can be manipulated themselves
06:11:39 <oerjan> Yes, to C a variable is a region in memory, of arbitrary size.
06:12:11 <CakeProphet> since I get my ideas about variables form Python... which, in terms of C++, makes variables implicitly a pointer.
06:12:38 <CakeProphet> x = [1,2,3,4,5,6,7,8]
06:12:39 <CakeProphet> y = x
06:12:47 <oerjan> Not simply a reference to a region of memory, like presumably in Python (except for primitive immutable types, where the reference is optimized away)
06:13:38 <CakeProphet> hmmm...
06:13:41 <CakeProphet> alright then...
06:13:54 <CakeProphet> I don't like C++ arrays either... if I must complain.
06:14:06 <CakeProphet> I can't think of too many uses for them...
06:14:26 <bsmntbombdood> Don't think of them as an array, just as a succint way to manipulate large areas of memory
06:14:40 <bsmntbombdood> s/array/list/
06:14:40 <CakeProphet> Well... they're fixed-width.
06:14:47 <fizzie> It's probably the lowest-overhead way to have an array, since it's just a block of memory.
06:14:49 <CakeProphet> which... makes them kind of constained in what they can do.
06:15:08 <CakeProphet> yeah... C's all about low overhead.  :P
06:15:16 <bsmntbombdood> Like I said, they aren't a list
06:15:25 <oerjan> Interestingly in Haskell and Ocaml, where things _are_ references by default, there are libraries for "unboxing", which means essentially doing it the C way for efficiency.
06:15:27 <fizzie> If you're using C++, you probably want to use STL's containers (like std::vector) anyway, if you want an array-like container, and arrays if you want to _implement_ a container.
06:16:07 <CakeProphet> ah... so arrays aren't intended to be the final structure?
06:16:17 <CakeProphet> just the means to the final structure?
06:16:22 <CakeProphet> Like conses in lisp
06:16:38 <bsmntbombdood> ...they can be
06:16:38 <oerjan> Arrays were inherited from C.
06:16:55 <CakeProphet> Right.
06:16:59 <fizzie> I guess that depends on the user; but all C++ books probably tout the merits of the STL containers.
06:17:35 <oerjan> They essentially just show their age, as does pointers.
06:18:04 <oerjan> Except probably for really low-level programming.
06:20:12 <bsmntbombdood> which is what they are for
06:20:38 <CakeProphet> I imagine when I first start with C++ I'll always forget to type "||" instead of "or"
06:20:43 <CakeProphet> same with && and !
06:20:56 <CakeProphet> I could use #define to substitute them... if I wanted.
06:21:16 <CakeProphet> simply to avoid it from screwing up my program.
06:23:35 <oerjan> I think what Oklopol's nop language needs is a type system so complicated that _it_ is Turing-complete.
06:24:07 <fizzie> C++ templates are, after all. :p
06:24:21 <CakeProphet> ....okay...
06:24:23 <bsmntbombdood> C++ templates are SO GROSS
06:24:32 <CakeProphet> I'm not sure who the hell thought that C++'s comma operator was a good idea.
06:24:43 <fizzie> It's C's comma operator.
06:24:48 <bsmntbombdood> that's why high level languages should be dynamically typed
06:24:50 <CakeProphet> ....and C++'s
06:25:12 <fizzie> What's your problem with the comma? 
06:25:24 <CakeProphet> I don't call Python's + operator C's + operator simply because C used it before Python.
06:25:27 <bsmntbombdood> what do you mean, comma operator?
06:25:31 <CakeProphet> nah... it's fine.. and I could actually see myself using it.
06:25:45 <CakeProphet> I 'm just curious who the hell thought it up... and why they chose a comma.
06:26:09 <oerjan> The comma operator is simply a result of C distinguishing too hard between expressions and statements, like a P-language I could mention.
06:26:18 <bsmntbombdood> give me an example, I have no idea what you're talking about
06:26:37 <CakeProphet> int x = (a=5,b=3, 6 )
06:26:40 <CakeProphet> x would be 6
06:27:16 <fizzie> Incidentally, I haven't met anyone who wouldn't write that as "a = 5; b = 3; int x = 6;".
06:27:19 <bsmntbombdood> ...i've never seen/used that
06:27:40 <CakeProphet> yeah I know... I probably wouldn't use it...
06:27:42 <CakeProphet> for that
06:27:44 <fizzie> But the comma is used a lot in initializing several values in the init section of a for loop;  for(a = 0, b = 0; ...) ...
06:28:07 <CakeProphet> so it's like a... creepy non-data-type version of a tuple?
06:28:34 <oerjan> Actually it's like a creepy expression version of a statement separator.
06:28:58 <CakeProphet> what's a statement operator?
06:29:01 <CakeProphet> ; ?
06:29:11 <oerjan> separator.
06:29:30 <CakeProphet> aaah.
06:29:38 <CakeProphet> oh okay... I see WHY you would use it now... 
06:29:41 <fizzie> The , and ?: operators are very useful if you have some sort of ; allergy and want to write your whole program as a single expression.
06:29:44 <CakeProphet> still think it's a lame way to do it.  :P
06:30:00 <CakeProphet> I like writing programs in single expressions.  :D
06:30:17 <oerjan> Like Ocaml, a functional language uses ; for both, since it doesn't distinguish statements from expressions.
06:30:21 <CakeProphet> but for some reason I consider variable assignment in an expression "cheating".
06:30:37 <CakeProphet> but that's my inevitable Python  bias... because python treats = as a statement.
06:31:41 <oerjan> However, Ocaml's syntax is generally not considered its best part.
06:31:57 <CakeProphet> hmmm..
06:32:54 <lament> of course it's cheating.
06:32:59 <lament> it's a side effect.
06:32:59 <CakeProphet> "for x in SomeList"   in Python in    "for(x = SomeList[y], y++, SomeList)"      right?
06:33:04 <lament> any side effect in an expression is cheating.
06:33:23 <fizzie> Here's a well-structured brainf*ck interpreter in C I wrote once; it shows the amazing usefulness of the ?: operator:
06:33:26 <fizzie> main(j,a,n,t)int*a;{unsigned short p=-1;char*r=calloc(n=p+1,6),*i=r
06:33:29 <fizzie> +n,**k=i+n;for(read(open(*++a,t=0),i,p);n=*i-43,t<0?n-48?n-50||++t:
06:33:31 <fizzie> --t:n?n-2?n-19?n-17?n-3?n-48?n-50?n-1||read(0,r+p,1):p[r]?i=k[j]:j
06:33:34 <fizzie> --:p[r]?k[++j]=i:t--:putchar(p[r]):p--:p++:p[r]--:p[r]++,*i++;);}
06:33:41 <CakeProphet> oh I use conditional expressions all the time... and list comprehensions.
06:33:56 <lament> fizzie: i see a lot of ;
06:34:07 <fizzie> Yes, I don't really have a ; allergy.
06:34:31 <CakeProphet> hmmm... C makes it easier to avoid multiple statements...
06:34:41 <CakeProphet> in Python it's like a fun little challenge though... C makes it too easy.  :P
06:34:59 <lament> CakeProphet: not really
06:35:23 <lament> it's probably easier in python since C doesn't have lambdas
06:35:42 <CakeProphet> you can do variable assignments, multiple-expressions-with-side-effects-but-only-use-the-last-one-to-evaluate, 
06:35:48 <CakeProphet> it's almost like having statements.
06:36:21 <fizzie> And you have the ?: to do conditionals.
06:36:29 <CakeProphet> Python doesn't allow variable assignments in an expression... which makes it way more difficult (but more "pure") to write one-liners.
06:36:36 <CakeProphet> well.. Python added something for that in 2.5
06:36:46 <CakeProphet> (true if cond else false)
06:37:16 <CakeProphet> which I use... all the time.
06:37:53 -!- ShadowHntr has quit (Connection timed out).
06:38:15 <fizzie> That's a funny way to write it. Perl has the "... if cond;" statement modifier, but it doesn't add an else branch there.
06:38:37 <CakeProphet> it seemed weird at first to me too.
06:38:40 <CakeProphet> but it's grown on me...
06:38:43 <CakeProphet> it reads a lot like English.
06:38:52 <lament> true if cond else false doesn't read at all like english.
06:38:59 <lament> it reads like Forth.
06:39:10 <CakeProphet> it reads like conversational english
06:39:15 <oerjan> I suppose you cannot use ... if ... else ... inside an ... if ... else ... without parentheses.
06:39:22 <CakeProphet> how often do you put your ifs before your assertions?
06:39:29 <CakeProphet> only in formal settings.
06:39:43 <CakeProphet> but in conversation... I always say   "I like pancakes, but only if it's noon"
06:39:49 <CakeProphet> the condition came after.
06:40:08 <lament> i prefer the way forth does it.
06:40:09 <fizzie> "I like pancakes, but only if it's noon; else I like RAW MEAT ARRR."
06:40:34 <CakeProphet> well else is kind kind of a weird word.
06:40:39 <oerjan> What about pancakes with raw meat in them?
06:40:40 <CakeProphet> "otherwise" sounds more conversationally.
06:40:45 <CakeProphet> but... else is easier to write. :D
06:41:14 <lament> cond if true else false then
06:41:49 <oerjan> Yeah, Forth's then at the end is really weird.
06:41:50 <CakeProphet> hehehe... to someone unfamiliar with stack-based languages... that would look like someone scrambled the source code.
06:42:57 <CakeProphet> I'm still waiting for python to get a while-loop list comprehension/generator-expression.
06:43:03 <CakeProphet> I never use while loops that much though.
06:43:57 <CakeProphet> usually just one for the main loop of the program.
06:44:54 <RodgerTheGreat> aw, I feel so robbed! SQL doesn't allow definition of recursive functions!
06:45:03 <RodgerTheGreat> CREATE FUNCTION adder(a INT(10), b INT(10)) RETURNS INT(10) RETURN IF(b<>0, adder(a + 1, b - 1), a);
06:45:13 <RodgerTheGreat> ERROR 1424 (HY000): Recursive stored functions and triggers are not allowed.
06:45:13 <CakeProphet> oh woe is you..
06:45:23 <CakeProphet> how will you go on without SQL functions being recursive?
06:45:41 <RodgerTheGreat> I was hoping I'd stumbled upon a brilliant esocoding opportunity.
06:45:56 <RodgerTheGreat> like coding a BF interpreter in mySQL or something
06:46:03 <CakeProphet> SQL is kind of appaling though.
06:46:17 * CakeProphet had a BF interpreter coded in Excel at one point.
06:46:30 <RodgerTheGreat> cool
06:46:32 <bsmntbombdood> I remeber you talking about that
06:46:43 <CakeProphet> yeah I finally got it to work.
06:46:46 <RodgerTheGreat> but excel macros are pretty powerful to begin with
06:46:55 <CakeProphet> it can't really "print" things.
06:47:03 <CakeProphet> it just gives you the entire array to work with.
06:47:27 <CakeProphet> but I guess you could use print to accumulate characters into a single "output cell"
06:47:29 <CakeProphet> if you wanted.
06:47:55 <bsmntbombdood> cond if true-stmnt else fasle-stmt?
06:48:34 <bsmntbombdood> I can't remember enough forth
06:48:37 <lament> oerjan: not really
06:48:46 <lament> oerjan: it just means, "... and then, do this"
06:48:55 <bsmntbombdood> 2 definitions of "then"
06:50:34 <oerjan> if ... if ... else ... then else ... then
06:51:39 <CakeProphet> hmm...
06:51:55 <CakeProphet> I would have implemented it    true-stmt then false-stmt else if
06:52:09 <CakeProphet> or    false-stmt else true-stmt then if
06:52:26 <CakeProphet> reminds me of the backwardsiness of FORTH.  :D
06:52:44 <oerjan> Doesn't work with the Forth compiler principle though.
06:52:56 <bsmntbombdood> yeah
06:53:05 <RodgerTheGreat> ooh. we have an idea- we can't make recursive calls in a general sense, but we *can* define functions with our functions. We might be able to "build the tracks as our train runs on them", so to speak
06:53:07 <CakeProphet> fuck the compiler principle.
06:53:10 <bsmntbombdood> if takes the predicate off the stack
06:53:33 <CakeProphet> hmmm.... here's an idea.
06:53:36 <oerjan> Because anything found before the first "keyword" must be directly executed.
06:54:01 <CakeProphet> make an imperitive esolang modelled after "it puts the lotion on the skin"
06:54:10 <RodgerTheGreat> haha
06:54:25 <CakeProphet> oh
06:54:29 <CakeProphet> it puts the lotion of the skin
06:54:31 <CakeProphet> its
06:54:33 <CakeProphet> skin
06:54:35 <CakeProphet> bleh
06:54:36 <RodgerTheGreat> "It puts the lotion on it's skin or else it gets the hose again"
06:54:42 <CakeProphet> hahahahahaha
06:54:45 <CakeProphet> conditional
06:55:11 * oerjan wonders what the heck you are referring to.
06:56:07 <RodgerTheGreat> we're playing lambs
06:58:33 <oerjan> The obvious name for Ork's successor would be "ORK is to increment."
06:58:52 <CakeProphet> ....I'm calling mine Sophia.
06:58:52 * oerjan is still reading the logs.
06:58:55 <CakeProphet> because I like the name.
06:59:08 <CakeProphet> and because I intend to create a large number of things named "Sophia"
06:59:11 <CakeProphet> to confuse people.
07:00:25 <CakeProphet> I wonder what C++ would have been like if it included the increment in its evaluation (++C)
07:01:12 <RodgerTheGreat> haha
07:01:23 <oerjan> Obviously one of them would have a syntax like: Sophia? Sophia. Sophia! Sophia?
07:01:42 <CakeProphet> ...no
07:01:48 <CakeProphet> that's like... the worst clone ever.
07:01:53 <CakeProphet> a clone of ook...
07:01:55 <CakeProphet> that's appaling.
07:01:56 <oerjan> What, you don't want to increment Ook? :)
07:02:08 <CakeProphet> cloning a cloning is a sin.
07:02:25 <RodgerTheGreat> Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo.
07:02:44 <CakeProphet> It'll basically have ORKs syntax... with Metaclasses and coroutines...
07:02:57 <CakeProphet> and some new directive-type stuff via commands related to "Sophia"
07:03:21 <oerjan> I wasn't suggesting that you make Sophia have such a syntax, but that you make Sophia have it.
07:03:22 <CakeProphet> and some minor syntax tweaks... such as "When this program starts:"   being changed to "When Sophia loves us:"
07:03:49 <CakeProphet> no no no... I would really only consider Sophia for that kind of silliness.
07:04:11 <CakeProphet> well... that's actually not a syntax tweak...
07:04:12 <bsmntbombdood> excuse me mister but wtf ru doing?
07:04:18 <CakeProphet> because Sophia will be an object with a method "loves us"
07:04:36 <CakeProphet> so it'd be When sophia is to love us
07:05:32 <CakeProphet> oh yeah... and special methods  (yup... can't have OO without SPECIAL METHODS!!_
07:06:02 <CakeProphet> "be said"  is the string representation method (and how the object is printed when outputted)
07:06:16 <CakeProphet> When an apple is to be said:   
07:07:45 <CakeProphet> and I'll try to think of some ways to totally bastardize ORK.
07:07:51 <CakeProphet> for fun.
07:09:45 <oerjan> You could add a functional layer.
07:10:31 <CakeProphet> I plan on making it heavily corotuinal.
07:10:32 <CakeProphet> actually.
07:10:37 <CakeProphet> with the whole "ring" thing.
07:19:22 -!- digital_me_ has quit (Read error: 110 (Connection timed out)).
07:19:45 -!- Sgeo has quit (Remote closed the connection).
07:28:06 -!- calamari has left (?).
07:58:42 <Sukoshi> Hey look. I've ignored all of you for the last 2000 lines.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:00:07 <oerjan> That's OK, we were ignoring you too.
08:31:36 <Sukoshi> No, it's not OK. It's ORK.
10:20:54 -!- ihope has joined.
10:24:05 -!- oerjan has quit ("leaving").
12:54:55 <oklopol> [08:21:32] <oerjan> I think what Oklopol's nop language needs is a type system so complicated that _it_ is Turing-complete.
12:54:56 <oklopol> it is
12:55:02 <oklopol> but no IO :)
12:55:21 <oklopol> ny nop language
12:59:57 <oklopol> [08:44:14] * CakeProphet had a BF interpreter coded in Excel at one point.
13:00:09 <oklopol> if you're talking about vba, i made one during a class in school
13:02:23 <oklopol> [14:53:16] <oklopol> ny nop language
13:02:26 <oklopol> idiot :\
13:16:41 -!- andreou has joined.
13:21:04 <oklopol> it supports only datatypes list and nopad, nopad being the empty list
13:21:54 <ihope> I did Bitwise Cyclic Tag in Excel.
13:22:09 <ihope> And I don't mean a macro or anything.
13:22:21 <oklopol> with cell arithmetic?
13:22:27 <ihope> Yep.
13:22:35 <ihope> It's easier than BF, of course.
13:22:42 <oklopol> because making it in vba is as easy as in any language :)
13:22:56 <ihope> I think BCT earns the Simplest Turing-Complete Language award.
13:23:09 <oklopol> tho vb is the worst language i've run into
13:23:14 <oklopol> hmm i'll have to check it, don't remember
13:23:21 <ihope> Malbolge is the worse language I've run into.
13:23:24 <ihope> :-)
13:23:33 <ihope> And by worse, I mean worst.
13:25:21 <oklopol> well, in vb it's nicer to do a program, but i like malbolge more :)
13:25:37 <ihope> Epigram has a ridiculously strong type system, doesn't it?
13:25:58 <oklopol> i'll have to see that one too........
13:26:02 <oklopol> :\
13:31:30 <oklopol> BCT stops execution when datastring is empty?
13:32:46 * andreou would like to see the US gov't adopting mycelium as a stego device
13:37:39 <ihope> andreou: :-)
13:37:58 <ihope> They probably have better ways of doing that, you know.
13:38:30 <andreou> probably; not as cool, though
13:38:47 <ihope> Heh.
13:43:38 <andreou> a combination of filigram.c and mycelium would also produce interesting results
13:44:29 <ihope> filigram.c?
13:45:11 <andreou> it's on ../filigram/ in the site of that putty guy
13:45:15 <andreou> (sorry, no c&p here)
13:51:28 -!- ihope_ has joined.
14:07:29 -!- ihope has quit (Read error: 110 (Connection timed out)).
14:12:43 <oklopol> python: reduce ( (lambda a, b : a+b), [[[]], [[[], [], [[], []]], []], [[], [], []]] )
14:12:44 <oklopol> nopol: <<<>><<<><><<><>>><>><<><><>>>:<<..><:>:<::>>
14:13:13 <oklopol> it supports alphanumeric names tho, also comments and whitespace
14:13:44 <oklopol> the function is <<..><:>:<::>>, please crack it if you have time :)
14:15:59 <oklopol> the system is not only turing complete, it's actually pretty nice to write algorithms in
14:18:46 -!- jix__ has joined.
14:54:41 <oklopol> nopol is getting quite complicated for a language you cannot do anything with :\
14:59:38 <oklopol> i think the best feature is you can have lists of negative depth, if a([b]) == b, a(a(a([]))) for example is valid code :)
15:00:09 <oklopol> i gotta finish it so i can make a compiler!
15:00:35 <oklopol> the standard for compilers guarantees a -f final build mode that optimized the whole program to one nop
15:00:46 <oklopol> *optimizes
15:01:22 <andreou> to one nop?!
15:01:30 <oklopol> yes
15:01:45 <oklopol> because, any number of nops is essentially one nop
15:01:48 <andreou> *every* program does absolutely nothing and does it in a quirky way?
15:01:55 <oklopol> yeah :)
15:02:10 <andreou> ah i didn't read the specs -- are there any or is it WIP"?
15:02:14 <oklopol> of course, you can have fun with it with a debugger
15:02:37 <oklopol> because you see what's happening in the memory
15:02:40 <oklopol> specs?
15:02:43 <oklopol> for the lang?
15:02:57 <andreou> heh yeah
15:03:05 <andreou> i think this kind of fun is easier with hallucinogens
15:03:13 <oklopol> :)
15:03:20 <oklopol> i'm not ready yet with the language
15:03:40 <oklopol> and it will be very hard to make an interpreter
15:03:46 <oklopol> (with debugging)
15:04:34 <oklopol> i have to think over all the commands and such to make everything as logical as possible
15:04:45 <oklopol> but not today
15:04:51 <oklopol> gotta go
15:05:34 <andreou> k cheers
15:11:31 <andreou> k cheers
15:11:32 <andreou> eh
15:20:13 -!- pikhq has joined.
15:29:09 -!- andreou has quit ("kernel test").
15:33:01 -!- andreou has joined.
16:24:51 -!- andreou has quit ("kernel test").
16:27:21 -!- tgwizard has joined.
16:31:16 -!- andreou has joined.
16:56:17 -!- wooby has quit.
17:05:01 -!- calamari has joined.
17:05:10 <calamari> hi
17:06:07 <RodgerTheGreat> howdy, calamari 
17:06:58 <calamari> apparently some spammers decided @kidsquid.com is a good return address :(  getting lots of failure notices
17:07:13 -!- FabioNET has joined.
17:15:34 -!- ais523 has joined.
17:16:16 <ais523> So there are people on #esoteric at the moment after all, then? I was monitoring the logs to see if anyone was online, but somehow I never seem to be online at the same time as other people...
17:16:51 <ais523> !help
17:16:54 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
17:16:56 <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
17:17:02 <ais523> !help fyb
17:17: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.
17:17:40 <ais523> !fyb :>+!;
17:17:44 <EgoBot> cp: cannot create regular file `fyb/cache/egobot.AbWxMh': Permission denied
17:18:19 <ais523> !ps
17:18:22 <EgoBot> 1 ais523: ps
17:19:00 <ais523> After that publicly-visible error message, EgoBot started spamming me with error messages...
17:20:22 <andreou> happens occasionally
17:20:40 <ais523> Besides, how can it run a single fyb program anyway, considering that two of them, using each other as data space, are needed for the program to work?
17:21:29 <andreou> beats me
17:22:06 <ais523> !fyb file://bomber.fyb
17:22:08 <EgoBot> cp: cannot stat `./files/bomber.fyb': No such file or directory
17:22:42 <andreou> i think it supports http
17:23:25 <ais523> I think it tries to run the program it's given against an internal list of programs to compete against, but it's getting 'permission denied' errors on the programs it has stored
17:23:41 <ais523> !ps
17:23:43 <EgoBot> 1 ais523: ps
17:24:15 * ais523 discovers that giving EgoBot another command stops the error-message spam
17:24:33 <ais523> !fybs :>+!;
17:24:38 <EgoBot> Reporting score for :>+!;.
17:26:12 <ais523> !ps
17:26:15 <EgoBot> 1 ais523: ps
17:26:25 <ais523> It just sent me three hyphens and stopped...
17:29:00 <ais523> !unlambda ```s``s``sii`ki`k.*``s``s`ks``s`k`s`ks``s`k`s`k./``s`k`sikk`k``s`ksk
17:29:03 <EgoBot> /*//
17:29:05 <ihope_> Maybe it lost three games in a row.
17:29:23 <ais523> I suppose so, it wasn't a very good program...
17:30:12 <ais523> !fybs +[>[-]!+]
17:30:15 <EgoBot> Reporting score for +[>[-]!+].
17:30:46 <ais523> More hyphens. But that's a really vulnerable program, due to the tight loop near the start...
17:36:29 <ais523> !fyb {>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]++++++++++++++!}
17:36:31 <EgoBot> cp: cannot create regular file `fyb/cache/egobot.YnjVgJ': Permission denied
17:36:43 <ais523> !ps
17:37:22 <EgoBot> 1 ais523: fyb
17:37:24 <EgoBot> 2 ais523: ps
17:37:52 <ais523> Hey, I think I actually beat some of its library
17:38:11 <ais523> !fybs {>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]++++++++++++++!}
17:38:14 <EgoBot> Reporting score for {>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]++++++++++++++!}.
17:38:41 <ais523> More hyphens, but there was something encouraging in the error messages on the plain fyb
17:42:31 <pikhq> Hello.
17:42:34 <ais523> !fyb %:[%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%[-]!]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]++++++++++++++!;{{>>>>}{>>>>}[-]++++++++++++++!}
17:42:36 <EgoBot> cp: cannot create regular file `fyb/cache/egobot.Gl82IV': Permission denied
17:42:45 <ais523> Hello, pikhq!
17:43:30 <pikhq> Enjoying Esolangs?
17:44:05 <pikhq> BTW, IIRC, fyb will compare the program given and some of the builtins.
17:44:18 <pikhq> And it seems that Gregor has fucked up Egobot a bit.
17:44:40 <pikhq> GregorR: Give egobot write access to itself.
17:45:05 <ais523> Yes, I'm enjoying esolangs. I enjoyed the logs, too, before I had access to an IRC client.
17:45:26 <ais523> !ps
17:45:29 * pikhq continues hugging BFM
17:45:29 <EgoBot> 1 ais523: ps
17:45:57 <ais523> The new program seems less good than the old one. Maybe it's better to be simple...
17:47:17 <ais523> !fyb :>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]+++++++++++++++!;:>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]+++++++++++++++!;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]+++++++++++++++!;
17:47:19 <EgoBot> cp: cannot create regular file `fyb/cache/egobot.2yppuf': Permission denied
17:48:03 <ais523> !ps
17:48:07 <ais523> losing again...
17:48:07 <EgoBot> 1 ais523: ps
17:49:02 -!- oerjan has joined.
17:49:19 * ais523 tries something really simple
17:49:22 <pikhq> string f! "Hello, oerjan."
17:49:26 <pikhq> outs f!end
17:49:43 <ais523> !fyb {>>>}{>>>}+++++++++++++++!
17:49:46 <EgoBot> cp: cannot create regular file `fyb/cache/egobot.CZrAiN': Permission denied
17:50:25 <ais523> !help
17:51:43 <ais523> !ps
17:51:46 <EgoBot> 1 ais523: ps
17:52:20 <ais523> The ps command does seems to stop the flow of error messages and useful answers... (it lost every single game, BTW)
17:53:24 <ais523> Hey, how does EgoBot manage the 2D languages?
17:54:06 <ais523> !help 1l
17:54:08 <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.
17:54:27 <ais523> Oh, it seems that it reads it off the Web
17:56:22 <ais523> !1l http://esoteric.voxelperfect.net/files/1l/src/1l_a/a.1l
17:56:24 <EgoBot> A
17:57:17 * pikhq is a bit sad that EgoBot doesn't seem to support Dimensifuck. . .
17:57:42 <pikhq> It's my n-dimensional Brainfuck variant. . .
17:57:42 <ais523> !help
17:57:46 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
17:57: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
17:58:02 * pikhq needs to write a BF->DF compiler
17:58:11 <ais523> It doesn't have any of my languages either.
17:58:19 <pikhq> Which are?
17:59:07 <ais523> BackFlip, Underload, and MiniMAX are the main ones (there are also some BackFlip derivatives like ABCDXYZ and Unassignable)
17:59:51 <pikhq> Hmm. . .
17:59:59 * pikhq still <3 BFM. . .
18:00:05 <pikhq> My macro system for Brainfuck.
18:00:11 <pikhq> With much thanks to oerjan.
18:00:29 <ais523> How do you do a loop in Dimensifuck? The wiki isn't clear on how you affect the program flow
18:00:58 <pikhq> =v
18:01:03 <pikhq> Err. . .
18:01:18 <pikhq> =v    =v ^
18:01:39 <pikhq>  _    _ _
18:02:05 <pikhq>  ^code=^+v
18:02:06 <ais523> So v and ^ affect the program counter?
18:02:19 <pikhq> v and ^ conditionally change the direction of program flow.
18:02:33 <pikhq> = and _ change the dimension v and ^ effect.
18:03:53 <ais523> So you could compile BF into 2D Dimensifuck just by drawing loops to represent literal loops, in much the same way as Sansism
18:04:46 -!- andreou has quit ("-").
18:05:14 <ais523> Maybe it would be possible to do it without wire-crossings
18:08:15 -!- sebbu has joined.
18:11:41 <ais523> !fybs {>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]++++++++++++++!}
18:11:45 <EgoBot> Reporting score for {>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]++++++++++++++!}.
18:15:47 <pikhq> Well, I can *hand*compile BF to Dimensifuck. . .
18:19:13 <ais523> If you assign each loop its own y-coordinate (or better, its own dimension), you could use each of those as a bypass path for the loop if the value is zero
18:19:22 <ais523> and assign another one for the return path
18:19:27 <oerjan> I would expect every BF command to be compiled to a fixed 2D-block of DF commands, except for [], where you need to vary the height of the loop to avoid crossings.
18:20:12 <ais523> + - < > , . are all the same in DF, so it's only the flow control you have to deal with
18:20:58 <ihope_> !
18:21:05 <EgoBot> Huh?
18:21:15 <ihope_> And for a minute there I thought ! no longer did anything.
18:21:42 <oerjan> !daemon nop bf ,[,]
18:22:23 -!- ais523 has quit ("about to lose Internet access for a while").
18:28:30 * SimonRC fails to understand today's xkcd.
18:28:38 <pikhq> !daemon  bf ,[,]
18:28:38 <pikhq> !
18:28:48 <pikhq> I win.
18:28:54 <pikhq> !nop
18:29:15 * oerjan hands pikhq the golden cup
18:29:52 * pikhq joins SimonRC.
18:35:02 <pikhq> :)
18:43:13 <calamari> sorry, I'm a bit out of the loop.. is this some kind of game you are playing?
18:43:19 <bsmntbombdood> ~quit
18:43:20 -!- bsmnt_bot has quit.
18:43:24 -!- bsmnt_bot has joined.
18:43:40 <pikhq> Nope.
18:43:42 <EgoBot> cannot open checkpoint file /home/gregor/esoteric/egobot/egobot/daemons/: Is a directory
18:43:43 <EgoBot> cannot obtain a checkpoint stream
18:43:55 <bsmntbombdood> heh
18:43:59 <bsmntbombdood> EgoBot is broken
18:44:10 <pikhq> Gregor, do you not have write access to your home dir?
18:45:12 <bsmntbombdood> !bf +[>+]
18:45:22 <EgoBot> realloc: Cannot allocate memory
18:45:44 -!- digital_me has joined.
18:46:21 <bsmntbombdood> !bf -[->+<]
18:46:38 <calamari> <ihope_> Maybe it lost three games in a row.
18:46:44 <calamari> ^^^ what does this mean? :)
18:46:49 <pikhq> !bf ++++++++++.
18:46:53 <pikhq> calamari: FYB.
18:47:00 <bsmntbombdood> SimonRC: me too
18:51:23 -!- digital_me has quit ("Lost terminal").
19:03:31 * pikhq continues prodding Gregor
19:33:17 -!- pikhq has quit (Read error: 104 (Connection reset by peer)).
19:35:06 -!- pikhq has joined.
19:42:05 -!- ShadowHntr has joined.
19:48:02 <pikhq> Kill egobot, Gregor.
19:48:22 <bsmntbombdood> kiiiiiil it
19:48:25 <bsmntbombdood> kiiiiiil it!
19:48:55 * CakeProphet remembers how much he loves duck typing.
19:48:59 <pikhq> I'm getting PMd error messages.
19:49:02 <bsmntbombdood> duck typing is nice
19:49:05 <bsmntbombdood> can't do that in c++
19:49:09 <CakeProphet> it makes sense.
19:49:52 <CakeProphet> What data can do should be defined by its propertie, rather than some "type".  :P
19:50:54 <CakeProphet> and...
19:50:57 <CakeProphet> it has a cool name.
19:51:00 <CakeProphet> you can't beat that.
19:53:41 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
19:53:54 -!- EgoBot has joined.
19:54:35 <pikhq> Now, chmod some of its directories +w.
19:54:43 <pikhq> !bf ++++++++++.
19:54:50 * pikhq waits for the error message
19:55:23 * pikhq waits for a newline, even
19:55:55 <oklopol> !bf +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
19:55:59 <EgoBot> A
19:56:12 <oklopol> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
19:56:16 <oklopol> !bf +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
19:56:19 <EgoBot> A
19:57:31 <GregorR> You realize that prodding is useless if you don't say "GregorR"
19:57:45 <GregorR> What with IRC clients highlighting tabs and such.
19:59:23 <pikhq> GregorR, you didn't respond when I said your full name.
19:59:47 <GregorR> I was asleep :-P
19:59:56 <pikhq> Is your home dir rw now?
20:00:07 <pikhq> !daemon  bf ,[,]
20:00:09 <bsmntbombdood> hook up your alarm clock to your irc client
20:00:10 <pikhq> !
20:00:58 <GregorR> OK, fyb is fixed.
20:01:12 <bsmntbombdood> !bf_txtgen A
20:01:37 <GregorR> And it runs as user egobot in /home/gregor/esoteric/egobot/egobot :P
20:01:38 <bsmntbombdood> there should be an algorithmic bf textgen
20:01:39 <EgoBot> 30 ++++++++[>++++++++>>><<<<-]>+. [53]
20:01:58 <bsmntbombdood> 30 characters to make an A??
20:02:00 <oklopol> !bf >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++.>-------------.>++.>++++++++.>+++.>--------------------------------.
20:02:03 <EgoBot> G+óà
20:02:06 <oklopol> :)
20:02:13 <oklopol> well, getting close
20:02:19 <oklopol> oh
20:02:50 <oklopol> !bf +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++.-------------.++.++++++++.+++.--------------------------------.
20:02:53 <EgoBot> GregorR
20:02:56 <oklopol> :)
20:03:01 <oklopol> i made a generator too!
20:03:04 <oklopol> xD
20:03:17 <bsmntbombdood> it's less effecient than EgoBot's
20:03:24 <bsmntbombdood> !bf_txtgen GregorR
20:04:01 <EgoBot> 80 ++++++++++++++[>+++++>++++++>++++++++>+++++++<<<<-]>+.>>++.>+++.++.<---.+++.<--. [250]
20:04:08 <bsmntbombdood> yep
20:05:00 <oklopol> is it really?!?!?!?!? :D
20:05:22 <oklopol> actually, mine is not much slower
20:05:33 <oklopol> just longer
20:05:35 <bsmntbombdood> EgoBot uses a genetic algorithm
20:05:42 <oklopol> genetic?
20:06:09 <oklopol> mine uses a generic algorithm and i wrote it just now in python in 2 minutes
20:06:33 <oklopol> so, yeah it sucks but i love all those chains of letters <3
20:06:57 <oklopol> what algorithm is GregorR's anyway?
20:07:13 <bsmntbombdood> GregorR: You should pipe the output of bf_txtgen through a bf optimizer
20:07:31 <bsmntbombdood> to remove the >>><<< stuff
20:08:45 <oklopol> [250]?
20:09:14 <GregorR> textgen.java . Look @ calamari :-P
20:09:14 <bsmntbombdood> my guess is the generations it wen't through
20:09:48 <oklopol> can i see the thingie?
20:09:51 <GregorR> ^[0-9]+ is the length, \[[0-9]+\]$ is the generations.
20:10:04 <GregorR> It's in the files archive.
20:10:08 <bsmntbombdood> that's what I thought
20:10:35 -!- maverickbna has joined.
20:11:11 -!- ShadowHntr has quit (Nick collision from services.).
20:11:52 <oklopol> okay, what is the files archive :)
20:12:03 -!- ShadowHntr has joined.
20:12:10 -!- ShadowHntr has quit (Read error: 104 (Connection reset by peer)).
20:12:41 <GregorR> http://www.esolangs.org/wiki/LOOK_IT_UP_YOURSELF
20:12:56 <GregorR> Or just http://www.esolangs.org/ :-P
20:13:00 <oklopol> i found no archive :\
20:13:10 <oklopol> :O
20:13:12 <oklopol> OMG
20:13:24 <oklopol> SUPRISINGLY IT WAS NOT IN THE WIKI
20:13:38 <bsmntbombdood> stupid java
20:14:15 <oklopol> okay
20:14:21 <oklopol> i can't find it there either :)
20:14:29 <bsmntbombdood> http://www.esolangs.org/files/egobot/ ?
20:14:52 <oklopol> oh
20:15:09 <EgoBot> cannot open checkpoint file /home/gregor/esoteric/egobot/egobot/daemons/: Is a directory
20:15:11 <oklopol> i thought it was like in a separate folder :)
20:15:11 <EgoBot> cannot obtain a checkpoint stream
20:15:24 <bsmntbombdood> HA HA HA E GO BO T
20:15:36 <GregorR> That's curious :-P
20:15:45 <GregorR> !ps d
20:15:47 <EgoBot> 1 EgoBot: daemon nop reload
20:15:49 <EgoBot> 2 pikhq: daemon  bf
20:15:51 <EgoBot> 3 GregorR: ps
20:15:55 <bsmntbombdood> You're just an e go bo t
20:15:55 <GregorR> Damn you pikhq ;)
20:16:00 <GregorR> !undaemon  
20:16:10 <GregorR> Of course X-D
20:16:27 <oerjan> Aha
20:16:48 * pikhq grins
20:17:05 <oerjan> now what i wanted to check.
20:17:37 <bsmntbombdood> Someone needs to do something clever with bsmnt_bot 
20:17:48 <pikhq> GregorR: I can be cruel to bots at times.
20:18:02 <oerjan> !daemon bf bf ,[.,]
20:18:13 <oerjan> !bf Testing...
20:18:14 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
20:18:18 <bsmntbombdood> heh
20:18:24 -!- EgoBot has joined.
20:18:26 <GregorR> Hm.
20:18:30 <oerjan> !ps d
20:18:32 <pikhq> !daemon glass bf ,[.,]
20:18:33 <GregorR> That's sort of bad X-P
20:18:33 <EgoBot> 1 EgoBot: daemon nop reload
20:18:35 <EgoBot> 2 oerjan: ps
20:18:41 <bsmntbombdood> I should read the EgoBot source
20:18:45 <pikhq> !glass Whee.
20:18:49 <EgoBot> Whee.
20:18:54 <pikhq> !undaemon glass
20:18:57 <EgoBot> Process 2 killed.
20:18:58 <GregorR> You jackass :-P
20:19:05 <pikhq> !daemon glass glass ''
20:19:11 <pikhq> !glass There we go.
20:19:12 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
20:19:21 -!- EgoBot has joined.
20:19:27 <pikhq> Hmm.
20:19:38 <pikhq> !daemon cat cat f
20:19:39 <pikhq> !cat f
20:19:40 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
20:19:42 <oerjan> Apparently daemons can be recursive?
20:19:46 <pikhq> Can't.
20:19:50 -!- EgoBot has joined.
20:19:53 <bsmntbombdood> dude, wtf
20:19:53 <GregorR> Can't successfully :-P
20:19:58 -!- maverickbna has quit (Read error: 145 (Connection timed out)).
20:20:00 <bsmntbombdood> you wrote it in c++?
20:20:08 <GregorR> I'm a C++'er.
20:20:11 <GregorR> !daemon bf undaemon bf
20:20:12 <bsmntbombdood> That just ain't right
20:20:12 <EgoBot> Process 1 killed.
20:20:17 <GregorR> !bf foo
20:20:31 <bsmntbombdood> NOT COOL DUDE
20:20:32 <pikhq> !bf foo
20:20:37 <oklopol> bsmntbombdood, as wouter said, ppl who don't like c++ don't understand it
20:20:44 <GregorR> bsmntbombdood: People who don't like C++ --- thanks, oklopol 8-D
20:20:51 <oklopol> :)
20:20:53 * pikhq needs to fiddle with egobot a bit
20:21:25 <oerjan> !daemon undaemon bf
20:21:38 * oerjan cackles evilly
20:21:39 <bsmntbombdood> what's cerr?
20:21:55 <GregorR> oerjan: 8-X
20:21:56 <pikhq> Dude, wtf?
20:22:13 <oerjan> !ps d
20:22:16 <EgoBot> 1 oerjan: ps
20:22:22 <pikhq> Why the hell are you writing IRC commands to stderr?
20:22:22 <oerjan> Hmmm..
20:22:31 <pikhq> bsmntbombdood: It's the C++ stream interface to stderr.
20:22:37 <bsmntbombdood> oh
20:22:45 <oerjan> !daemon undaemon bf ,[,]
20:22:48 <oerjan> !ps d
20:22:51 <EgoBot> 1 oerjan: daemon undaemon bf
20:22:52 <EgoBot> 2 oerjan: ps
20:23:01 <GregorR> pikhq: netcat is a bit funky :(
20:23:05 <oerjan> That's better. Or worse.
20:23:23 <bsmntbombdood> heh, I don't understand the source at all
20:23:40 <GregorR> ...
20:23:41 <pikhq> !help raw
20:23:42 <GregorR> !undaemon undaemon
20:23:44 <EgoBot> Process 1 killed.
20:23:45 <pikhq> bsmntbombdood: What's wrong with you.
20:23:46 <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.
20:23:57 <GregorR> pikhq: There's no help on !raw
20:24:19 <pikhq> !raw QUIT :I don't want to live!
20:24:43 <bsmntbombdood> what's lockIRC_o()?
20:24:45 <GregorR> !raw PRIVMSG #esoteric :Do you /really/ think I use security by obscurity, dorkus?
20:24:45 <EgoBot> Do you /really/ think I use security by obscurity, dorkus?
20:25:21 <pikhq> !raw PRIVMSG bsmntbombdood :Don't answer that.
20:25:53 * pikhq realised something stupid
20:26:02 <pikhq>                         if (sender != string(argv[2])) continue;
20:26:18 <pikhq> So Gregor alone can use raw.
20:26:32 <pikhq> Same for reload.
20:26:37 <pikhq> (bastard)
20:27:56 <pikhq> ./egobot EgoBot GregorR esoteric 10485760 >> EGOOUT
20:28:11 <pikhq> I don't understand how the fuck that allows netcat to access IRC.
20:29:00 <bsmntbombdood> what's a "trigger interpreter"?
20:31:51 <bsmntbombdood> ooooh, trigger is an esolang
20:36:06 <pikhq> At least there aren't any buffer overflows to exploit. . .
20:36:41 <pikhq> . . . I think I stand corrected.
20:36:59 <oklopol> !bf_txtgen was this the command?
20:37:13 <oklopol> !help
20:37:17 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
20:37:19 <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
20:37:27 <oklopol> okay
20:37:37 <oklopol> i... se
20:37:37 <oklopol> *See
20:38:01 <EgoBot> 162 +++++++++++[>+++>+++++++++++>+++++++++>++++++<<<<-]>>--.>--.<----.<-.>+.>+++++++.+.<-.<.>+.------------.---.<.>--.++++++++++++.--..------------.>+++++.<+++.>>---. [930]
20:38:11 <pikhq> No, your use of C strings is safe. . .
20:38:18 <pikhq> Still. . . Bad Gregor!
20:38:19 <oklopol> !bf_txtgen test
20:38:40 <bsmntbombdood> You should have written it in bf
20:38:51 <EgoBot> 54 +++++++++++++[>+++++++++>++++++++>><<<<-]>-.>---.<-.+. [32]
20:38:54 <oklopol> !bf_txtgen test
20:39:22 <bsmntbombdood> args.substr(0, 7) == "http://"
20:39:25 <EgoBot> 54 +++++++++++++[>+++++++++>++++++++>><<<<-]>-.>---.<-.+. [316]
20:39:41 <bsmntbombdood> Double quotes don't evaluate to a c string in c++?
20:39:52 <pikhq> Using char arrays in C++ isn't wise.
20:39:52 <oklopol> yes
20:41:56 <bsmntbombdood> What's the point of forking and then waitpid()ing on it?
20:44:10 <pikhq> "foo" is a static C string in C++. . .
20:50:03 <bsmntbombdood> Then line 253 of cmd.cc is broken I think
20:50:24 <bsmntbombdood> unless string::substr is magice
20:50:30 <bsmntbombdood> *magiv
20:50:33 <bsmntbombdood> *magic
20:51:21 <bsmntbombdood> No idea what the function is used for
20:54:02 <GregorR> Not broken.
20:55:14 -!- cmeme has quit (Connection timed out).
20:55:43 <bsmntbombdood> Oh right
20:55:55 <bsmntbombdood> string overloads ==
20:56:45 <pikhq> string::substr is magic, indeed.
20:56:46 <pikhq> ;)
20:57:31 <bsmntbombdood> yeah
21:01:27 <oklopol> how does the txtgen randomize the same string every time :\
21:01:37 <oklopol> or, even two times in succession
21:02:54 <pikhq> It's a genetic algorithm. . . You're experiencing dumb luck.
21:05:59 -!- Sukoshi has quit ("ERC Version 5.1 (CVS) $Revision: 1.796 $ (IRC client for Emacs)").
21:06:08 <bsmntbombdood> heh, ERC
21:08:07 <bsmntbombdood> !bf http://esoteric.sange.fi/brainfuck/bf-source/prog/99botles.bf
21:08:12 <EgoBot> 99 Bottles of beer on the wall 
21:08:20 <bsmntbombdood> damn, pm
21:08:31 <bsmntbombdood> !ps
21:08:34 <EgoBot> 1 bsmntbombdood: ps
21:08:35 <bsmntbombdood> !kill 1
21:08:38 <EgoBot> Process 1 killed.
21:13:37 -!- oerjan has quit ("leaving").
21:39:11 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
21:41:26 <CakeProphet> Wow...
21:41:30 <CakeProphet> This is great.
21:41:38 * CakeProphet absolutely loves the ring idea.
21:44:12 <bsmntbombdood> I don't understand why it's so great
21:45:21 <CakeProphet> In a static universe... it wouldn't be all that great.
21:45:21 <pikhq> I don't know what idea it is.
21:45:38 <CakeProphet> for a dynamic universe... it's pretty damn sweet.
21:45:41 <CakeProphet> and I've changed it a bit.
21:45:54 <CakeProphet> It's a sequence of functions that can be called.
21:46:59 <CakeProphet> when you call a ring... it calls the first function with those arguments, and uses the return value as the arguments for the next function, etc
21:47:20 <CakeProphet> but there's a "ring return value" as well... which is what the ring returns as a whole.
21:47:39 <CakeProphet> it's like function decorators.
21:47:53 <CakeProphet> but... not exactly.
21:48:51 <CakeProphet> it's not really meant to be a "pure" function (no side-effects)
21:48:59 <CakeProphet> it would work best where everything is a side-effect.
21:55:04 <ihope_> People who don't like C++ don't understand it? Lies!
21:55:33 <ihope_> I refuse to use any programming language that I cannot code first-order logic theories into!
21:56:47 <bsmntbombdood> I hate that excuse that people give
21:57:03 <bsmntbombdood> "You don't like it, so you must not understand it"
21:59:22 -!- Sgeo has joined.
21:59:29 <CakeProphet> That would be assuming that anything understood is liked.
22:00:10 * bsmntbombdood reads K&R
22:00:20 <ihope_> K&R?
22:00:31 <ihope_> That's not the virtualization thing, is it?
22:00:49 -!- sebbu has quit (Connection timed out).
22:00:49 <bsmntbombdood> no
22:01:02 <bsmntbombdood> kernighan and ritchie
22:01:20 -!- pikhq has quit (Read error: 104 (Connection reset by peer)).
22:01:56 -!- pikhq has joined.
22:07:25 <oklopol> No, CakeProphet, just that C++ is nice when you get it.
22:07:36 <oklopol> oh
22:07:46 <oklopol> you did say it genericly
22:07:50 <oklopol> math ->
22:11:07 -!- olli90 has joined.
22:11:13 <olli90> hi all
22:11:28 <pikhq> Hello.
22:12:47 <olli90> I have a question reguarding BrainF*ck ....
22:12:51 <olli90> can you help me?
22:14:46 <ihope_> Sure.
22:14:54 <ihope_> Depends on the question, of course...
22:15:50 <olli90> i have to make a brainfuck program that checks a string...
22:16:02 <olli90> like a serial key checker
22:16:21 <ihope_> You *have* to?
22:16:45 <ihope_> Check one string against another, then?
22:16:48 <olli90> i wuold like to
22:16:53 <olli90> xD
22:17:00 <olli90> sry for my english
22:17:46 <olli90> then if the first is = to the second the program prints "OK" and is not = the program prints "wrong"
22:18:48 <pikhq> Hmm. . .
22:19:26 <pikhq> I can think of the basic structure for such a program in BFM. . .
22:19:46 <pikhq> Would it be a specific, builtin string, or would it compare two strings from stdin?
22:19:48 * ihope_ slaps pikhq
22:20:07 <bsmntbombdood> are the lengths known?
22:20:07 <olli90> it haves to compare 2 strings...
22:20:10 <pikhq> ihope_: Sorry. . . It's easy to think about it at higher levels of abstraction.
22:20:11 <olli90> no
22:20:19 <olli90> yes i know
22:20:28 <ihope_> Input a character, go right, increment, go right, input a character, go right, increment, go right...
22:20:45 <ihope_> Continue until you receive a newline.
22:21:26 <ihope_> After you receive it, go left to the cell you incremented last, then [<<], then go right.
22:22:11 <ihope_> From there, you're at the beginning of the string you want to check against, and there's one cell between each pair of characters, and the next thing that will be input is the other string.
22:22:27 <olli90> ok
22:23:09 <olli90> thanks
22:23:25 <olli90> I think I have undertund :D
22:25:46 <olli90> bye
22:25:50 -!- olli90 has quit ("KVIrc 3.2.3 Anomalies http://www.kvirc.net/").
22:25:52 * pikhq realises one thing that could be much faster in BFM, when compiled into Tcl and interpreted. . .
22:25:56 <pikhq> itoa is slow as hell
22:28:16 <pikhq> Of course, I know an even easier way to make the BFM interpreter faster.
22:28:27 <pikhq> Make it just compile to BF and run through egobfi.
22:28:49 <CakeProphet> Compile it to C.
22:28:53 <CakeProphet> C is nice and face.
22:28:56 <CakeProphet> st
22:29:15 <pikhq> That's great and all, but BFM already targets C.
22:29:37 <pikhq> I just need to get c.tcl pulled over onto my laptop and package it up.
22:29:45 <pikhq> Besides, egobfi8 is very fast.
22:30:07 <pikhq> tclsh ./bfm.tcl -f ~/esoteric/bfm/bott.bfm  1.22s user 0.04s system 56% cpu 2.218 total
22:30:11 <pikhq> egobfi8  0.14s user 0.07s system 9% cpu 2.213 total
22:30:28 <pikhq> Comparing with the BFM interpreter. . .
22:30:34 <pikhq> Give it a few minutes.
22:31:07 <pikhq> (comparing with my in-BFM implementation of 99 bottles of beer)
22:32:23 <pikhq> 79.
22:32:46 <pikhq> Like I said: the in-BFM itoa implementation is slow as fuck.
22:33:10 <pikhq> (at least, it is in an environment where your interpretation of a while loop is very, very slow)
22:33:15 <ihope_> Just how slow is fuck?
22:33:48 <pikhq> I'm watching the thing spit out a string, wait a few seconds, spit out a number and a string, and so on and so forth.
22:34:34 <pikhq> Unbuffered output lets me see what the bottleneck is. . .
22:34:58 <pikhq> String output goes pretty quickly, even for a rather slow interpreter.
22:35:17 <pikhq> tclsh ./bfm.tcl -f ~/esoteric/bfm/bott.bfm -I  285.46s user 0.37s system 98% cpu 4:48.95 total
22:35:22 <pikhq> That's how slow fuck is.
22:36:57 -!- tgwizard has quit (Remote closed the connection).
22:39:15 * pikhq has made the thing a bit faster now. . .
22:39:29 <pikhq> I removed redundant calls to itoa in my bott.bfm program.
22:39:43 <pikhq> It should be 3 times as fast.
22:39:49 <pikhq> Which is still rather slow. . .
22:41:25 <pikhq> tclsh ./bfm.tcl -f ~/esoteric/bfm/bott.bfm -I  130.26s user 0.34s system 92% cpu 2:20.87 total
22:41:42 <pikhq> tclsh ./bfm.tcl -f ~/esoteric/bfm/bott.bfm  0.89s user 0.05s system 93% cpu 1.005 total
22:41:45 <pikhq> egobfi8  0.11s user 0.06s system 9% cpu 1.886 total
22:42:34 <pikhq> Now, we all know how slow fuck is.
22:43:47 <oklopol> i actually made an assignment! :)
22:43:53 <pikhq> . . . Yes?
22:45:30 <oklopol> Math.
22:45:41 <pikhq> . . .
22:45:55 <oklopol> i've done maybe 10 in high school if you don't count exams, so i'm very proud -_______-
23:12:51 <pikhq> . . . Wow.
23:13:01 <pikhq> I've got 939 lines of code in BFM. . .
23:13:16 <pikhq> Not counting my C backend, which I have yet to sync in with the rest of my tree.
23:13:59 <pikhq> My pre-rewrite build was 325 lines.
23:14:17 <pikhq> Kind of odd that I managed to have the thing grow in size as it increased in readability.
23:37:46 -!- FabioNET has quit ("notte notte").
23:38:37 <ihope_> oklopol: you made an assignment?
23:39:24 <ihope_> You assigned something, then?
23:39:32 <pikhq> char a = 2;
23:39:34 <pikhq> Hard.
23:42:15 <oklopol> ya i assigned my foot in yer ass :\
23:45:11 <oklopol> I had to carry out a derivation manually :OO
23:45:18 <oklopol> verry omg!
23:48:02 <ihope_> Gasp!
23:50:25 <oklopol> I have to do 150 to pass the course. I know the answer when I've read the question but it takes 20 minutes to do it.
23:50:31 <oklopol> so... 50 hours
23:50:33 <oklopol> for nothing

2007-01-16:

00:16:44 * SimonRC goes away (but not yet to bed).
00:25:34 -!- cmeme has joined.
00:45:15 -!- RodgerTheGreat has quit.
00:47:31 -!- pikhq has quit ("leaving").
00:52:23 -!- RodgerTheGreat has joined.
01:03:55 -!- ihope_ has quit ("http://tunes.org/~nef/logs/esoteric/06.08.09").
01:11:03 <bsmntbombdood> zomg, the apocalypse
01:11:05 <bsmntbombdood> Mon Jan 18 20:14:07 2038
01:19:33 <pgimeno> btw, who was the one who decided that that was the perfect format for a timestamp standard?
01:30:00 <bsmntbombdood> probably ken or dmr, but i'm just geussing
01:38:32 <bsmntbombdood> wikipedia implies dmr
01:42:54 <GregorR> It does seem kind of silly to make a timestamp with an end time that could actually be in your lifetime.
01:43:16 <GregorR> But keep in mind that REALLY olde Unix precursors had timestamps so small, they had to have multiple epochs per year.
01:44:09 <bsmntbombdood> the 32 bit 60hz timers
01:53:28 -!- andreou has joined.
02:04:59 <bsmntbombdood> weird
02:05:08 <bsmntbombdood> the C "static" keyword
02:05:22 <bsmntbombdood> that's kind of coruitine-esque
02:06:54 -!- andreou has quit ("rbt").
02:30:15 -!- pikhq has joined.
02:51:18 -!- digital_me has joined.
03:44:31 <CakeProphet> hmmm..
03:44:55 <CakeProphet> one cool thing I noticed about C++ is that you can have two functions with the same name but with different parameter types.
03:45:15 <CakeProphet> that could be really useful... saves a lot of effort with type checking.
03:45:30 <pikhq> It's called "overloading".
03:45:34 <pikhq> Welcome to C++.
03:46:00 <CakeProphet> When Python gets optional type declarations, I hope they do that to.
03:46:22 <CakeProphet> Duck typing -and- that kind of operator overloading would be great.
03:47:43 * pikhq much prefers the Tcl way of things. . .
03:47:47 <pikhq> Typing? What typing?
03:48:06 <pikhq> It autocasts into what you use it as.
03:48:16 <pikhq> Say you input a string, and want to treat it like a number.
03:48:18 <CakeProphet> that could be useful for some things.
03:48:24 <pikhq> One just treats the variable as a number.
03:48:39 <CakeProphet> You could easily select between the two.
03:48:53 <pikhq> You want to cast a list into a string?
03:48:58 <CakeProphet> I like all the options C and C++ have... I'll just have to get used to static typing and all those silly brackets.
03:49:01 <pikhq> One just uses a string function on it.
03:49:22 <pikhq> The brackets, once you get used to it, seem more like a god-send then anything else.
03:49:28 <CakeProphet> a lot of them seem to be just pure for-the-sake-of-optimization things though... like inline functions.
03:49:35 <CakeProphet> Why's that?
03:50:08 <pikhq> I parse brackets much more effectively than levels of indentation.
03:50:49 <pikhq> if(foo()) {compound;statement;here;}, for some reason, just makes sense to me.
03:51:19 <CakeProphet> Indentation is a lot easier to read for me... except when there's brackets included.
03:51:23 <CakeProphet> then it just kinda looks weird.
03:51:53 <pikhq> With Tcl, the brackets really, *really* make sense.
03:52:10 <pikhq> A curly bracket denotes a list. . .
03:52:18 <lament> {
03:52:54 <pikhq> Thus, something like "while {foo} {bar}" indicates running the proc while with arguments of two lists. . . It makes sense in an almost-Lispish way.
03:53:46 <bsmntbombdood> }
03:55:28 <CakeProphet> yeah.
03:56:00 <CakeProphet> if you wanted to go about data-tixing code... you could have a statement type... and just allow any list of statements to be used for blocks.
03:56:22 <CakeProphet> it would be cool for blocks-of-code-in-a-function.
03:57:54 <CakeProphet> Ruby does that I believe.
03:58:16 <CakeProphet> you can place blocks of code in a function call because Ruby compiles blocks into a code object.
04:22:24 -!- CakeProphet has quit (Read error: 113 (No route to host)).
04:27:58 -!- lament has changed nick to mental.
04:32:00 -!- mental has changed nick to lament.
04:35:23 -!- pikhq has quit ("leaving").
04:46:02 -!- Sgeo has quit ("Leaving").
04:49:10 -!- andreou has joined.
04:49:50 <andreou> testing, one two..
04:49:51 <andreou> ok
04:55:28 <lament> three
04:56:54 <andreou> hey lament, what's up?
05:04:21 <lament> not much!
05:06:01 <andreou> are you aware of any nice/graphical scheme's for pre-X Mac OS's?
05:06:19 <andreou> though i should try #scheme for that...
05:14:38 -!- oerjan has joined.
05:15:15 <lament> surely drscheme ought to work?
05:16:08 <andreou> v204
05:16:33 <andreou> which, arithmetically speaking, is 164 versions old
05:16:51 <lament> well
05:16:57 <lament> you _are_ using a pre-X mac os.
05:17:00 <andreou> 154 even
05:17:02 <andreou> yes
05:17:11 <andreou> i'd update if i wasn't scared as hell
05:17:31 <lament> and you _do_ want a graphical scheme which is a strange thing to want.
05:17:34 <lament> what are you scared of?
05:18:01 <andreou> well the disk can probably take it, but it's an old 266MHz G3 with 320MB RAM
05:18:21 <lament> oh.
05:18:24 <andreou> all that eye candy would probably make the whole system snail slow
05:18:33 <lament> install linux then :)
05:19:00 <andreou> tried netbsd, goes quite well
05:19:08 <andreou> but macos has something else
05:19:20 <andreou> je ne sais qui or whatnot
05:21:24 <andreou> ah maybe i'll do the switch in netbsd4, when audio driver problems will probably be resolved
05:31:02 -!- digital_me has quit ("Lost terminal").
05:47:26 * andreou sipping hot black tea with honey
05:47:34 <bsmntbombdood> eew tea with honey
05:48:06 <andreou> i don't know what kind of tea or honey you're used to, but this combo rocks :)
05:48:33 <bsmntbombdood> I like my tea straight ;)
05:48:55 <andreou> some teas are not supposed to be drunk straight
05:50:25 <oerjan> I recall reading the Aztecs drank unsugared hot chocolate with chili.  Now that's weird.
05:50:46 <andreou> they got extinct, see?
05:53:08 <andreou> though 'extinct' is not proper for a whole race
05:57:07 <oerjan> Strictly speaking they did not get extinct, they got converted and colonized.
05:58:41 <andreou> i think most of them were used as slave labour, died of exhaustion, malnutrition & relevant factors
06:01:18 <andreou> some of the rest later constituted large parts of the zapatistas
06:01:27 <andreou> now now-adays the EZLN
06:01:32 <andreou> s/-//
06:04:47 <lament> well, there's quite a lot of aztecs in mexico
06:05:05 <lament> they tend to be very poor
06:05:24 <andreou> they just reject the monetary fantasies of the westerners
06:05:40 <lament> no, they don't, they're simply poor
06:05:57 <andreou> well, i'm always the idealist
06:05:58 <lament> bedouins in israel (and elsewhere) reject the monetary fantasies
06:06:17 <lament> natives in mexico are simply extremely socially disadvantages and so really poor
06:06:23 <lament> *disadvantaged
06:06:59 <andreou> ah
06:29:13 -!- calamari has quit ("Leaving").
06:43:40 -!- ShadowHntr has joined.
06:47:14 -!- maverickbna has joined.
06:47:50 -!- ShadowHntr has quit (Nick collision from services.).
06:59:42 -!- ShadowHntr has joined.
07:09:39 -!- sentinel has joined.
07:10:15 -!- ShadowHntr has quit (Nick collision from services.).
07:10:19 -!- maverickbna has quit (Nick collision from services.).
07:10:21 -!- sentinel has changed nick to ShadowHntr.
07:12:21 -!- maverickbna has joined.
07:12:51 -!- ShadowHntr has quit (Nick collision from services.).
07:24:11 -!- oerjan has quit ("leaving").
07:31:58 -!- maverickbna has quit (Read error: 110 (Connection timed out)).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:38:25 -!- andreou has quit ("bsn").
09:13:38 -!- ais523 has joined.
09:14:10 <ais523> !fyb >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]++++++++++++++!
09:14:13 <EgoBot> Running...
09:17:05 <ais523> !ps
09:17:07 <EgoBot> 1 ais523: ps
09:18:51 <ais523> !fyb :[>%%%%%%%%%%%%%%%%%%%%%%%%>[-]!<]*;:>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]++++++++++++++!;{>>>}[-]++++++++++++++!
09:18:53 <EgoBot> Running...
09:19:42 <ais523> !ps
09:19:46 <EgoBot> 1 ais523: fyb
09:19:48 <EgoBot> 2 ais523: ps
09:20:23 <ais523> it seems to be running all its example programs against each other, rather than against mine
09:21:22 * ais523 tries a program designed only to lose
09:21:38 <ais523> !fyb @[+]+++++++++++++!
09:21:42 <EgoBot> Running...
09:21:55 <ais523> !ps
09:21:56 <EgoBot> 1 ais523: fyb
09:21:58 <EgoBot> 2 ais523: ps
09:22:10 <ais523> No, it's ignoring my program and just running its
09:23:19 <ais523> !help
09:23:32 <ais523> !ps
09:23:34 <EgoBot> 1 ais523: ps
09:23:55 <ais523> !fybs @[+]++++++++++++++!
09:23:58 <EgoBot> Reporting score for @[+]++++++++++++++!.
09:24:27 <ais523> !fybs >++!
09:24:30 <EgoBot> Reporting score for >++!.
09:24:41 <ais523> !help
09:24:44 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
09:24: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
09:24:52 <ais523> !help show
09:24:54 <EgoBot> Use: show <pid>  Function: display the current output buffer for a process
09:25:01 <ais523> !help flush
09:25:04 <EgoBot> Use: flush  Function: flush the output buffer, discarding any current output
09:25:09 <ais523> !help usertrig
09:25:12 <EgoBot> Use: usertrig <command> <trig-command>  Function: manage user triggers.  <command> may be add, del, list or show.
09:25:24 <ais523> !help i
09:25:28 <EgoBot> Use: i <pid> <input>  Function: send input to a process
09:25:38 <ais523> !help daemon
09:25:40 <EgoBot> Use: daemon <daemon> <daemon-command>  Function: start a daemon process.
09:26:30 <ais523> !unlambda ```sr.a``sr.b
09:26:44 <ais523> That's an infinite loop, by the way
09:26:47 <ais523> !ps
09:26:48 <EgoBot> 1 ais523: unlambda
09:26:50 <EgoBot> 2 ais523: ps
09:26:58 <ais523> !kill 1
09:26:58 <EgoBot> Process 1 killed.
09:27:25 <ais523> and only now do I get the output...
09:28:30 <ais523> !flush
09:28:41 <ais523> !ps
09:29:20 <ais523> it's still busy sending me an infinite number of 'b's
09:33:02 <ais523> !bf +[]
09:33:13 <ais523> !ps
09:33:46 <ais523> I can't even stop the infinite output loop with an infinite loop in another language...
09:35:16 -!- ais523 has changed nick to ais523_trying_to.
09:35:28 -!- ais523_trying_to has changed nick to ais523.
09:35:58 -!- ais523 has changed nick to ais523_.
09:36:19 <ais523_> Renaming myself to direct EgoBot's infinite output elsewhere
09:37:04 <ais523_> !ps
09:37:26 * ais523_ has probably broken EgoBot
09:38:59 <ais523_> !ps
09:39:13 <ais523_> It still seems to be in an infinite loop...
09:47:56 <ais523_> !ps
09:48:08 <ais523_> !help
09:48:27 <ais523_> (I'm just trying this every now and then to see if it's finished it's infiniely-long output)
09:51:07 <ais523_> !help
09:56:53 <ais523_> !help
10:00:01 <ais523_> !help
10:00:16 -!- ais523_ has changed nick to ais523.
10:00:26 -!- ais523 has changed nick to ais523_.
10:00:33 <ais523_> it's still going...
10:09:01 <ais523_> !help
10:37:00 <ais523_> !help
10:41:29 <ais523_> !help
10:45:25 <ais523_> !help
10:45:32 -!- ais523_ has changed nick to ais523.
10:45:44 -!- ais523 has changed nick to ais523_.
10:46:25 <ais523_> There should probably be some way to stop EgoBot in such situations (it was still sending messages when I checked just now)
10:50:27 <ais523_> !help
10:56:02 <ais523_> !help
11:03:04 <ais523_> !help
11:05:29 <pgimeno> hm, maybe renicing could help
11:07:14 <pgimeno> or blocking the process until it sends the output instead of buffering it
11:07:40 <pgimeno> (à la xon-xoff)
11:08:09 -!- ais523_ has quit.
11:08:18 <pgimeno> this may explain other situations where EgoBot ceased to respond
11:09:26 <pgimeno> GregorR: you there?
12:00:30 -!- ais523 has joined.
12:00:50 -!- ais523 has changed nick to ais523_.
12:11:58 <ais523_> !help
12:32:09 <SimonRC> bsmntbombdood: hey!  The apocalypse-in-2038 thing is *my* joke.
12:33:25 <ais523_> that statement's rather out of context to me at the moment
12:33:28 <SimonRC> bsmntbombdood: There is an amazing hack that abuses the switch-case interleaving (like in Duff's Device) to give you co-routines in C with not too much inconvinience.  It is available as a library.
12:33:47 <ais523_> you should try to do it with setjmp
12:33:57 <ais523_> both techniques have been used to implement Threaded INTERCAL
12:34:10 * SimonRC likes that ability of multiple-dispathc based on method retunr-type alone.
12:34:24 <SimonRC> Found in Haskell and maybe a few other places.
12:36:03 <SimonRC> ais523_: actually setjmp is unlikely to work, and certainly not guaranteed.
12:36:31 <ais523_> setjmp has certain guarantees. With practice and careful use of 'volatile', they can be exploited to lead to a portable program
12:38:22 <SimonRC> I though it just popped the stack, and could only jump up, not down.
12:38:25 <SimonRC> like exceptions
12:39:20 <ais523_> yes, you have to have all the coroutines in the same level of the same function
12:39:33 <ais523_> but the same restriction applies to switch and to goto
12:39:45 <SimonRC> hmm, maybe I see.
12:41:02 <ais523_> my Threaded INTERCAL code is at http://esoteric.voxelperfect.net/files/intercal (along with the rest of the INTERCAL implementation), in unravel.c
12:41:27 <ais523_> I used setjmp to minimize the change needed to the existing code
12:42:54 -!- ais523_ has quit ("lunchtime").
12:58:37 <SimonRC> No, the C one has macros which save the current position in the function and restore it, thus:
12:58:43 <SimonRC> http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
13:01:53 -!- ais523_ has joined.
13:02:05 -!- ais523_ has changed nick to ais523.
13:02:12 -!- ais523 has changed nick to ais523_.
13:02:19 <ais523_> EgoBot's still going...
13:06:16 -!- EgoBot has quit (SendQ exceeded).
13:08:45 -!- ais523_ has changed nick to ais523.
13:09:27 <ais523> So EgoBot's left, and hasn't come back in.
13:09:35 * ais523 is sorry for getting EgoBot thrown off the channel
13:42:13 <pgimeno> Simon Tatham
13:42:18 <pgimeno> I hate that guy
13:43:28 <pgimeno> he's made me lose lots of time with the puzzles collection
13:47:31 <pgimeno> incidentally, Inertia's creator = Malbolge's creator
13:53:43 <ais523> Inertia?
13:53:59 <pgimeno> one of the puzzles in S.Tatham's collction
13:54:03 <pgimeno> *collection
13:54:23 -!- andreou has joined.
13:55:03 -!- ais523 has quit ("busy in RL").
13:58:04 <andreou> disregarding the absence of the /physical/, the electronic is now a vital part of the R world and L.
14:02:19 <andreou> it'd be wise to include a 'sadly' after the 'is'.
14:05:49 <SimonRC> andreou: ?? :-S
14:06:11 -!- jix__ has joined.
14:06:21 <andreou> well, R is for real, L is for life
14:06:27 <SimonRC> pgimeno: also the guy that wrote PuTTY, it seems.
14:07:13 <SimonRC> Which a really odd, because PuTTY is one of the few real-world uses of the C coroutines hack we were discussing on this channel just an hour ago.
14:10:22 <pgimeno> well, coroutines have their uses
14:10:52 <pgimeno> one of the clearest uses is in implementing parsers
14:11:56 <pgimeno> another one is in certain types of cooperative multitasking
14:13:09 <pgimeno> the need often arises spontaneously
14:13:18 <pgimeno> er, well, not so often :)
14:13:27 <fizzie> This is not really too related, but for those uses SysV-like systems also have the funky {get,set}context functions, which are a bit like {set,long}jmp, but more.
14:19:53 <pgimeno> scary
14:20:36 <pgimeno> my man page claims get/setcontext is POSIX.1-2001
14:33:57 <fizzie> Oh? Well, I guess it could be.
14:38:03 <fizzie> It is. How very. (Although it's marked as a XSI extension.)
14:47:51 <SimonRC> Bah, you need contionuations.
14:48:05 <SimonRC> Continuations are easy in assembler.  Just a load of blitting.
14:49:18 <SimonRC> OTOH, laziness is sometimes a good alternative to coroutines.
15:26:52 <andreou> off to class, dogmatics 101
15:26:54 <andreou> (literally)
15:26:59 -!- andreou has quit ("the joys of theology").
15:59:11 -!- tgwizard has joined.
16:27:37 -!- sekhmet has quit (Read error: 110 (Connection timed out)).
17:04:05 -!- FabioNET has joined.
17:13:07 -!- ShadowHntr has joined.
17:14:39 -!- sekhmet has joined.
17:43:11 <SimonRC> hi people
17:53:10 <GregorR> I'm not a person :(
17:55:35 <SimonRC> why?
17:56:35 <GregorR> I am a computer programmed to chat on IRC.
17:58:19 <SimonRC> what about the pictures of you wearing hats?
17:58:49 <GregorR> Artificially generated.
17:58:57 <SimonRC> ah, ok
17:59:33 <pgimeno> hi GregorRBot
18:00:57 <pgimeno> seen what happened to your colleague EgoBot some hours ago?
18:09:33 -!- sebbu has joined.
18:10:25 <GregorR> pgimeno: He was taking 25% of my CPU, so I killed him.
18:11:01 <lament> That's what i do to my girlfriends when I start thinking about them too much.
18:14:28 <pgimeno> heh
18:15:51 <pgimeno> I was suggesting to renice the launched program
18:16:24 <lament> can't renice women :(
18:16:25 <pgimeno> at least trying to keep EgoBot responsive so that !kill works
18:16:34 <lament> once they're not nice, they're not nice forever
18:17:05 <pgimeno> well, jewelry works with some
18:19:44 -!- sebbu2 has joined.
18:33:49 <bsmntbombdood> Coruitines in C can be done with setcontext
18:33:55 <bsmntbombdood> SimonRC: 
18:39:08 -!- sebbu has quit (Connection timed out).
18:39:10 -!- sebbu2 has changed nick to sebbu.
18:44:24 <bsmntbombdood> it's not quite pretty though
18:50:50 -!- wooby has joined.
18:54:02 -!- sebbu2 has joined.
19:13:35 -!- sebbu has quit (Read error: 110 (Connection timed out)).
19:13:36 -!- sebbu2 has changed nick to sebbu.
19:57:12 -!- proog has joined.
19:58:41 -!- proog has quit (Client Quit).
21:02:19 -!- ShadowHntr has quit ("End of line.").
21:35:17 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:01:59 -!- sebbu has quit (Connection timed out).
22:24:42 -!- ihope has joined.
22:26:48 -!- CakeProphet has joined.
23:13:15 <CakeProphet> hahahahaha
23:13:48 <CakeProphet> classes than are friends have access to members in the private area of the class.
23:14:04 * CakeProphet rolls around.
23:14:38 <lament> that's... sick.
23:14:49 <bsmntbombdood> what?
23:15:15 <lament> now that i think of it i do have some very hot friends
23:15:26 -!- tgwizard has quit (Remote closed the connection).
23:15:42 <CakeProphet> Friends have access to the private parts.  :D :D :D 
23:16:53 <bsmntbombdood> oh
23:17:19 <lament> that's what being a friend is all about.
23:18:25 * CakeProphet is trying to think of uses for private members.
23:19:06 <bsmntbombdood> CakeProphet: I don't understand private stuff either
23:19:22 <lament> well you see, when a man loves a woman....
23:19:26 <CakeProphet> -maybe- protected.
23:19:45 <CakeProphet> or friends.
23:19:48 <CakeProphet> I mean..
23:20:01 <CakeProphet> if you just have everything public by default... there's no real terrible loss.
23:20:42 -!- Sgeo has joined.
23:20:45 <bsmntbombdood> right
23:21:03 <CakeProphet> C++ classes are kind of weird.
23:21:07 <bsmntbombdood> yep
23:21:10 <CakeProphet> like... virtual.
23:21:36 <CakeProphet> I'd find myself using virtual almost constantly.
23:21:42 <bsmntbombdood> virtual?
23:21:46 <CakeProphet> and structs instead of classes... 
23:21:51 <CakeProphet> because structs are public by default.
23:21:55 <bsmntbombdood> structs are a class 
23:22:01 <CakeProphet> I know.
23:22:24 <CakeProphet> virtual just means the member can be redefined in a subclass.
23:22:38 <CakeProphet> which.... I would imagine to simply be the default behavior.
23:22:39 <bsmntbombdood> they can't by defualt?
23:22:44 <CakeProphet> not that I know of.
23:22:59 -!- GregorR has quit (Read error: 110 (Connection timed out)).
23:29:06 <CakeProphet> I've recently started dabbling with self-replicating code..
23:29:17 <CakeProphet> and substitution stuff.
23:29:24 <CakeProphet> it's pretty cool.
23:29:52 <bsmntbombdood> zomg teh virus
23:30:28 <CakeProphet> Well I meant like...
23:30:30 <CakeProphet> hmmm...
23:30:35 <CakeProphet> a - > ba
23:30:39 <CakeProphet> b - > b
23:30:44 <CakeProphet> abab
23:31:01 <CakeProphet> the bottom string is applied to those replace rules for a number of iterations.
23:31:35 <CakeProphet> so abab  would become babbab... which would become bbabbbab   which would become bbbabbbbab
23:32:02 <CakeProphet> which could very well be the syntax of some other language... called baa
23:32:36 <bsmntbombdood> hmm
23:32:51 <oklopol> download a thue interpreter :\
23:32:54 <CakeProphet> The main use I see for something like that would be... fractals.
23:32:57 <CakeProphet> and yeah
23:32:59 <CakeProphet> thue
23:38:19 -!- wooby has quit (Read error: 104 (Connection reset by peer)).
23:38:37 <CakeProphet> I was thinking that you could probably unify the declarative phase and the input-string phase..
23:38:49 <CakeProphet> as well as add some more tidbits for context-based and probabilistic matches.
23:41:05 <CakeProphet> so you could like... redefine the replacement declarations via the replace declarations.
23:44:55 <ihope> Thue is obsolete. Use Thubi instead.
23:44:57 <ihope> :-P
23:45:30 <ihope> And then you can write a language better than both, but still based on the same principle, and call it Thusi.
23:45:57 <ihope> I imagine Thudi would be next, followed by Thui. From then, I have no idea.
23:47:21 -!- FabioNET has quit ("notte notte").
23:49:14 <CakeProphet> Since the dawn of man-kind.
23:49:24 <CakeProphet> escape characters have plagued the programmers existence.
23:49:30 <CakeProphet> with their necessity-ness.
23:49:48 <CakeProphet> how is it that we can represent multiple, otherwise non-printable entities???!?!?!?!?1
23:49:50 <CakeProphet> !!!!???!?!?!?!?
23:50:20 <ihope> !?!?!??!??!?!!!?!?!?!??!
23:51:45 <CakeProphet> Well...
23:51:59 <CakeProphet> if you use replacements to conditional execute replacements.
23:52:15 <CakeProphet> well..
23:52:17 <CakeProphet> no..

2007-01-17:

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-18:

00:00:40 <oklopol> <bsmntbombdood> <oklopol> hmm... do i do a generic number-> bsmntbombdood-code function or english?
00:00:43 <oklopol> what did you imply?
00:01:06 <bsmntbombdood> dude, you are a genious
00:01:12 <bsmntbombdood> That loop code works perfect
00:01:24 <oklopol> well, thank you
00:02:16 <bsmntbombdood> now I need to think about the math
00:02:35 <bsmntbombdood> and write a spec
00:03:43 <oklopol> god i love metaprogramming :O
00:03:49 <oklopol> how come i never did it before?
00:03:50 <oklopol> >>> def printnumsfromntozero(n):
00:03:50 <oklopol> return makenumber(n)+"[.1-].]"
00:03:50 <oklopol> >>> printnumsfromntozero(7)
00:03:50 <oklopol> '11g11g11g11g11g11g1------------[.1-].]'
00:03:50 <oklopol> >>> runsome("11g11g11g11g11g11g1------------[.1-].]")
00:03:52 <oklopol> 7.0 6.0 5.0 4.0 3.0 2.0 1.0 0.0
00:04:11 <oklopol> hmm
00:04:28 <oklopol> should open c++... i'll start liking that lang soon :<
00:04:54 <bsmntbombdood> hmmm
00:05:15 <oklopol> yeah, the ordo is not optimal
00:05:27 <oklopol> i mean O(n) to create a number
00:06:12 <bsmntbombdood> In the loop, you have to pop the stack
00:06:25 <oklopol> is that so?
00:06:47 <oklopol> my bot does that, believe, it's not that nice
00:06:51 <oklopol> *believe me
00:06:59 <oklopol> i'll get some coffee 8|
00:11:50 <oklopol> okay
00:11:53 <oklopol> added sqrt
00:11:55 <oklopol> as 'q'
00:12:04 <oklopol> now try 11g1--qg.
00:12:13 <oklopol> and wait 10 min for the generic one
00:15:06 <oklopol> hmm
00:15:27 <oklopol> does python have err... err.... err..... binary logical operators?
00:17:35 <oklopol> hmm i assumed being able to create 0.5 automatically makes it easy to create 0.25 etc :)
00:17:54 <oklopol> oh
00:17:56 <oklopol> it does...
00:19:12 <bsmntbombdood> argh
00:19:20 <bsmntbombdood> I can't figure out how to multiply
00:19:33 <lament> binary lowho?
00:19:35 <oklopol> loop
00:19:49 <bsmntbombdood> oklopol: no, with logs there's a better way
00:19:57 <oklopol> okay
00:20:01 <oklopol> what is it?
00:20:27 <oklopol> 11g1--qqqqg = 0.0625
00:20:34 <bsmntbombdood> ">g<g ADD" puts the log of the product on top of the stack
00:20:50 <oklopol> true
00:20:55 <bsmntbombdood> #define ADD > ZERO <--
00:20:59 <oklopol> then inverse would be nice
00:21:11 <bsmntbombdood> right, but I don't want to have to add another operation
00:21:26 <oklopol> trues
00:21:31 <oklopol> but, q is bad too?
00:21:44 <bsmntbombdood> yeah, I don't want any extra ops
00:21:44 <oklopol> makes fractions nice to do
00:21:48 <oklopol> okay
00:21:53 <oklopol> then it's loop
00:22:02 <bsmntbombdood> no
00:22:09 <bsmntbombdood> there has to be some way to do it with logs
00:22:20 <oklopol> yes
00:22:23 <oklopol> changing base
00:22:28 <oklopol> :\
00:22:33 <bsmntbombdood> ?
00:22:34 <oklopol> i can't think of anything else
00:22:44 <bsmntbombdood> What do you mean changing base?
00:22:47 <oklopol> hmm, i might be wrong
00:23:00 <oklopol> i'll test before i say anything more stupid
00:23:44 <bsmntbombdood> maybe inv. log (exponent) is needed
00:24:59 <oklopol> yeah
00:25:05 <oklopol> i was wrong
00:25:14 <oklopol> haven't fiddled with logarithms in ages
00:25:14 <bsmntbombdood> that makes me sad :(
00:25:22 <oklopol> :(
00:25:27 -!- ihope has quit (Read error: 104 (Connection reset by peer)).
00:29:42 <oklopol> i thought there was a correlation between either logarithms with inverted base, but there seems not to be
00:29:53 <oklopol> (i'm not good at math, i just guess :))
00:30:17 <oklopol> yeah, the coffee >>
00:30:56 -!- sebbu has quit ("@+").
00:31:13 <bsmntbombdood> ok, for now i've added an operation "p", which inverts "g"
00:31:49 <bsmntbombdood> so now to multiply you can do ">g<g ADD p"
00:32:47 <oklopol> yeah ok
00:33:54 <oklopol> but, if you need decimal numbers, i'd say square root being a sister operation of a 2-base logarithm would make a nice addition to the lang... unless there is a nice way to do numbers with logs
00:34:07 <oklopol> decimal numbers -> floating point values
00:34:19 <oklopol> -> rational non-integer numbers
00:34:29 <oklopol> -> the right term fuck it
00:35:03 <ryanakca> oklopol: back, sorry, kk, thanks
00:35:35 <oklopol> you need logs when calculating loans etc
00:35:35 <lament> what's a decimal number?
00:35:55 <oklopol> lament, i used the wrong term
00:36:13 <oklopol> a->v mean s/a/v
00:36:19 <oklopol> ...
00:36:22 <oklopol> s/v/b
00:36:39 <oklopol> ...someone kill me
00:36:59 * ryanakca gives oklopol a poison cookie :)
00:37:13 <oklopol> :)
00:40:07 <bsmntbombdood> argh, how to do this
00:40:08 <lament> so many people get the terminology wrong :(
00:40:10 <lament> they make me sad :(
00:41:31 <bsmntbombdood> aARARARaRARARAR
00:45:08 <oklopol> what, bsmntbombdood?
00:45:18 <oklopol> lament, i'm an idiot
00:45:27 <bsmntbombdood> inverting a logarithm
00:45:31 <oklopol> 2**...
00:45:39 <bsmntbombdood> I don't want to have an extra command
00:45:44 <oklopol> ah okay
00:45:51 <oklopol> you said something peeish
00:46:02 <bsmntbombdood> yeah
00:47:30 <bsmntbombdood> my source: http://bsmntbombdood.mooo.com/logfuck.py.txt
00:49:45 <oklopol> read
00:49:53 <oklopol> nice
00:50:03 <oklopol> all my iffy parts fixed
00:50:05 <oklopol> nice work
00:50:19 <oklopol> but, i had to make it in 10 minutes to be first :)
00:50:27 <bsmntbombdood> heh
00:50:50 * oklopol likes q :'(
00:50:51 <oklopol> :DD
00:51:25 <bsmntbombdood> You can compute square roots withs logs
00:52:30 <oklopol> ah okay
00:52:34 <oklopol> shomme!
00:54:42 <bsmntbombdood> one sec
00:54:45 <oklopol> k
00:54:50 <oklopol> darn
00:54:57 <oklopol> i'm gonna hate myself when i see it :)
01:01:53 <bsmntbombdood> hrm
01:02:32 <oklopol> does it work?
01:02:34 <bsmntbombdood> well, sqrt(x) == 2**(.5 * log(x))
01:02:43 <oklopol> :)
01:02:58 <oklopol> since sqrt is the only way to get 0.5, that's hard
01:03:03 <bsmntbombdood> no
01:03:03 <oklopol> you can get close tho
01:03:06 <oklopol> oh
01:03:15 <bsmntbombdood> #define DIV >g<g - p
01:03:23 <bsmntbombdood> #define ZERO 1g
01:03:23 <bsmntbombdood> #define TWO 1 ZERO 1--
01:03:25 <oklopol> well, with p, true :)
01:03:44 <bsmntbombdood> 1 TWO DIV
01:03:47 <bsmntbombdood> is .5
01:03:49 <oklopol> but, you see, then you don't need sqrt
01:03:54 <oklopol> ye
01:04:07 <bsmntbombdood> right
01:04:08 <CakeProphet>  so...
01:04:13 <oklopol> so, it's p or q
01:04:15 <CakeProphet> floating points numbers are a tad... limited.
01:04:23 <oklopol> CakeProphet, you are limited
01:04:29 <oklopol> :D
01:04:29 <CakeProphet> LOL NO
01:04:31 <bsmntbombdood> oklopol: p can do more than q
01:04:37 <bsmntbombdood> CakeProphet: What's your point?
01:04:38 <oklopol> yes
01:04:43 <oklopol> much more
01:05:02 <bsmntbombdood> a ha!
01:05:08 <bsmntbombdood> got it
01:05:11 <oklopol> so, you are a stupid head
01:05:11 <bsmntbombdood> #define SQRT >1 TWO DIV<g MULT p
01:05:14 <oklopol> :O
01:05:27 <oklopol> yeah, okay
01:05:32 <oklopol> i can make a num conversion
01:05:52 <oklopol> and it'll make it to the spec and i'll be a hero -_____-
01:06:14 <CakeProphet> well...
01:06:16 <bsmntbombdood> What do you mean num conversion?
01:06:19 <CakeProphet> hrm..
01:06:29 <oklopol> conversion of a number into lf-code
01:06:44 <bsmntbombdood> oh
01:06:58 <oklopol> but, it wouldn't be very optimal
01:07:01 <oklopol> easy tho
01:07:10 <bsmntbombdood> I'm going to change output from decimal to ascii now I think
01:07:25 <oklopol> yeah, for non-integers
01:07:28 <oklopol> *integers
01:07:45 <CakeProphet> >>> float("0." + "".join(["565656534" for x in xrange(100000)]))
01:07:46 <CakeProphet> 0.56565653456565657
01:07:48 <CakeProphet> >>>
01:07:49 <CakeProphet> :(
01:07:57 <CakeProphet> I want giant floating point numbers!!!!
01:08:54 <bsmntbombdood> CakeProphet: gmp
01:09:01 <oklopol> i want 10-base to be illegalized
01:09:20 <CakeProphet> I want to use a base-5 numeral system!
01:09:24 <CakeProphet> THE LAW OF FIVES.
01:09:35 <bsmntbombdood> How do you implement dup in lf?
01:09:40 <bsmntbombdood> I can't figure it out
01:09:45 <oklopol> hmm...
01:10:02 <CakeProphet> you could consequitely move items from one stack to the next.
01:10:06 <CakeProphet> till you... get to the one you want?
01:10:12 <oklopol> dup
01:10:16 <oklopol> not lift
01:10:30 <CakeProphet> well...
01:10:32 <CakeProphet> it's close. :D
01:12:00 <oklopol> hmm
01:12:07 <bsmntbombdood> It's not turing complete unless I can implement dup I think
01:12:20 <bsmntbombdood> since [] is destructive
01:12:55 <oklopol> hmm, there is no way to use a number in a calculation without even then only having it in one place again... i think
01:13:08 <oklopol> you can only add a 1
01:13:21 <CakeProphet> Implement two stacks-of-queues.
01:13:24 <CakeProphet> like Stue. :D
01:13:29 <CakeProphet> except... two
01:13:31 <CakeProphet> TwoStueFuckLogs
01:13:36 <CakeProphet> you could call it.
01:13:41 <bsmntbombdood> no
01:13:42 <oklopol> and using that one IN ANY WAY with the number to duplicate will destroy the original number
01:13:43 <bsmntbombdood> too complicated
01:13:50 <oklopol> and you have the same prob with the new one
01:13:53 <bsmntbombdood> oklopol: yep :/
01:14:10 <oklopol> i think i can prove it's impossible... but that's all i can do :\
01:14:23 <bsmntbombdood> I could make > copy isntead of moving
01:14:26 <oklopol> ...if it's impossible, that's pretty obvious tho :)
01:14:30 <oklopol> yeah
01:14:43 <bsmntbombdood> but that causes other problems
01:14:58 <CakeProphet> such as.. not being able to remove items.
01:15:02 <CakeProphet> because it just copies.
01:15:11 <oklopol> you can.
01:15:15 <oklopol> oh
01:15:20 <CakeProphet> you could just have a copy command.
01:15:25 <bsmntbombdood> CakeProphet: no
01:15:28 <CakeProphet> that copies from stack to other stack
01:15:32 <bsmntbombdood> too many instructions
01:16:00 <oklopol> [ could copy the topmost, ] could pop :P
01:16:39 <oklopol> nah, wouldn't work... i think
01:16:42 <bsmntbombdood> hmmm
01:16:49 <oklopol> because you still couldn't dup for example
01:17:06 <bsmntbombdood> the dup would be ">0<[>]<"
01:17:11 <bsmntbombdood> s/the/then/
01:17:18 <bsmntbombdood> s/0/1g/
01:17:57 <oklopol> you're right
01:18:00 <bsmntbombdood> I think that works!
01:18:15 <oklopol> i didn't understand > and < right, yeah, it was good
01:18:26 <oklopol> s/understand/...grasp :)
01:20:51 <bsmntbombdood> crap, that doesn't work
01:21:09 <oklopol> :\
01:22:11 <oklopol> mine says list index outta range
01:22:18 <oklopol> but i didn't allow that anyway
01:22:24 <oklopol> so it should
01:23:18 <oklopol> [>0]<
01:23:24 <oklopol> that would dup right?
01:23:32 <oklopol> eh
01:23:41 <oklopol> yeah
01:23:43 <oklopol> i thnk
01:23:47 <bsmntbombdood> no
01:23:58 <bsmntbombdood> wait
01:24:43 <bsmntbombdood> no
01:24:56 <bsmntbombdood> that does nothing
01:26:08 <oklopol> n,  -> (start of loop) n n,  -> n, n -> (end of loop) n 0, n -> n, n -> n n, 
01:26:09 <CakeProphet> hmm..
01:26:24 <CakeProphet> I wonder how you would use a tree as a languages data structure.
01:26:29 <oklopol> yes
01:26:33 <oklopol> my friend did that
01:26:49 <oklopol> it is nice
01:27:10 <oklopol> you can have tree data structures as vars then
01:27:14 <oklopol> very convenient
01:27:53 <CakeProphet> You could probably do something with genetics.
01:27:54 <CakeProphet> and trees.
01:27:59 <CakeProphet> and fractals.
01:28:01 <CakeProphet> and chaos
01:28:04 <CakeProphet> and evolution.
01:28:09 <oklopol> > goes left, < goes right, ^ goes up, so navigating is like bf but you can reserve infinite certain memory for vars
01:28:25 <CakeProphet> hmm...
01:28:27 <CakeProphet> that's cool.
01:28:36 <CakeProphet> you could take a lisp-ish approach and make the program a tree.
01:28:40 <oklopol> true
01:28:44 <oklopol> but he's not good
01:28:49 <CakeProphet> with the branches acting as... erm..
01:28:51 <oklopol> you could
01:29:01 <CakeProphet> conditional pathways?
01:29:07 <bsmntbombdood> aaagh
01:29:18 <oklopol> you could just code it as a tree, no ascii shit
01:29:31 <oklopol> i don't understand why everything must be coded in ascii...
01:29:36 <oklopol> or unicode
01:29:55 <oklopol> except for cellular automatons
01:29:56 <bsmntbombdood> ok
01:29:57 <oklopol> of course
01:30:04 <oklopol> bsmntbombdood, what?
01:30:05 <bsmntbombdood> We make > copy instead of move
01:30:09 <bsmntbombdood> < acts as normal
01:30:12 <oklopol> okay
01:30:17 <CakeProphet> could do something like wireworld... but different.
01:30:18 <oklopol> ah
01:30:21 <oklopol> yeah
01:30:25 <CakeProphet> electrical circuitry type programming.
01:30:32 <CakeProphet> make it a GUI
01:30:34 <CakeProphet> it could be fun.  :D
01:30:36 <oklopol> how do you drp? bsmntbombdood
01:30:41 <bsmntbombdood> oklopol: []
01:30:46 <oklopol> yeah
01:30:58 <oklopol> what was wrong with my n,  -> (start of loop) n n,  -> n, n -> (end of loop) n 0, n -> n, n -> n n,  tho?
01:31:05 <oklopol> what fails?
01:31:11 <CakeProphet> We should all COLLABORATE
01:31:11 <bsmntbombdood> the move
01:31:13 <CakeProphet> and make something sweet
01:31:22 <CakeProphet> but according to my vision..
01:31:24 <oklopol> why does it fail?
01:31:27 <CakeProphet> because I said so.
01:31:31 <oklopol> CakeProphet, sure :)
01:31:39 <bsmntbombdood> now [ pops
01:31:46 <CakeProphet> FRACTALIC SELF-REPRODUCING EVOLUTIONARY GENETICS CODE
01:31:49 <CakeProphet> now
01:31:51 <CakeProphet> how
01:31:53 <CakeProphet> think
01:31:58 <oklopol> but but, what was wrong with the move? :'(
01:32:14 <bsmntbombdood> It was destructive
01:32:31 <oklopol> okay
01:32:35 <oklopol> how would it go then?
01:32:41 <oklopol> if not like that
01:32:53 <oklopol> i did it destructively in n,  -> (start of loop) n n,  -> n, n -> (end of loop) n 0, n -> n, n -> n n,  i think
01:33:06 <bsmntbombdood> write that in the language
01:33:06 <CakeProphet> I'd like to make an esolang larger than a few commands and a tiny interpreter.
01:33:17 <oklopol> i did, but it fails
01:33:22 <CakeProphet> like... a major project...
01:33:39 <bsmntbombdood> oklopol: exactly
01:33:43 <oklopol> but, why?
01:33:56 <oklopol> how do the stacks evolve then?
01:34:07 <bsmntbombdood> crap, borked
01:34:19 <oklopol> because making > copy is not nice if it's not needed
01:34:27 <oklopol> because it's not very intuitive
01:34:40 * CakeProphet is thinking.
01:34:47 <bsmntbombdood> Yeah
01:34:48 <oklopol> and i think an esoteric language should always be intuitive... according to it's own rules
01:35:03 <bsmntbombdood> now we can't drop
01:35:13 <oklopol> ah
01:35:15 <CakeProphet> a genetic language isn't coming into my head intuitively.
01:35:15 <oklopol> yeah
01:35:35 <CakeProphet> but it seems like it would be simple.
01:36:00 <CakeProphet> you have some stuff... and some other stuff... and some stuff that tests that stuff...
01:36:08 <CakeProphet> and something to put it all in... an environment.
01:36:13 <oklopol> that really sums it up :)
01:36:19 <CakeProphet> and stuff starts dying..
01:36:26 <CakeProphet> and stuff starts procreating.
01:36:28 <CakeProphet> yay... genetics.
01:36:37 <CakeProphet> which inevitably creates evolution.
01:37:04 <CakeProphet> AHA
01:37:04 <oklopol> i thought of making a language with the most basic component being flock movement... but if that's not done yet, i pity mankind
01:37:06 <CakeProphet> simplified DNA
01:37:18 <CakeProphet> a series of.... codes\
01:37:22 <CakeProphet> that determine shit
01:37:33 <CakeProphet> and make a bunch of them...
01:37:42 <CakeProphet> or better yet... just make one starting code... the source code.
01:37:55 <CakeProphet> which spawns off offspring..
01:38:05 <CakeProphet> two source codes?
01:38:07 <CakeProphet> yes.
01:38:09 <CakeProphet> two source codes.
01:38:11 <CakeProphet> that mate.
01:38:26 <oklopol> yeah
01:38:31 <CakeProphet> swap genes... reproduce... you have a bunch of source codes now.
01:38:39 <oklopol> first of all you need a lot of redundancy
01:38:48 <CakeProphet> and some start dying... the ones that you don't want.
01:38:52 <CakeProphet> nah... just two genetic strands.
01:39:16 <CakeProphet> but I don't want DNA.... the thought of coding in DNA-like language kinda makes me want to puke.
01:39:40 <oklopol> the codes you have first should be quines that are altered then executed until more new executable code is randomly created
01:40:00 <CakeProphet> maybe borrow some ideas from Thue-like-ness?
01:40:05 <oklopol> but, the language should aim at creating itself
01:40:05 <CakeProphet> but.. not direct string replacement.
01:40:09 <CakeProphet> yah.
01:40:26 <CakeProphet> I've been tossing through ideas like that.
01:40:37 <CakeProphet> a language that contains the instructions for creating itself
01:40:38 <oklopol> it need not have any other operation than cloning itself, changing thing to their "synonyms" etc
01:40:59 <CakeProphet> well... there needs to be some form of sexual interchange... otherwise you just have a bunch of clones.
01:41:19 <oklopol> well, yeah
01:41:26 <oklopol> we can leave out randomness then
01:41:29 <oklopol> which is good
01:41:36 <CakeProphet> could have it as an option.
01:41:40 <CakeProphet> non-determinism is cool sometimes.
01:42:16 <oklopol> because with one we'd need a seed, with two (that reproduce collaboratively) they are each others seeds, more sensible
01:42:21 <oklopol> yeah
01:42:29 <oklopol> but the seed could then be a random program
01:42:46 <oklopol> since all programs should of course be always-executing
01:43:01 <oklopol> but, redundant operations just wouldn't produce themselves
01:43:19 <CakeProphet> hmmm... the program instructions could correspond with each other... 
01:43:23 <CakeProphet> like... 
01:43:25 <oklopol> so there would always be a random amount of nops that always die
01:43:29 <oklopol> yes
01:43:35 <CakeProphet> do different things for two different pairings?
01:43:40 <CakeProphet> or... however we pair them up.
01:44:01 <oklopol> yes, these pair could be made so that best result i gotten
01:44:04 <oklopol> *pairs
01:44:07 <oklopol> *is
01:44:19 <oklopol> my s's are becoming extinct
01:44:25 <CakeProphet> haha... a self-optimixing language.
01:44:29 <oklopol> :)
01:44:36 <CakeProphet> fuck compilers.
01:44:39 <oklopol> did you coin that term just now?
01:44:42 <CakeProphet> just make the language do it itself.
01:44:57 <CakeProphet> ...well.. it was a typo.
01:44:59 <CakeProphet> but sure.
01:45:01 <CakeProphet> I coined it.
01:45:15 <oklopol> okay
01:45:22 <oklopol> i thought it was brilliant :)
01:45:37 <oklopol> since it mixes two progs while optimizing automatically
01:46:02 <oklopol> now, english again
01:46:06 <CakeProphet> by program.. do you mean hard file or... separate 'halves"
01:46:12 <CakeProphet> it could be either I guess.
01:46:19 <oklopol> i need more complicated english here than in my homework :\
01:46:21 <CakeProphet> you could have two different files get it on as well.
01:46:34 <CakeProphet> file-sex.
01:46:52 <oklopol> you could do like dna
01:47:10 <oklopol> each instruction is two bytes, like +/ () %% etc
01:47:24 <oklopol> and you know how it works
01:47:38 <CakeProphet> eh... my biology is fuzzy.
01:47:40 <oklopol> okay
01:47:42 <CakeProphet> but I get the picture.
01:47:45 <CakeProphet> they sort of... interchange right?
01:47:52 <oklopol> random one of the pair is picked
01:48:12 <CakeProphet> hmmm... I don't think randomality could produce optimizations... but... who knows.
01:48:39 <oklopol> mixing program "¤¤ ## 1%" with "aG oo /\" could be "¤G #o %\" for example
01:48:44 <CakeProphet> oooh..
01:48:48 <CakeProphet> the optimization wouldn't be there.
01:48:50 <oklopol> you could optimize it afterwards
01:48:54 <CakeProphet> it would be in the... massive amounts of this occuring.
01:48:59 <CakeProphet> and... which ones "live"
01:49:04 <CakeProphet> by being more efficient.
01:49:06 <CakeProphet> alright.. cool.
01:49:26 <oklopol> well, optimizing isn't really fair play in a sence... nature doesn't have it :P
01:49:39 <CakeProphet> it would be neat if you could strategically plan the flow of an evolution chain... to produce some desired result... but that sounds kind of far-fetched and vague.
01:50:07 <oklopol> we'd just have an algorithm to check for sanity in the program to skip evolution when a species is due to die pretty soon
01:50:10 <CakeProphet> what about environment... no environment? Should the programs start killing each other?  What about a "species change"
01:50:21 <CakeProphet> :D
01:50:34 <CakeProphet> all is not always peachy in the wild.
01:50:38 <oklopol> you can always have a 2D map to emulate them living there...
01:50:42 <CakeProphet> haha
01:50:46 <oklopol> s/to/and
01:50:50 <CakeProphet> ah...
01:51:00 <CakeProphet> that could be another part of the program?  or... too much?
01:51:12 <oklopol> hmm
01:51:14 <CakeProphet> like... the spaces could be different.
01:51:24 <oklopol> huh?
01:51:27 <CakeProphet> like a 2D language.
01:51:31 <oklopol> separate things
01:51:36 <CakeProphet> but with... programs running around in it.  :D
01:51:53 <oklopol> you'd make programs (prolly at random), then put 10000 of them on the screen and see what happens
01:52:12 <oklopol> the dna would be executed differently when doing different thigs
01:52:14 <oklopol> *things
01:52:29 <oklopol> like, walking could be specified in a certain part of the code
01:52:37 <oklopol> all codes equal length for simplicity
01:52:43 <bsmntbombdood> http://bsmntbombdood.mooo.com/logfuck_spec.txt
01:52:48 <oklopol> you're fast
01:53:01 <CakeProphet> yah... I like complexity springing out of simplicity...
01:53:10 <CakeProphet> ah... how about functional?
01:53:12 <oklopol> yeah, ok, it's quite a simple lang :)
01:53:18 <oklopol> for bsmntbombdood
01:53:47 <CakeProphet> an organism is a set of functions... each being the original code we were talking about... pairs of opcodes.
01:53:51 <oklopol> functional is not that good since it needs what's it called...
01:53:55 <oklopol> ah yeah
01:53:59 <oklopol> but then no string
01:54:03 <oklopol> we can forget about it
01:54:06 <CakeProphet> I got the idea from when you mentioned walking.
01:54:08 <oklopol> a structure then
01:54:09 <CakeProphet> walking is a function. :D
01:54:42 <oklopol> a creature would map the command to walk in any function it wants
01:54:49 <oklopol> once again depending on it's code
01:54:57 <CakeProphet> hmm...
01:55:01 <oklopol> and, it would create functions at random
01:55:01 <CakeProphet> I kinda follow
01:55:26 <CakeProphet> and then there should be functions for EATING PEOPLE
01:55:50 <CakeProphet> I kinda liked having deterministic functions though... random could help spur on genetics.. somehow.
01:56:10 <oklopol> yes, once again it would be feeded all the necessary information, and requested what it'll do, it would map these commands into whatever functions it wants to
01:56:12 <oklopol> or smth
01:56:26 <oklopol> yeah
01:56:36 <oklopol> functions should be deterministic
01:56:45 <oklopol> but new ones could be created
01:56:49 <CakeProphet> Start off with just two creatures... and an environment source... either being in different files or in the same source... either way.
01:56:52 <CakeProphet> righto
01:57:02 <CakeProphet> ah.. I get what you mean.
01:57:38 <CakeProphet> The environment would provide much of the constaints... while perhaps evolving and changing itself. :)
01:57:48 <CakeProphet> as creatures effect it.
01:58:00 <oklopol> i loved making 2D life simulator when i was little (with set vars, not code)
01:58:09 <oklopol> little... i'm still little
01:58:11 <oklopol> smaller
01:58:49 <CakeProphet> the rest of the conditioning would come from interactions with creatures... collisions in the environment basically.
01:58:53 <oklopol> haha, plants that are creatures that lost the ability to move at some point :D
01:58:57 <oklopol> so cool
01:59:10 <CakeProphet> hmm...
01:59:12 <CakeProphet> yeah
01:59:22 <CakeProphet> hmmm.... energy?
01:59:30 <oklopol> like, hp? :P
01:59:39 <CakeProphet> might as well... while we're at it... planning a big-ass game of life.
01:59:45 <CakeProphet> well.. like... energy.
01:59:45 <oklopol> hehe :=)
01:59:53 <oklopol> i'd like their code to be eaten :)
02:00:09 <oklopol> no variables, just wrecking of each others functions when hit
02:00:34 <CakeProphet> stationary creatures would eventually get better at either eating other creatures or gaining energy from the environment (like a form of photosynthesis... although maybe not from any "light" source)
02:01:10 <oklopol> trues... the code could be in such a format that removing it would probably not change anything
02:01:39 <CakeProphet> should there be set functions for actions?
02:01:50 <CakeProphet> or... should it somehow determine which function to use?
02:02:11 <oklopol> i think it should do it's own mapping, but it's kinda too random then
02:02:14 <CakeProphet> well... there should be a "sex" function...
02:02:21 <CakeProphet> that... determines sex
02:02:26 <CakeProphet> male, female, asexual... something else.
02:02:30 <oklopol> :)
02:02:48 <oklopol> or, when encountering, a function to determine what they do to each other
02:02:53 <CakeProphet> yeah
02:03:10 <CakeProphet> but... I like gender too. :D
02:03:17 <oklopol> true
02:03:30 <oklopol> when actually implementing
02:03:37 <CakeProphet> when they collide... behavioristic traits determine what actions are taken... which are functions themselves.
02:03:39 <oklopol> a simpler one should be done first
02:03:44 <oklopol> with set functions prolly
02:03:47 <oklopol> and such
02:03:47 <CakeProphet> aha... "behaviors" are functions that determine what function is to be used!
02:03:56 <oklopol> yes
02:04:03 <CakeProphet> higher-order functions.
02:04:10 <oklopol> taking the other creatures functions to determine it
02:04:18 <CakeProphet> yeah.
02:04:27 <CakeProphet> so the functions would need to have some sort of manipulatable data.
02:04:37 <oklopol> they look at each others code, if it seems the other would attack, there's no use emitting seed on it
02:04:38 <oklopol> :)
02:04:40 <oklopol> okay
02:04:44 <CakeProphet> haha
02:04:45 <oklopol> far-fetched
02:04:56 <CakeProphet> it sounds do-able though.
02:04:57 <oklopol> we'll create the ultimate AI another time...
02:05:06 <CakeProphet> at least... basics.
02:05:09 <CakeProphet> basics first...
02:05:18 <CakeProphet> there will need to be a lot of modality in the source I think..
02:05:25 <CakeProphet> no simple universal commmand set like BF
02:05:26 <oklopol> the language should have a lot of functions for determining stuff about itself too :)
02:05:46 <CakeProphet> or at least... the symbols carry different semantics depending on where they're at.
02:05:54 <CakeProphet> a definetely like the idea of "behaviors" and "actions"
02:05:58 <oklopol> but, would this be a game for two ppl to play making their own populations and seeing which one wins or just experiment?
02:06:00 <CakeProphet> and maybe "traits"... for simple axiomatic shit.
02:06:17 <CakeProphet> I was kinda thinking you could use it to... compute shit...
02:06:27 <CakeProphet> far-fetch yeah... it sounds more like a fun game.
02:06:29 <oklopol> hehe :)
02:06:32 <CakeProphet> like corewars... but less competitive.
02:06:43 <CakeProphet> or.. more strategic.
02:07:17 <oklopol> i've not yet seen the real strategy in corewars, but i must've gotten something wrong, never played
02:07:55 <CakeProphet> so... traits (test functions), actions (executive functions that employ traits), and behaviors (functions that use traits, combined with the input of another creatures behavior function to trigger a specific action)
02:08:45 <oklopol> yeah, if those are made by the creator of the creature, would be cool
02:08:50 <CakeProphet> oh oh oh
02:09:00 <CakeProphet> environment... could be a set of symbols on a 2D space.
02:09:06 <CakeProphet> with each one mapping to a function..
02:09:10 <CakeProphet> or functions
02:09:44 <CakeProphet> or.. just like... basic commands and stuff
02:09:46 <CakeProphet> either works.
02:09:51 <CakeProphet> both maybe... 
02:10:07 <oklopol> <<>.> okay, this is a nop since i should be doing my tasks :)
02:10:20 <CakeProphet> ...?
02:10:26 <oklopol> nopol <3
02:10:41 <oklopol> this discussion, i don't have time for it now :D or for anything
02:10:47 <oklopol> i have school in 4 hours
02:10:50 <oklopol> it 4 am
02:10:54 <oklopol> *it's
02:10:54 <CakeProphet> pfft... there's always time.
02:10:58 <CakeProphet> I've gone tons of shit I could be doing.
02:11:05 <oklopol> but... there are a lot of tasks :\
02:11:37 <oklopol> and if i don't get them before tomorrow, i'll not be able to do the matriculation exam of english this spring
02:11:50 <oklopol> (might be finland spesific)
02:12:06 <oklopol> because i forgot to do them when i should've
02:12:14 <CakeProphet> I have a tendency to... leave projects unfinished... and start a lot of stuff.
02:12:22 <oklopol> me too
02:12:23 <CakeProphet> and.. not finish crap because I get distracted by ideas.
02:12:34 <oklopol> i'll finish them usually when i can do it in 4 hours :)
02:12:40 <CakeProphet> yeah.
02:12:45 <CakeProphet> if you have to stop and continue later.
02:12:46 <CakeProphet> it kills it.
02:13:02 <oklopol> one time i took my 3 year old unfinished projects and finished them all during the afternoon
02:13:17 <oklopol> (but they were mostly hello worlds :))
02:13:55 <oklopol> yeah, i'm bad at continuing programming since i've already completed it in my head :\
02:14:06 <CakeProphet> I usually start bots, languages, weird quick mini-languages for parsiing, strange and useless "helper functions", etc
02:14:19 <oklopol> and of course sometimes i don't remember my idea that well
02:14:24 <oklopol> if i haven't thought about it
02:14:26 <CakeProphet> hmm... I like the idea of the environment code being basic... but some optional complexity.
02:14:45 <CakeProphet> you have some basic stuff... river, grass, mountain, weird-wall-thing..
02:14:52 <oklopol> okay, i have to go now, really :)
02:14:52 <oklopol> cu
02:14:54 <CakeProphet> and then you have "structures"... which are functions.
02:14:56 <CakeProphet> hahaha
02:14:58 <CakeProphet> alright
02:26:44 -!- anonfunc has joined.
02:27:23 -!- anonfunc has quit (Client Quit).
02:27:26 -!- anonfunc has joined.
02:41:35 -!- ryanakca has quit (Read error: 104 (Connection reset by peer)).
02:41:42 <oklopol> hmm
02:41:45 <oklopol> that was easy
02:41:52 <oklopol> i had one left :)
02:42:11 <oklopol> i'm good at assessing that, it seems
02:42:22 <oklopol> the number of items in a list
02:51:02 <CakeProphet> >.>>
02:51:11 * CakeProphet is still working out that idea...
02:51:16 <CakeProphet> it sounds feasible... surprisingly.
02:51:39 <CakeProphet> but with like... 4 languages...
02:51:42 <CakeProphet> at the least
02:51:44 <oklopol> i still have a word test tomorrow, gonna read for that after a little family guy + coffee break :)
02:51:50 <CakeProphet> hehe
02:51:51 <oklopol> 4 languages?
02:51:57 <CakeProphet> yeah.
02:52:22 <CakeProphet> So... behaviors conditional run through actions based on what's occuring... they'll use a very abstract language.
02:52:32 <oklopol> i already saw simpsons, futurama and friends, after fg i'll have nothing unless i start watching anime :\
02:52:36 <CakeProphet> actions will be somewhere inbetween... they perform manipulations on the source code of traits.
02:52:59 <CakeProphet> traits will be simple event-based programming... they perform actions based on how their own soruce code is manipulated.
02:53:01 <CakeProphet> by actions.
02:53:32 <oklopol> these are programmed initially by the programmer?
02:53:41 <CakeProphet> an action would be like... grazing...
02:53:49 <CakeProphet> and a trait like... grass  (I'm assuming environment will be traits)
02:53:50 <oklopol> and they are altered when the thingies have fun?
02:53:51 <CakeProphet> yeah.
02:54:07 <CakeProphet> behaviors and actions will largely be altered by reproduction.
02:54:18 <CakeProphet> traits... I think... will be altered mostly through interaction.
02:54:58 <CakeProphet> It leads to some cool ideas.
02:55:29 <CakeProphet> I've never heard of a language that does operations based on how its source code is manipulated from an outside influence.
02:55:31 <oklopol> the 2d map exists too?
02:55:35 <CakeProphet> yeah.
02:55:38 <oklopol> good
02:55:42 <CakeProphet> it'll be a map of functions... basically.
02:55:49 <CakeProphet> and some primitive commands.
02:56:10 <oklopol> that is the main interface between creatures, it should be spec'd first
02:56:15 <oklopol> as much as possible
02:56:31 <CakeProphet> I was thinking it would be a big grid of symbols... followed by some function definitions.
02:56:39 <CakeProphet> for various symbols.
02:56:44 <CakeProphet> one character each
02:57:02 <oklopol> programmers can see the functions then ans decide their action on them?
02:57:04 <CakeProphet> it would most likely follow a language similar to the traits language... since the environment will be largely event driven.
02:57:21 <CakeProphet> Probably.
02:57:30 <CakeProphet> you would just need to peak under the soruce of the environment.
02:57:49 <CakeProphet> I see the environment being code that's mostly manipulated.
02:57:52 <CakeProphet> it makes a lot of sense.
02:57:56 <oklopol> hmm, prolly would be intentionally left for the programmers to see?
02:58:09 <oklopol> the code
02:58:13 <CakeProphet> Sure.
02:58:23 <CakeProphet> It's no fun poking in the dark.
02:58:28 <oklopol> frokfrokfrokfrokfrokfrokfrokfrokfrokrfokfrokfrokfrokfrokfrok
02:58:34 <oklopol> sorry
02:58:41 <oklopol> i'm a flooder normaly
02:58:42 <CakeProphet> hmm... let's call it Grass
02:58:44 <oklopol> *ll
02:58:48 <oklopol> hehe :)
02:58:50 <bsmntbombdood> I'm not sure what to do with logfuck
02:58:57 <CakeProphet> fuck it
02:58:57 <oklopol> why?
02:59:02 <oklopol> yeah
02:59:04 <oklopol> with your log
02:59:09 <CakeProphet> ...yup
02:59:13 <bsmntbombdood> heh
02:59:21 <oklopol> but, what ya mean?
02:59:27 <CakeProphet> well.. Grass was the name for a theoretical fractal-based Thue-like language I had in my mind.
02:59:28 <oklopol> or, just what to do?
02:59:31 <CakeProphet> because it was nature-ish
02:59:44 <bsmntbombdood> oklopol: Right now, it's not very usefull
02:59:46 <oklopol> fractal-based, i don't see that
02:59:53 <oklopol> bsmntbombdood, sure it is :)
03:00:07 <bsmntbombdood> I'm not sure how to do the looping operators
03:00:18 <oklopol> okay... they didn't work yet?
03:00:23 <bsmntbombdood> yeah, they work
03:00:32 <bsmntbombdood> The implementation is fine
03:00:39 <oklopol> > copies lead to both dup and drp?
03:00:44 <CakeProphet> well... fractal based as in... repeated self-similar manipulations of the source code (like Thue, but more complex logic involved) will produce any sort of arbitrary  "bytecode"... that could be read by an image creator. 
03:00:50 <bsmntbombdood> oklopol: no, that's the problem
03:00:58 <oklopol> okay
03:00:59 <bsmntbombdood> I think i'm going to have [ not pop
03:01:15 <oklopol> well, my bot has it like that :)
03:01:35 <CakeProphet> hmmm..
03:01:36 <oklopol> my bot's flooded our channel for 6 hours now, every 3 seconds
03:01:40 <oklopol> i love watching that
03:01:44 <CakeProphet> if we finish this lang... we could put it into a bot.
03:01:47 <CakeProphet> how awesome would that be
03:01:51 <oklopol> haha :D
03:01:53 <CakeProphet> a big database of creatures and maps.
03:02:23 <oklopol> tho, wouldn't be that interactive, i mean you couldn't see but the result
03:02:49 <CakeProphet> seems like a crude GUI would be the best result.
03:03:04 <oklopol> yes
03:03:16 <CakeProphet> or at most just a display
03:03:24 <oklopol> a screen and a bar for loading maps, creatures and opening a connection
03:03:26 <CakeProphet> of whats going on
03:03:37 <CakeProphet> heh.. I kinda like good ol' text files.
03:03:41 <CakeProphet> with the output being all fancified
03:04:16 -!- pikhq has joined.
03:04:17 <oklopol> i don't like the whole concept of having a graphical interface for a non-graphical operation
03:04:25 <oklopol> hey pikhq
03:04:26 <bsmntbombdood> I need to find out if logfuck is turing complete
03:05:48 <oklopol> make that... one lang
03:06:18 <oklopol> hmm, if it's final, i can try and make something outta it as well
03:06:27 <bsmntbombdood> It's not final
03:07:28 <oklopol> ah okay
03:07:34 <bsmntbombdood> I can't decide what to do with it
03:08:22 <oklopol> you don't have a list structure, so it's hard to make an interpreter
03:08:32 <oklopol> you could find an isomorphism tho
03:09:32 <oklopol> just list all basic operation sequences that do anything sensible and find a language proven turing complete that has them or just a subset of them
03:09:53 <oklopol> there was at least one... with i think less functionality
03:10:01 <oklopol> that was similar
03:10:03 <oklopol> very
03:10:07 <bsmntbombdood> well, two stacks make a tape
03:10:11 <oklopol> yeah
03:11:33 <bsmntbombdood> I can't figure out how to make cat
03:11:41 <oklopol> inc: 1g1--
03:11:48 <oklopol> dec: 1-
03:11:52 <oklopol> :DD
03:11:56 <bsmntbombdood> yeah
03:12:00 <CakeProphet> well..
03:12:03 <CakeProphet> you have a stack
03:12:12 <oklopol> [,.1] or smth wont work?
03:12:17 <oklopol> 1[,.1]
03:12:26 <bsmntbombdood> oklopol: that won't stop on eof
03:12:33 <oklopol> [,.]
03:12:36 <oklopol> then
03:12:41 <oklopol> 1[,.]
03:12:43 <bsmntbombdood> because the , pops the stack
03:12:56 <oklopol> huh?
03:12:59 <oklopol> why?
03:13:24 <oklopol> 1[1,.] if it pops
03:13:30 <oklopol> i'll check your spec
03:15:14 <oklopol> 1[,><.] should work if > copies, once again i don't remember, no copy in the reference
03:16:00 <bsmntbombdood> It doesn't copy
03:16:11 <bsmntbombdood> That messes stuff up
03:16:50 <oklopol> 1[,[>1g]<.] then?
03:17:21 <oklopol> read in, copy, move right, add a 0, pop it while ending loop, move copy back left
03:18:18 <bsmntbombdood> ?
03:18:35 <oklopol> doesn't work?
03:18:40 <oklopol> what is wrong?
03:18:41 <bsmntbombdood> EOF is -1
03:18:46 <oklopol> okay
03:19:08 <oklopol> 1[,[>1g]<.1g1--]
03:19:15 <oklopol> satisfied?
03:20:13 <bsmntbombdood> almost
03:20:20 <oklopol> what is wrong?
03:20:23 <bsmntbombdood> That prints an eof char
03:20:26 <oklopol> ah
03:20:30 <oklopol> yeah
03:21:09 <bsmntbombdood> whoa
03:21:12 <bsmntbombdood> you figured out dup
03:21:26 <oklopol> 1[,[>1g]<1g1--[1-.]]
03:21:31 <oklopol> how about now then?
03:21:45 <bsmntbombdood> nope
03:21:46 <oklopol> eof will jump off both loops
03:21:48 <oklopol> :(
03:21:53 <oklopol> what now?
03:22:32 <oklopol> eh
03:22:35 <bsmntbombdood> only prints one char
03:22:35 <oklopol> sorry
03:22:56 <oklopol> 1[,[>1g]<1g1--[1-.1g]]
03:22:57 <oklopol> now
03:23:02 <oklopol> since ] pops
03:23:50 <oklopol> okay
03:24:06 <bsmntbombdood> !!
03:24:08 <bsmntbombdood> workage
03:24:15 <oklopol> huh?
03:24:23 <oklopol> noooo!
03:24:25 <bsmntbombdood> it works
03:24:29 <oklopol> mine or yours?
03:24:32 <bsmntbombdood> yours
03:24:37 <oklopol> 1[,[>1g]<1g1--[1-.1g]] this?
03:25:00 <bsmntbombdood> yeah
03:25:04 <oklopol> AND I NEEDED ONLY 10 TRIES!!
03:25:11 <oklopol> :\\\\\\\\\\\\\
03:25:52 <oklopol> the spec should provide certain things that floating point arithmetic on a computer doesn't, normally
03:26:05 <bsmntbombdood> good job
03:26:09 <bsmntbombdood> what do you mean?
03:26:38 <oklopol> you use logs for multiplication, might be that the error margin grows with many operations
03:26:55 <oklopol> which one wouldn't expect normally in integer arithmetic
03:27:00 <bsmntbombdood> hmm
03:27:50 <oklopol> anyway, 0 as end condition should be abs(top)<0.00005 or smth :)
03:28:21 <oklopol> i dunno
03:28:25 <oklopol> not important
03:29:16 <oklopol> what i don't see is why EOF ends inputting since i only convert one of the dup'd values to (value+1) for testing :)
03:29:21 -!- CakeProphet has quit (Read error: 145 (Connection timed out)).
03:29:41 <bsmntbombdood> whats the 1g1-- for?
03:29:46 <oklopol> +=1
03:29:56 <oklopol> for -1 -> 0
03:30:03 <oklopol> ah
03:30:06 <oklopol> i see it now
03:30:14 <oklopol> [ never pops?
03:30:21 <bsmntbombdood> [ never pops
03:30:23 <oklopol> yeah
03:30:29 <bsmntbombdood> how does 1g1-- add one though?
03:30:46 <oklopol> 0 - 1 = -1. x --1 = x+1
03:31:20 <bsmntbombdood> oops
03:31:24 <bsmntbombdood> yeah, I read it wrong
03:31:43 <oklopol> with dup you can make a number n on the stack in O(logn)
03:31:47 <oklopol> tho it's complicated
03:31:49 <bsmntbombdood> I switched postfix and prefix in my head accidently
03:32:03 <oklopol> yeah, it's common :\
03:33:37 <bsmntbombdood> well, I'm satisfied now
03:33:42 <bsmntbombdood> (with the language)
03:33:56 <oklopol> how to add two topmost elements?
03:34:01 <oklopol> without inserting code
03:34:06 <oklopol> before them
03:34:16 <bsmntbombdood> >1g<--
03:34:28 <oklopol> yeah
03:34:29 <oklopol> true
03:34:57 <oklopol> i love the > and <, like get-outta-my-way commands
03:35:15 <oklopol> since only the stuff moves, you stay put (hmm, might be just me xD)
03:35:26 <bsmntbombdood> yeah
03:35:36 <bsmntbombdood> You always stay on the primary stack
03:36:28 <oklopol> i see the 1g as 0 now, forgot it means the same as everywhere else
03:36:44 <bsmntbombdood> wish it didn't need p :(
03:36:50 <oklopol> why g, by the way?
03:36:56 <bsmntbombdood> loG
03:37:06 <oklopol> yeah... but there is l, you know :)
03:37:13 <bsmntbombdood> l looks like 1, o looks like 0
03:37:27 <oklopol> _ could represent a log -__________-
03:37:41 <oklopol> just lying around...
03:37:45 <bsmntbombdood> heh
03:37:52 <oklopol> fuck :O 2½ hours left
03:38:17 <bsmntbombdood> "-__-" == log base 2, "-___-" log base 3 ...
03:38:35 <oklopol> and i've not read yet, not watched my episodes and talking naked on IRC about programming 8||
03:38:39 <bsmntbombdood> I can't even remember why I chose 'p'
03:38:42 <oklopol> hehe :D
03:38:53 <oklopol> -__- is my other nick in quakenet!
03:38:57 <bsmntbombdood> maybe exPonent
03:39:03 <pikhq> You're doing nude IRCing?
03:39:04 <oklopol> yeah, third there too
03:39:17 <bsmntbombdood> pikhq, what do you think about my language
03:39:18 <oklopol> i'm always nude, if you can handle the knowledge :)
03:39:32 <oklopol> if not, then... i'm lying
03:39:57 <pikhq> bsmntbombdood: I think my brain is *dead*.
03:40:05 <pikhq> Give me a summary this weekend.
03:40:11 <bsmntbombdood> ok
03:40:20 <oklopol> hmm, you can't take the log of 0
03:40:21 <oklopol> ?
03:40:25 <oklopol> m i rihgt?
03:40:35 <bsmntbombdood> log 0 is undefinded
03:40:36 <pikhq> log(0) is undefined.
03:40:38 <oklopol> okay
03:40:42 <oklopol> thought so
03:40:50 <oklopol> you should define it
03:40:52 <oklopol> for fun
03:41:08 <bsmntbombdood> log(0) == -infinity
03:41:17 <oklopol> yeah
03:41:18 <pikhq> e^x=0. Solve for x.
03:41:27 <oklopol> 2^x=0
03:41:43 <oklopol> not ln, log2
03:41:54 <pikhq> Oh.
03:41:54 <bsmntbombdood> it's the same for all bases
03:42:10 <pikhq> Fine.
03:42:17 <pikhq> b^x=0, where b is your base.
03:42:20 <pikhq> Solve for x.
03:42:23 <pikhq> Have fun.
03:42:56 <oklopol> x=-oo
03:43:09 <oklopol> i think it's nice enough
03:43:19 <bsmntbombdood> lim_{x \to -\infty}{2^x} = 0
03:43:21 <pikhq> (lim x->-oo b^x)=0. . .
03:43:25 <oklopol> ye
03:43:30 <pikhq> Doesn't mean that b^-oo=0.
03:43:34 <pikhq> ;)
03:43:59 <bsmntbombdood> pikhq: LaTeX pwns j00
03:44:00 <bsmntbombdood> :P
03:44:01 <oklopol> true, i know that, just wasn't sure if i could represent it that formally
03:44:09 <oklopol> but, fortunately you BOTH did
03:44:36 <pikhq> bsmntbombdood: I don't remember the LaTeX syntax for limits; sorry.
03:44:47 <oklopol> latex?
03:44:49 <pikhq> (I've not had to use it)
03:45:04 <pikhq> oklopol: It's a typesetting system which excels at math.
03:45:12 * pikhq needs to leave
03:45:13 -!- pikhq has quit ("leaving").
03:45:47 <oklopol> :O
03:46:30 <bsmntbombdood> oklopol: lim_{x \to -\infty}{2^x} = 0 gets rendered to this:
03:46:40 <bsmntbombdood> http://www.mathbin.net/7252
03:47:11 <oklopol> i know
03:47:24 <oklopol> it was obvious from the syntax for one
03:47:33 <oklopol> plus i already knew what you meant :)
03:47:59 <oklopol> cool bin tho :\
03:48:38 <oklopol> okay, now i'm neither coding nor talking about coding
03:48:42 <oklopol> maybe i'll open the bool
03:48:47 <oklopol> ..........k
03:49:00 <oklopol> c u
03:49:17 <bsmntbombdood> bye
04:06:28 <bsmntbombdood> damnit
04:06:46 <bsmntbombdood> oklopol: That cat program doesn't work unless > copies
04:06:49 <bsmntbombdood> which it shouldn't
04:08:04 <bsmntbombdood> argh
04:20:21 <bsmntbombdood> heh, fun program: 1[11g1--11g1--11g1-->g<g>1g<--p>g<g>1g<--p1-.1]
04:21:05 -!- calamari has joined.
04:22:38 <bsmntbombdood> (that prints beep chars endlessly)
04:30:04 <oklopol> 1[,[>1g]<1g1--[1-.1g]] this? weird
04:30:13 <oklopol> it certainly won't work if > copies...
04:30:51 <bsmntbombdood> yeah
04:31:18 <bsmntbombdood> what?
04:31:19 <bsmntbombdood> no
04:31:28 <bsmntbombdood> It works only if > copies
04:32:57 <oklopol> 1:1 -> [:1 -> ,:1 I -> [:1 I I -> >:1 I, I -> 1:1 I 1, I -> g:1 I 0, I -> ]:1 I, I -> <:1 I I
04:33:04 <oklopol> if no copying
04:33:26 <bsmntbombdood> [>1g]< doesn't dup
04:33:39 <oklopol> 1:1 -> [:1 -> ,:1 I -> [:1 I I -> >:1 I I, I -> 1:1 I I 1, I -> g:1 I I 0, I -> ]:1 I I, I -> <:1 I I I
04:33:42 <oklopol> if dopying
04:33:44 <oklopol> *copying
04:33:54 <bsmntbombdood> I don't understand your notation
04:33:57 <oklopol> it triplicates if > copies
04:34:03 <bsmntbombdood> no
04:34:09 <oklopol> oper: stack1, stack2 -> next
04:34:29 <oklopol> I == input
04:34:37 <oklopol> what is wrong with it?
04:34:45 <oklopol> please tell me where it goes wrong
04:34:47 <oklopol> :\
04:35:10 <bsmntbombdood> [ = do nothing to stack
04:35:15 <bsmntbombdood> > move top over
04:35:22 <bsmntbombdood> 1g drop 0 on
04:35:29 <bsmntbombdood> ] pop zero off, end loop
04:35:32 <oklopol> ah
04:35:33 <oklopol> okay
04:35:35 <bsmntbombdood> < move back over
04:35:58 <oklopol> mine works if EITHER > copies or [ duplicates
04:36:07 <oklopol> but i meant it with [ duplicates
04:36:20 <bsmntbombdood> [ has never duplicated
04:36:21 <oklopol> if there is neither in the language, how do you duplicate?
04:36:23 <oklopol> okay
04:36:31 <oklopol> i just imagined it then
04:36:36 <bsmntbombdood> I'm starting to think there's no way to dup :(
04:36:40 <oklopol> okay
04:36:45 <oklopol> then make [ duplicate
04:36:57 <bsmntbombdood> That doesn't make sense
04:37:02 <oklopol> [ push ] pop
04:37:23 <bsmntbombdood> then there's no way to drop
04:38:20 <oklopol> yeah
04:38:27 <oklopol> same prob as before
04:38:49 <bsmntbombdood> If we got rid of p we could add a dup command
04:39:05 <oklopol> nooooooo
04:39:19 <oklopol> 2 log commands is better than stack opers
04:39:22 <oklopol> hmm
04:39:37 <oklopol> you did have [ duplicate at some point of testing
04:39:37 <bsmntbombdood> I'll keep trying to think of ways to emulate p
04:39:39 <oklopol> i'm sure
04:39:51 <bsmntbombdood> nope
04:41:17 <oklopol> okay
04:41:57 <oklopol> i just suggested that, you thought it didn't work, which it didn't
04:42:01 <oklopol> but i stuck with it :)
04:42:07 <oklopol> hard to change
04:42:15 <oklopol> anyways, that doesn't work now
04:42:40 <oklopol> i like [ duplicate more than > duplicate (you need one of them) because it's more logical
04:42:45 <oklopol> but then there's no drop
04:42:52 <oklopol> > copying you have both
04:42:56 <oklopol> ...no
04:43:08 <bsmntbombdood> yes, [] is drop
04:43:09 <oklopol> yes
04:43:12 <oklopol> esyesy
04:43:27 <bsmntbombdood> wait
04:43:41 <bsmntbombdood> nope
04:43:52 <bsmntbombdood> because [] will keep dropping untill it gets to 0
04:44:08 <oklopol> 01[]
04:44:11 <bsmntbombdood> and if > copies we have no way to put a 0 under the top
04:44:16 <oklopol> yeah
04:44:18 <oklopol> tru
04:44:18 -!- digital_me has quit ("leaving").
04:44:33 -!- digital_me has joined.
04:44:37 <oklopol> damn :D you're one step ahead of me all the time
04:45:15 <oklopol> what if
04:45:21 <oklopol> log 0 would be drop?
04:45:42 <bsmntbombdood> that doesn't make sense
04:45:55 <oklopol> i think it does, but maybe not :)
04:46:26 <bsmntbombdood> g should never take more than one off the stack
04:46:50 <oklopol> it wouldn't
04:46:57 <oklopol> it just wouldn't put anything back in
04:47:31 <oklopol> anyway, you could only wipe out numbers divisible by 2 :)
04:47:50 <oklopol> i meant if you tried 0g it would leave nothing there
04:48:00 <oklopol> then 2 would be dropped with gg
04:48:11 <oklopol> and 2.1 with infinite amount of ggggggg... xD
04:48:19 <oklopol> so no
04:48:29 -!- GreaseMonkey has joined.
04:49:30 <oklopol> hmm
04:49:45 <bsmntbombdood> how does one undo a log without a special function to do it...
04:49:49 <oklopol> you can make that work with many kinds of little nonsence
04:50:13 <oklopol> you could have [ not copy a 0 but pop it :)
04:50:26 <oklopol> so ig[ would start a non-dup loop
04:50:30 <oklopol> and [ a dup look
04:50:38 <bsmntbombdood> That wouldn't do anything
04:50:46 <oklopol> 1g[
04:50:53 <oklopol> wouldn't?
04:51:05 <oklopol> yeah, it wouldn't :)
04:51:57 <oklopol> well, add a drp, make [ or > push, then it'll work
04:52:18 <bsmntbombdood> I don't want more than 10 commands though :(
04:53:22 <oklopol> well, i think it'd a good way to handle log(0) to make it a drop that drops another from the stack :)
04:53:30 <oklopol> it's undefined
04:53:49 <bsmntbombdood> That would make g very very weird
04:53:50 <oklopol> so... why not
04:53:54 <oklopol> nah
04:54:03 <bsmntbombdood> g can't take more than one arg from the stack
04:54:11 <oklopol> why is that?
04:54:18 <oklopol> you don't take random logs from input
04:54:28 <oklopol> you always know when you put 0 in
04:54:36 <oklopol> and you always do it for dropping
04:54:41 <oklopol> it's true it's not intuitive
04:54:44 <bsmntbombdood> Because you can only take the log of one number
04:54:52 <bsmntbombdood> so g taking 2 numbers doesn't make sense
04:55:17 <oklopol> yes, but log(0) is an error, that would just be a try {} catch() to drop
04:55:23 <oklopol> -_______-
04:55:33 <GreaseMonkey> what's this lang?
04:55:46 <oklopol> logfuck :)
04:55:47 <bsmntbombdood> GreaseMonkey: http://bsmntbombdood.mooo.com/logfuck_spec.txt
04:56:00 <bsmntbombdood> GreaseMonkey: http://bsmntbombdood.mooo.com/logfuck.py.txt
04:57:48 <oklopol> basically, you have to choose between side-effects and overloading
04:57:54 <oklopol> if you don't want a new command
04:58:03 <oklopol> side-effects don't seem to do it
04:58:33 <oklopol> so... g could be overloaded for input it can't handle yet
05:01:14 <oklopol> 1[1,1g1--[1-.1g]] actually
05:01:21 <oklopol> no dup needed i think...
05:01:48 <oklopol> bsmntbombdood, try that!
05:02:37 <bsmntbombdood> !!!!!!!!
05:02:40 <bsmntbombdood> it works
05:02:47 <oklopol> goods
05:03:00 <oklopol> but, still, dup and drp, needed are
05:03:12 <oklopol> fuck 8|| i gotta go to school
05:03:21 <GreaseMonkey> school hols here :D
05:03:43 <bsmntbombdood> school :(
05:03:44 -!- Sgeo has quit ("Leaving").
05:03:46 <oklopol> school in an hour here and holidays in a few months
05:04:35 <bsmntbombdood> I don't see where that code drops out of the loop
05:04:37 <bsmntbombdood> on eof
05:11:36 <oklopol> it does, tho?
05:11:38 <oklopol> right?
05:12:38 <oklopol> 1[1,1g1--[1-.1g]] -1 won't go in the inner loop, [ won't drp it tho, so it'll go outta the outermost loop too
05:18:04 -!- digital_me has quit ("Lost terminal").
05:19:48 <oklopol> bsmntbombdood, please respond, it'll bug me the whole day otherwise :)
05:19:49 <oklopol> oh
05:19:59 <oklopol> i can dl the official code tho
05:22:43 <oklopol> i can't run it tho
05:22:44 <oklopol> :))
05:22:46 <oklopol> :)))))
05:30:11 <GreaseMonkey> i bags we make a massive BF-style lang with a shitload of instructions and call it BrainDead
05:31:32 <GreaseMonkey> afk food
05:39:45 <bsmntbombdood> oklopol: yes, it works
05:40:36 <bsmntbombdood> Why can't you run it?
05:41:15 <bsmntbombdood> anyway, bedtime
05:51:53 -!- calamari has quit ("Leaving").
05:57:33 <GreaseMonkey> b4x0r
06:18:14 -!- oklofok has joined.
06:19:46 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
07:32:56 -!- oerjan has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:00:47 -!- ShadowHntr has joined.
08:07:23 -!- sebbu has joined.
08:30:13 -!- oerjan has quit ("Delirium").
08:33:34 <GreaseMonkey> gtg zzz gnight
08:34:35 -!- GreaseMonkey has quit (".,,._ {o_O} _.,,.").
09:24:40 -!- ShadowHntr has quit ("End of line.").
10:16:29 -!- Asztal has quit ("closing VM").
11:39:57 -!- helios24 has joined.
11:55:13 -!- sebbu2 has joined.
12:14:28 -!- sebbu has quit (Read error: 110 (Connection timed out)).
12:36:59 -!- MM2 has quit (Read error: 110 (Connection timed out)).
13:02:33 -!- MM2 has joined.
13:03:41 -!- jix__ has joined.
13:17:41 <oklofok> i couldn't because i have an old version of python
13:17:51 <oklofok> i could dl a new one now
13:17:58 <oklofok> but i was in quite a hurry
13:23:25 -!- oklofok has changed nick to oklopol.
13:28:00 -!- anonfunc has quit.
14:10:57 -!- calamari has joined.
14:18:24 -!- calamari has quit (Read error: 104 (Connection reset by peer)).
14:20:20 -!- calamari has joined.
14:20:48 -!- MM2 has quit (Read error: 110 (Connection timed out)).
14:37:37 -!- sebbu has joined.
14:37:53 -!- Asztal has joined.
14:47:19 -!- calamari has quit ("Leaving").
14:52:00 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
14:56:15 -!- sebbu2 has quit (Read error: 110 (Connection timed out)).
15:54:32 -!- tgwizard has joined.
16:00:07 -!- jix__ has joined.
16:06:30 -!- Asztal has quit (Read error: 110 (Connection timed out)).
16:18:59 -!- jix__ has quit (Read error: 54 (Connection reset by peer)).
16:19:15 -!- jix__ has joined.
16:37:02 <SimonRC> I think a major impediment to good esolanging is that we make stuff up.
16:37:26 <SimonRC> If we didn't just make stuff up, we could have invented stuff like this:   http://home.pipeline.com/~hbaker1/Use1Var.html
17:06:02 -!- helios24 has quit ("Leaving").
17:16:32 <lament> okay, let's stop making stuff up.
18:22:13 <bsmntbombdood> making what up?
18:42:45 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
18:48:59 -!- Asztal has joined.
19:04:17 -!- tgwizard has quit (Read error: 110 (Connection timed out)).
19:11:53 -!- tgwizard has joined.
20:18:44 <SimonRC> BTW, I recommend reading about single-use variables.  They are fascinating
20:30:21 -!- sebbu2 has joined.
20:31:38 -!- sebbu has quit (Nick collision from services.).
20:57:26 -!- Asztal has quit (Read error: 110 (Connection timed out)).
21:05:48 -!- oerjan has joined.
21:06:48 -!- jix__ has joined.
21:21:03 <oerjan> For a language depending heavily on single use variables, check out Clean.
21:28:46 -!- Sgeo has joined.
21:33:11 -!- tgwizard has quit (Remote closed the connection).
21:40:12 <SimonRC> oerjan: Already done so.
21:40:24 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
21:47:05 -!- RodgerTheGreat has joined.
21:48:29 <SimonRC> RodgerTheGreat: hi
21:49:03 <SimonRC> RodgerTheGreat: read about uniquiness types.  They rock for esotericness!
21:49:14 <RodgerTheGreat> ok, cool.
21:49:19 <RodgerTheGreat> I'll look into it
21:51:23 <RodgerTheGreat> ooh
21:51:29 <RodgerTheGreat> yeah, that's a good idea
21:52:29 <SimonRC> now read this, which gives VM ideas:       http://home.pipeline.com/~hbaker1/LinearLisp.html
21:57:30 -!- sebbu2 has quit (Connection timed out).
22:34:26 <bsmntbombdood> hmph
22:59:31 -!- pgimeno has changed nick to pgimeno42.
23:08:31 -!- pgimeno42 has changed nick to pgimeno.
23:20:13 -!- oerjan has quit ("Death").
23:22:38 -!- CakeProphet has joined.
23:23:04 <CakeProphet> MMM
23:23:30 <bsmntbombdood> mmm
23:43:33 -!- CakeProphet_ has joined.

2007-01-19:

00:00:13 -!- CakeProphet has quit (Read error: 110 (Connection timed out)).
00:04:50 -!- CakeProphet_ has changed nick to CakeProphet.
00:53:47 <bsmntbombdood> maybe logfuck doesn't need a dup
01:05:27 -!- pikhq has joined.
01:05:54 <CakeProphet> I'm devising a language based on the rhythm of sound.
01:06:23 <CakeProphet> where the rhythm is the data rather than the operation.
01:06:34 <pikhq> . . .
01:07:09 <CakeProphet> . . . 
01:07:38 <bsmntbombdood> .. .. ..
01:07:45 <CakeProphet> . .. .. .
01:07:56 <CakeProphet> .-.-.-.-.--.--.--...--...-.-.-.-.-.-.-.
01:08:08 <CakeProphet> hmm..
01:08:24 <CakeProphet> I could probably have an infinite memory... despite being a finite medium.
01:08:31 <CakeProphet> because rhythm is infinitely divisble.
01:09:15 <pikhq> It's a theoretically infinite medium, actually.
01:09:39 <pikhq> Unless your arbitrarily limit the music size?
01:10:05 <CakeProphet> I probably would... just to see if the inifitely-visibleness makes it infite.
01:10:05 * pikhq recommend something like opcodes encoded in the notes, initial data encoded via rythm
01:10:17 <CakeProphet> nah.. no notes
01:10:32 <pikhq> So just a drumbeat, then?
01:10:44 <CakeProphet> I'm going with a non-musical structure operating on the data.
01:10:49 <CakeProphet> rhythm only being the analogy for the data
01:10:57 <pikhq> That's no fun.
01:11:07 <pikhq> I want to be able to pay my code!
01:11:23 <CakeProphet> it's technically a finite strip of inifitely divisble data with regular segments of "sound" and "no sound"... a binary encoding that can be divided by any ratio.
01:11:35 <pikhq> (besides, at least with something like GNU Lilypad, there's a simple syntax for music encoding)
01:12:43 <CakeProphet> there will be maybe 3 sound-manipulation commands... and 3 or 4 pointer manipulation commands...
01:13:15 <CakeProphet> the pointer is basically three pointers... forming two segments... on which the sound-manipulation commands operate.
01:14:02 <pikhq> Make a rythmic output device, then.
01:14:12 <CakeProphet> with the control commands being proportional
01:14:14 <pikhq> Maybe tie into MIDI and make it play your data like a drumbeat.
01:14:16 <pikhq> >:D
01:14:18 <CakeProphet> yeah, that seems to be a thing to do.
01:14:40 <pikhq> (in addition to ASCII, maybe?)
01:14:57 <CakeProphet> so if you have -----|--|-------|------
01:15:31 <CakeProphet> doing "zoom tuk"   (tuk is the formal name for the segment formed between the middle and right pointers)
01:15:34 <CakeProphet> you would  get...
01:15:51 <CakeProphet>  something like   -------|--|-----|------
01:16:37 <CakeProphet> it's kinda like the golden ratio.
01:16:46 <pikhq> Heheh.
01:16:55 <CakeProphet> you take a part of the ratio... and make it the whole of the ration.
01:18:29 <CakeProphet> commands for operating on the data would be like... flip segments...
01:18:49 <CakeProphet> which gives you conditions... if both the flipped segments are the same type... nothing is changed.
01:19:03 <CakeProphet> otherwise... they swap type.
01:20:48 <CakeProphet> that could actually be consider the string-rewriting paradigm.
01:21:02 <CakeProphet> if ASCII is converted into the rhythm... and the entire program is merely operations on that string.
01:23:57 <CakeProphet> other ideas could be to use polythym to program.
01:24:14 <CakeProphet> you play two rhythms side by side... with the combinations being operations.
01:34:51 <CakeProphet> OH
01:34:58 <CakeProphet> how about a concurrent programming language.
01:35:05 <CakeProphet> with like... single character commands.
01:35:13 <CakeProphet> each thread is separate by two newlines.
01:35:34 <CakeProphet> and they're all interpreted at the same time (albeit, with a nanosecond so between them), and on different resources.
01:35:40 <CakeProphet> haha... threaded BF
02:08:22 <CakeProphet> wrote up a spec for it:  http://esolangs.org/wiki/Weave   :D
02:13:08 * SimonRC thinks there needs to be way to program a collection of processes instead of individual processes; you don't say "send to foo" in one and "receive from bar" in the other, but you specify a "copy from foo to bar".
02:13:12 * SimonRC realises there must be dozens of obscure academic papers on many ways of doing this.
02:13:15 * SimonRC goes to bed.
02:13:33 <CakeProphet> ...what?
02:21:02 * CakeProphet is organizing the esolang wiki's categories a bit.
02:21:06 <CakeProphet> they're kind of disgruntled.
03:02:23 <bsmntbombdood> owtf
03:02:30 <bsmntbombdood> why isn't AND a function in common lisp
03:02:32 <bsmntbombdood> stupid macros
03:03:26 <bsmntbombdood> I thought I could do (reduce #'and list)
03:03:35 <CakeProphet> it isn't?
03:03:48 <CakeProphet> I thought and was a valid function.
03:04:26 <bsmntbombdood> (funcall #'and 1 2)
03:04:34 <bsmntbombdood> > The function AND is undefined.
03:08:50 <bsmntbombdood> that's dumb
03:32:10 -!- pikhq has quit ("leaving").
03:57:32 -!- bsmntbombdood has changed nick to bdsmbombdood.
04:13:53 -!- bdsmbombdood has changed nick to bsmntbombdood.
04:22:42 -!- RodgerTheGreat has quit (Read error: 110 (Connection timed out)).
04:26:47 -!- CakeProphet has quit (Read error: 113 (No route to host)).
04:44:30 -!- wooby has quit ("BitchX: often imitated, never duplicated!").
05:22:50 -!- Sgeo has quit ("Leaving").
05:53:35 -!- MM2 has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
09:11:30 -!- oerjan has joined.
09:58:10 -!- oerjan has quit ("Destruction").
11:13:36 <SimonRC> bsmntbombdood: ISTR there is a FAND, which *is* a function.
11:14:15 <SimonRC> anyway, AND takes as many arguments as you want, so I suspect it is not useful to reduce with it.
11:14:53 <SimonRC> Discouraging the evaluation-control usage of macros is why Haskell has laziness, you know.
12:37:43 -!- MM2 has quit (Read error: 131 (Connection reset by peer)).
12:39:12 -!- MM2 has joined.
15:07:30 -!- tgwizard has joined.
17:11:01 -!- sebbu has joined.
18:14:57 -!- tgwizard has quit (Remote closed the connection).
18:29:37 * SimonRC goes to dinner.
19:35:04 <bsmntbombdood> bsmnt_bot is bored
19:35:19 <oklopol> !fuckyerself
19:35:59 <oklopol> make it say "* bsmntbot is bored" if idle for a day :)
19:36:04 <bsmntbombdood> oklopol: make logfuck better!
19:36:06 <oklopol> easy
19:36:08 <oklopol> :O
19:36:12 <bsmntbombdood> or come up with a better name
19:36:13 <oklopol> i meant the bored thing :)
19:36:24 <oklopol> name, better?
19:36:31 <bsmntbombdood> yeah
19:36:48 <oklopol> XXXfuck, where XXX is the shortest possible string related to the subject
19:37:05 <bsmntbombdood> naaah
19:37:11 <oklopol> is the naming convention for languages that have relations with bf
19:37:21 <bsmntbombdood> I don't want it to have fuck in it, so that I can tell normal people about it
19:38:08 <oklopol> logarythm would be nice if combined with CakeProphet's
19:38:10 <oklopol> :)
19:38:20 <oklopol> i'll try again
19:38:57 <oklopol> hmm
19:39:11 <oklopol> i only come up with stupid wordplays :)
19:39:43 <oklopol> how about just "logic"?
19:39:51 <bsmntbombdood> logic?
19:40:08 <oklopol> okay, bad then
19:40:11 <oklopol> hmm
19:41:57 <oklopol> make it better how?
19:42:07 <oklopol> what solution did you choose?
19:42:17 <bsmntbombdood> ?
19:42:26 <oklopol> for the dup/drp thing
19:43:03 <bsmntbombdood> didn't
19:43:08 <bsmntbombdood> I think that dup isn't needed
19:43:29 <oklopol> it is
19:43:41 <bsmntbombdood> as long as pooping in a [] is deffered to the ]
19:43:55 <oklopol> deffered?
19:44:48 <oklopol> i didn't understand that
19:45:47 <bsmntbombdood> delayed
19:46:00 <oklopol> ah deferred
19:46:05 <oklopol> still
19:46:06 <bsmntbombdood> and s/poop/pop/
19:46:24 <oklopol> it starts making sence eventually .D
19:46:39 <oklopol> so, ] pops -> it works?
19:46:46 <bsmntbombdood> I think
19:46:57 <oklopol> k
19:46:57 <oklopol> dup
19:47:04 <oklopol> shuwwit!
19:47:30 <bsmntbombdood> you can't dup
19:47:40 <oklopol> ah sorry
19:47:54 <oklopol> hmm
19:47:58 <oklopol> i think you need to dup
19:48:06 <bsmntbombdood> I think you can do it without dup
19:48:54 <oklopol> do "get input -> subtract log(input) from input"
19:49:02 <oklopol> then i'm happy
19:50:50 <bsmntbombdood> hrm
19:51:18 <oklopol> i'm not saying it's impossible
19:51:20 <oklopol> but i am
19:53:14 <bsmntbombdood> I can't figure out how
19:54:33 <oklopol> you can only do a subtraction of two adjacent numbers on the stack, there is no way to transmit ANY information between two numbers, so it is impossible to get the two numbers input and log(input) on top of the stack
19:56:35 <bsmntbombdood> I think it's still turing complete
19:56:42 <oklopol> nah
19:57:12 <oklopol> a turing complete system must be able to turn a number x to (x-log(x))
19:57:18 <oklopol> well
19:58:10 <oklopol> hmm, i think it's not turing complete if a number used in x calculations must be input x times
19:58:32 <bsmntbombdood> turing completeness doesn'thave to do with input/ouput
19:58:45 <oklopol> and i think if the example is impossible, other, more clear cases aren't either
19:58:59 <oklopol> well, okay
19:59:17 <oklopol> hmm
19:59:25 <oklopol> my example didn't work :)
19:59:27 <bsmntbombdood> argh
19:59:33 * bsmntbombdood adds dup
19:59:37 <oklopol> why is that?
19:59:49 <oklopol> it wasn't turing complete after all?
20:00:35 <bsmntbombdood> i dunno
20:00:35 <oklopol> :)
20:01:33 <oklopol> with that, if you want to, at any point of execution, subtract a from log(a), you will have to duplicate the whole program sofar
20:02:19 <bsmntbombdood> ,dg-
20:02:57 <bsmntbombdood> x-log(x)
20:02:59 <bsmntbombdood> :/
20:03:01 <oklopol> i know
20:03:05 <oklopol> i'm not blind :)
20:03:21 <bsmntbombdood> 11 commands :(
20:04:22 <oklopol> :(
20:04:41 <bsmntbombdood> i have to leave
20:04:46 <oklopol> bye
20:47:40 -!- oerjan has joined.
21:15:53 -!- anonfunc has joined.
21:21:42 -!- helios24 has joined.
21:44:21 <oklopol> made a new language today (1 fully)
21:44:30 <oklopol> brainfuck with floating point arithmetic
21:44:36 <oklopol> which has been my goal for long
21:44:55 <lament> how can that work? explain.
21:45:12 <oklopol> it adds a few constraints to programs
21:45:27 <oklopol> you have to have as many >'s as you have <'s in one level
21:45:30 <oklopol> or, []
21:45:42 <oklopol> and input allowed only at "base" level
21:46:05 <oklopol> +++[------->+<]>: would print 3/7
21:46:08 <oklopol> whatever that is
21:46:51 <oerjan> That >< constraint implies you can only use a finite number of cells.
21:47:04 -!- sebbu2 has joined.
21:47:05 <oklopol> yes
21:47:30 <oklopol> i think it's turing complete, i don't care whether it is or not, tho, it's a nice toy
21:47:32 <oerjan> Same as named whiles in pikhq's BFM
21:48:08 <oerjan> You get a Minsky machine that way, which is Turing complete.
21:48:24 <oerjan> (Ignoring non-integer values)
21:48:42 <oklopol> ;>++++>++++++++[<<[>>>+>>+<<<<[<->>>>+<<<]>>>[-<<<+>>>]<<<<-]>>>>>[-<<<<<+>>>>>]<<[-<<+>>]<-]<:
21:48:48 <oklopol> calculates sqrt of input :)
21:49:25 <oklopol> the 8 in the beginning is the number of iterations, 4 is the initial guess
21:49:52 <oklopol> i'm not yet sure whether it is possible to make an interpreter without adding even more constraints
21:50:18 <lament> hm
21:50:24 <lament> i still don't get how that works
21:50:35 <oerjan> Only increment and decrement? Are you using differentiation implicitly?
21:50:39 <oklopol> (i think i can implement any math-related function even with the constraint a sub-[] can't change a parent-[]'s data)
21:50:43 <oklopol> yes
21:50:44 <oklopol> :)
21:50:51 <oerjan> Curiously I had the exact same idea today!
21:50:53 <lament> i'm quite sure that's not turing-complete actually
21:50:55 <oklopol> difference is the name of the language
21:50:57 <oklopol> really :D
21:50:59 <oklopol> cool
21:51:20 <oerjan> Probably caused by the logfuck discussion
21:51:53 <oklopol> lament, i think it is, and i'd add all bf features if they'd make algorithmic sence like <'s and >'s being predictable
21:52:27 <oklopol> i mean, mathematically pretty hard to say how the differentiation works if there are for example inputs in a [] :)
21:53:08 <lament> i just don't understand what the semantics of - are
21:53:10 <oklopol> oerjan, i've thought about that some time ago, but heard about differential just a few months ago... and maybe the logfuck discussion too
21:53:20 <oklopol> lament, it decreases one
21:53:30 <oklopol> one 1/inf
21:53:38 <oerjan> You might want to look at non-standard analysis.
21:53:43 <lament> one 1/inf.
21:54:38 <oklopol> well, if you put [->++<] in brainfuck, you are multiplying a number. if you put [-->+<] then you either divide a number or do something unpredictable
21:54:50 <lament> so ++[->[->++<]] is exponentiation?
21:54:51 <oklopol> using differentials that makes sence too
21:55:13 <lament> err not like that
21:55:15 <oklopol> that does what it does in bf
21:55:20 <lament> ++[->++[->++<]]
21:55:31 <oklopol> 0,0,8
21:55:36 <oklopol> is the memory
21:55:49 <oklopol> if you add a <
21:55:58 <lament> hm.
21:55:59 <oklopol> i presumed you meant that
21:56:21 <lament> interesting
21:56:26 <oklopol> lament, most simple bf programs would work still...
21:56:36 <oklopol> [] is what does the funny stuff
21:56:43 <lament> still not sure if it's gonna be well-defined
21:57:03 <oerjan> It may be well-defined though not necessarily computable.
21:57:05 <oklopol> should a number go over / under zero during a loop, it is retried with a smaller increase
21:57:22 <oklopol> it is possible to interpret if i add constraints
21:57:49 <oklopol> BUT, these constrains are already used in many mathematical functions done with bf
21:58:04 <oklopol> you rarely depend on overflow
21:58:19 <oklopol> and in math you rarely have to iterate through memory
21:58:27 <lament> so you define [expr] as lim n->0 of evaluating [expr] in a language where - and + mean subtract and add n
21:58:33 <lament> right?
21:59:02 <oklopol> yes
21:59:33 <lament> possibly you could do that to the entire program and don't need the matching > and < restriction
22:00:14 <oklopol> nah
22:00:33 <oklopol> hmm
22:00:44 <oklopol> i'll try and find an example why it wouldn't work
22:00:44 <oerjan> There are some subtleties with that definition, since some values of n cause loops not to hit 0.
22:01:04 <lament> we define [] as checknig for when the index goes below 0
22:01:23 <lament> actually no, we define - as having bounds-checking
22:01:38 <lament> that makes more sense since i assume you want to keep all numbers positive?
22:01:42 <oklopol> nah
22:01:44 <oklopol> i don't
22:01:44 <lament> oh
22:01:55 <lament> that does make it more difficult :)
22:02:27 <oerjan> There may be cases where wrapping around at infinity works nicely.
22:02:28 <oklopol> you are missing the fact that inner []'s can move the pointer too, they are theoretically done infinity times
22:02:37 <oklopol> which is no problem with my constraint
22:02:38 <lament> oerjan: doubtful
22:02:51 <oerjan> Not at all doubtful.
22:03:12 <lament> oerjan: not well-defined
22:03:21 <lament> oklopol: that's fine, it's just a limit
22:03:30 <lament> (if it IS just a limit, which it doesn't seem to be)
22:03:33 <oerjan> It is well-defined if the limit is defined
22:04:38 <oerjan> (at infinity)
22:04:48 <oklopol> >+++++>++++>++++<<[-[>]<-[<]>] for example would be undefined
22:05:01 <oklopol> nah, maybe not
22:05:25 <oklopol> ah
22:05:30 <oklopol> it makes sence actually
22:05:55 <oklopol> it's the same as in BF
22:05:59 -!- sebbu has quit (Read error: 110 (Connection timed out)).
22:06:14 <lament> weird stuff.
22:06:32 <oklopol> all i added to bf was this differentials thing, ; and :, you can figure what they are
22:07:15 <oklopol> i actually thought making () a separate differentiation loop where constraints lie
22:07:18 <oerjan> Oh, I thought they were just decoration :)
22:07:25 <oklopol> and [] normal
22:07:27 <oklopol> no, addition
22:07:34 <oklopol> ,.;:
22:07:34 <oklopol> io
22:08:09 <oerjan> that's pretty logical notation for floating point IO
22:08:18 <oklopol> yes
22:08:27 <oklopol> obvious, tho
22:08:35 <oerjan> almost like Ocaml
22:08:47 <oklopol> fuck you with your names i don't know :(((((
22:08:51 <oklopol> wuzzit?
22:09:31 <oerjan> Ocaml is a functional language with object extensions. ML dialect.
22:10:17 <oklopol> okay
22:10:21 <oerjan> The point of my comment is that Ocaml uses +. etc. to mean floating point addition etc.
22:10:23 <oklopol> ; and : are like it? :D
22:10:31 <oklopol> ooo
22:10:45 <oerjan> Because it doesn't have arithmetic overloading.
22:10:48 <oklopol> yeah
22:10:53 <oklopol> guttit
22:11:51 <oklopol> but, i don't care whether it's touring complete, i can easily translate a calculation on it
22:12:01 <GregorR> oklopol: Gut tit?
22:12:08 <oklopol> yeah
22:12:09 <oklopol> sure
22:12:18 <GregorR> I don't even want to think about what that's supposed to mean O_O
22:12:24 <oklopol> got it
22:12:36 -!- Sgeo has joined.
22:13:20 <oklopol> now... now.... ()?
22:13:24 <oklopol> needed? is?
22:14:15 <oerjan> You can emulate ordinary [] I think
22:14:29 <oklopol> hmmmmmm
22:14:39 <oerjan> Or rather, ordinary +-
22:14:57 <oklopol> i don't know if the implicity will work everywhere
22:15:04 <oerjan> By having a cell with a fixed value.
22:15:16 <oklopol> yeah, i thought of that
22:16:30 <oklopol> 1 could assign a 1 in the current cell, that was one thing i thought... another were ^ and v, ^ would convert a differential into it's counterpart number, v the other way xD
22:16:42 <oklopol> counterpart number...
22:17:36 <oerjan> I don't think any of those are strictly needed though.
22:18:56 <oklopol> maybe not, i just think the fact that (3 here)[->[SMTH]<] will execute SMTH infinity times will in some cases make it hard for the interpreter to know what to do, actually
22:18:56 <oerjan> If you keep one cell with a known value you can convert everything with a little copying.
22:19:07 <oklopol> yes, true
22:19:44 <oklopol> but i liked the idea of using only one kind of numbers
22:19:57 <oklopol> everything being used as a differential when needed
22:20:10 <oklopol> but that requires the <>-limit i'm afraid
22:20:18 <oerjan> Well no matter what you do some limits will fail to exist
22:20:33 <oklopol> liek?
22:21:18 <oerjan> [>+<]
22:21:39 <oklopol> mem: 0 INF
22:22:07 <oklopol> 0 on this level, 1 on the other, infinity steps done -> 0 INF
22:22:15 <oklopol> not 0
22:22:18 <oklopol> but what there was
22:22:37 <oerjan> You will get inconsistencies.
22:23:21 <oklopol> +[>+<] (1 INF) >[->+++++<] (INF 0)
22:23:26 <oklopol> i can't see them
22:23:51 <oerjan> What happens with [>+<]>+<[>-<]
22:23:58 <oklopol> i'm just running the algorithm in my head, crash it and i see the inconsistencies
22:24:09 <oklopol> nothing
22:24:13 <oklopol> 0 1
22:24:17 <oklopol> if there is stuff tho
22:24:22 <oklopol> in the beginning
22:24:23 <oklopol> then
22:24:53 <oklopol> [>+<] (0 INF) >+< (0 INF) [>-<] (0 0)
22:25:23 <oklopol> replace 0 with your var
22:25:33 <oklopol> that's what it'd've done
22:25:45 <oklopol> you can, indeed, call that an inconsistency :)
22:26:02 <oklopol> but, it could be made crash
22:26:15 <oklopol> or infinite loop
22:27:02 <bsmntbombdood> I was working on brainfuck -> logfuck conversions in math today
22:27:16 <oklopol> did it work?
22:27:23 <bsmntbombdood> dunno
22:27:37 <bsmntbombdood> well, i got conversions for everything, but i haven't tested them
22:27:41 <bsmntbombdood> I'll type em up
22:27:43 <oklopol> ya
22:29:07 <bsmntbombdood> http://pastebin.ca/321969
22:30:20 <oklopol> ,
22:30:40 <oklopol> ah
22:30:57 <bsmntbombdood> because , replaces the top
22:31:00 <oklopol> sorry, i'm once again mixing the new standard with the old one :)
22:32:03 <oklopol> don't think > and < are correct tho
22:32:10 <bsmntbombdood> look good?
22:32:11 <oklopol> well, actualyl
22:32:13 <oklopol> yeah
22:32:22 <oklopol> they are the same, yeah
22:32:36 <oklopol> oh
22:33:05 <oklopol> yeah
22:33:07 <oklopol> xD
22:33:25 <oklopol> i had to think it over a few times
22:33:44 <oklopol> well, if you have an interpreter for the latest standard, try em
22:33:51 <bsmntbombdood> I will
22:34:51 <oklopol> i'm pretty sure a quine qouldn't work!
22:38:34 <bsmntbombdood> what's some brainfuck to test?
22:38:54 <oklopol> eh
22:39:01 <oklopol> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-.
22:39:15 <bsmntbombdood> ...that won't be a good test
22:39:28 <oklopol> ++++++++[->++++++++<]>.?
22:39:36 <oklopol> ++++++++[->++++++++<]>+.
22:39:41 <bsmntbombdood> i'll just do hello world
22:39:44 <oklopol> that would be a test
22:39:47 <oklopol> yeah
22:39:48 <oklopol> same thing
22:40:01 <bsmntbombdood> 1g1--1g1--1g1--1g1--1g1--1g1--1g1--1g1--1g1--1g1--[<1g1--1g1--1g1--1g1--1g1--1g1--1g1--<1g1--1g1--1g1--1g1--1g1--1g1--1g1--1g1--1g1--1g1--<1g1--1g1--1g1--<1g1-->>>>1-d]<1g1--1g1--d.<1g1--d.1g1--1g1--1g1--1g1--1g1--1g1--1g1--d.d.1g1--1g1--1g1--d.<1g1--1g1--d.>>1g1--1g1--1g1--1g1--1g1--1g1--1g1--1g1--1g1--1g1--1g1--1g1--1g1--1g1--1g1--d.<d.1g1--1g1--1g1--d.1-1-1-1-1-1-d.1-1-1-1-1-1-1-1-d.<1g1--d.<d.
22:40:13 <bsmntbombdood> is the code I get
22:40:17 <oklopol> runnit
22:40:36 <bsmntbombdood> shit
22:40:41 <oklopol> :D
22:40:50 <bsmntbombdood> it prints ":QXX[I[^X"
22:40:53 <oklopol> ++++++++[->++++++++<]>+.
22:40:55 <oklopol> try that
22:41:22 <bsmntbombdood> 1
22:41:27 <oklopol> ?
22:41:34 <bsmntbombdood> it prints "1"
22:41:38 <oklopol> i know your problem
22:41:45 <oklopol> your's prints numbers? btw
22:41:59 <bsmntbombdood> no, it prints ascii
22:42:19 <oklopol> if a cell is empty, bf assumes it 0
22:42:26 <bsmntbombdood> mine does too
22:42:26 <oklopol> yours doesn't have it
22:42:28 <oklopol> oh
22:42:57 <oklopol> i thought a - would use the underlying number if there was one and only making a new one when the stack is empty
22:43:08 <oklopol> *make
22:44:32 <oklopol> [<1g1-- this here will use the number in the last cell, right?
22:44:46 <bsmntbombdood> huh?
22:44:55 <oklopol> hey
22:44:56 <oklopol> yeah
22:44:59 <oklopol> it would
22:45:00 <oklopol> not
22:45:46 <oklopol> +[->+<]>.
22:45:48 <oklopol> try that
22:46:31 <bsmntbombdood> What's it supposed to do?
22:46:35 <oklopol> print a 1
22:46:40 <bsmntbombdood> nope
22:46:44 <bsmntbombdood> it hangs forever
22:46:45 <oklopol> put numeric io on
22:46:48 <oklopol> a-ha
22:46:52 <oklopol> show the code
22:47:09 <bsmntbombdood> 1g1--[1-<1g1-->d]<d.
22:48:03 <bsmntbombdood> it's non-wrapping
22:48:14 <oklopol> it should work imo
22:48:21 <bsmntbombdood> no
22:48:29 <bsmntbombdood> yes
22:49:22 <oklopol> hmm
22:49:23 <oklopol> okay
22:49:34 <oklopol> what does < do if the rightmost stack is empty?
22:49:38 <bsmntbombdood> 0
22:49:43 <oklopol> good
22:51:19 <bsmntbombdood> argh
22:51:20 <bsmntbombdood> bug
22:51:24 <oklopol> 1g1-- (put one on stack) [1- (subtract one... at zero now) < (push a zero, stack now [0 0]) 1g1-- (add one, stack now [0 1]) > (stacks: 1:[0] 2:[1]) d ([0, 0] [1], so end loop sith [0] [1]) ] < (stack now [0 1]) d. (print topmost... 1)
22:51:34 <oklopol> point me where it goes wrong
22:51:40 <bsmntbombdood> bug in interpreter
22:51:40 <oklopol> ....and win a cookie!
22:51:44 <oklopol> i knwo
22:52:25 <oklopol> more like, i knew it!
22:53:42 <oklopol> if not secondary:
22:53:43 <oklopol>                 secondary.append(0.)
22:53:43 <oklopol>             primary.append(secondary.pop())
22:53:49 <oklopol> the bug was the no else?
22:53:56 <bsmntbombdood> no
22:53:58 <oklopol> okay
22:54:03 <bsmntbombdood> in the '-' code
22:54:31 <oklopol> yeah
22:54:40 <oklopol> i should've read that :)
22:54:51 <bsmntbombdood> I need to write a stack object
22:54:53 <oklopol> pop returns none and you can append that?
22:54:56 <oklopol> you don't
22:55:18 <oklopol> you could, but since that is already done, no use
22:55:26 <oklopol> that as in that interpreter
22:55:47 <oklopol> the function is easily fixed
22:56:09 <oklopol> well yeah, stack might be easier
22:57:36 <oklopol> class stack:
22:57:36 <oklopol>    def __init__(self):
22:57:36 <oklopol>       id=[]
22:57:36 <oklopol>    def push(a):
22:57:36 <oklopol>       id.append(a)
22:57:37 <oklopol>    def pop(a):
22:57:39 <oklopol>       if id:
22:57:41 <oklopol>          return id.pop()
22:57:43 <oklopol>       else:
22:57:45 <oklopol>          return 0
22:57:56 <oklopol> 27 seconds
22:58:11 <oklopol> i'm getting godd it seems
22:58:12 <oklopol> :\
22:58:21 <oklopol> ah
22:58:24 <oklopol> min 27 secs
22:58:33 <oklopol> then it makes more sence :)
22:59:07 <oklopol> since i had a moment of thought on [] or recursion but then remembered [] is a list :D
23:01:05 <bsmntbombdood> yes!
23:01:08 <bsmntbombdood> it works!
23:01:32 <bsmntbombdood> :D
23:01:43 <oklopol> the progz?
23:01:51 <bsmntbombdood> hello world
23:01:55 <oklopol> good
23:02:56 <oklopol> for a brainfuck interpreter, a hello world usually find all bugs
23:03:23 <bsmntbombdood> I hope so
23:03:50 <oklopol> well, now it's brainfuck with multiplication and addition :)
23:04:02 <oklopol> actually all basic arithmetic
23:04:02 <bsmntbombdood> yep
23:04:14 <bsmntbombdood> more complex math is loads easier too
23:04:20 <oklopol> i can do sqrt
23:04:26 <bsmntbombdood> 3 extra instructions though :(
23:04:27 <oklopol> if you can wait
23:04:30 <oklopol> yeah :(
23:05:15 <bsmntbombdood> sqrt is >1 11g1-- >g<g - p<g >g<g >1g<-- p p
23:05:38 <bsmntbombdood> or >1 TWO DIV<g MULT p
23:06:28 <oklopol> ah you can just simulate it with logs
23:07:04 <bsmntbombdood> what do you mean, simulate it?
23:07:10 <bsmntbombdood> There's no simulation
23:07:13 <oklopol> i mean, calculate :)
23:07:18 <bsmntbombdood> yeah
23:07:22 <bsmntbombdood> great, eh?
23:07:54 <oklopol> it's pretty cool 
23:08:07 <oklopol> i needed your macros to see it tho :(
23:12:49 <bsmntbombdood> I need my macros to write it
23:14:11 <oklopol> yeah, but i'm very sensitive about my human weaknesses
23:14:31 <oklopol> the 1 is the input tho?
23:14:40 <bsmntbombdood> no
23:14:45 <bsmntbombdood> the 1 is to get .5
23:14:52 <oklopol> yeah
23:14:57 <oklopol> goddamned
23:15:45 <oklopol> i misunderstood it a little
23:16:33 <oklopol> since i just glanced at it and realized base^(log(a)*log(b))=a^b
23:17:57 <oklopol> i should have someone here whack me in the head if i start just staring at the screen idle :)
23:19:25 <bsmntbombdood> haha awesome
23:19:44 <bsmntbombdood> I came up with an algorithm to generate an arbitrary number on the stack
23:20:08 <bsmntbombdood> http://pastebin.ca/322010
23:21:46 <bsmntbombdood> works for floating point too
23:22:26 <oklopol> nice
23:24:23 <bsmntbombdood> now it's the output is smaller: http://pastebin.ca/322014
23:24:50 <oklopol> okay, now i figured it
23:24:58 <oklopol> i'm slow :\
23:25:35 <bsmntbombdood> figured what?
23:25:56 <oklopol> i mean, took me 5 minutes to get the function fully :\
23:26:09 <bsmntbombdood> the gen_number function?
23:26:12 <oklopol> yeah
23:28:05 <bsmntbombdood> I'm  not sure how it works with floating point numbers
23:29:13 <bsmntbombdood> It does though
23:31:45 <bsmntbombdood> Might be able to make it more efficient by using multilication too
23:31:48 -!- jix__ has joined.
23:33:11 <oklopol> hmm
23:33:23 <oklopol> log(the float) returns a negative number
23:33:27 <oklopol> which can be created
23:33:36 <oklopol> and... it is normally added and exp'd
23:34:15 <bsmntbombdood> hmm
23:36:23 <bsmntbombdood> well, I think that's a very elegant algorithm
23:36:54 <oklopol> yes, have nothing to add :\
23:36:59 <oklopol> perfect.
23:37:01 <oklopol> :D
23:38:26 <oklopol> as long as the numbers are of finite length in the base system, that is fast
23:38:50 <oklopol> if you'd've used 3-base in your language, that would cause infinite loops
23:38:59 <bsmntbombdood> ?
23:39:42 <oklopol> because number-base**int(log(number)) would never be zero
23:40:02 <oklopol> since there would be an infinite series of numbers as the decimal tail
23:42:09 <bsmntbombdood> ah ha!
23:42:15 <bsmntbombdood> I made it more effiecient
23:42:21 <oklopol> show!
23:42:35 <bsmntbombdood> s/math.floor/round/
23:42:53 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
23:43:01 <oklopol> that's not an algorithmical improvement :)
23:43:04 <bsmntbombdood> is what I did
23:43:15 <oklopol> *-al
23:43:23 <bsmntbombdood> well, it makes numbers like 2**16-1 a lot shorter
23:43:34 <oklopol> ah 
23:43:39 <oklopol> it is, true
23:43:52 <oklopol> not much tho
23:43:59 <bsmntbombdood> yes much
23:44:32 <oklopol> not much, 2**16*0.75 would be almost as inefficient then
23:45:01 <bsmntbombdood> before: 336 chars, after: 24
23:45:17 <oklopol> okay :)
23:45:32 <bsmntbombdood> 2**16*0.75 is 34 chars
23:45:44 <oklopol> and used to be?
23:45:52 <bsmntbombdood> one sec
23:46:03 <oklopol> actually
23:46:10 <oklopol> should be about the same
23:46:12 <oklopol> i think
23:46:24 <bsmntbombdood> used to be 69 chars
23:46:45 <oklopol> well, nice improvement then :D
23:47:15 <bsmntbombdood> whoa
23:47:31 <bsmntbombdood> .1 is 1435 chars
23:47:41 <oklopol> well, given
23:48:08 <bsmntbombdood> I think I have an idea
23:48:09 <oklopol> it's 2-base presentation is more than 30 bits
23:49:18 <bsmntbombdood> How do we convert a floating point number into a fraction?
23:50:52 <oklopol> hmm
23:50:57 <oklopol> you mean
23:50:58 <oklopol> like
23:51:36 <oklopol> wtf i can't find the word :\
23:51:41 <bsmntbombdood> I want f(.2) => (1,5)
23:51:50 <oklopol> oh
23:52:04 <bsmntbombdood> ei 1/5 == .2
23:52:27 <oklopol> (floor(number), 1/(number-floor(number)))
23:52:39 <oklopol> ?
23:52:54 <bsmntbombdood> nope
23:53:18 <oklopol> then what do you mean? :D
23:53:50 <bsmntbombdood> the gives (0.0, 5.0) for .2
23:54:10 <oklopol> yeah, i don't know what you meant by (1,5) :)
23:57:16 <bsmntbombdood> yes!!
23:57:29 <bsmntbombdood> .1 is now 31 chars!
23:57:38 <oklopol> what did you do?
23:58:12 -!- CakeProphet has joined.
23:58:29 <bsmntbombdood> http://pastebin.ca/322047
23:59:10 <bsmntbombdood> erm, crap
23:59:12 <bsmntbombdood> buggy
23:59:43 <bsmntbombdood> yeah, doesn't work for numbers > 1

2007-01-20:

00:00:28 <oklopol> why the +1?
00:00:41 <bsmntbombdood> because
00:02:57 <oklopol> 1/5 == .2 becomes 1 + .2 then :\
00:03:02 <oklopol> or?
00:03:09 <oklopol> ah
00:03:12 <oklopol> dam
00:03:13 <oklopol> n
00:04:25 <oklopol> you could factor the number and 1/(number-floor(number)) to their prime elements
00:04:28 <oklopol> then create those
00:04:31 <bsmntbombdood> one sec
00:04:34 <oklopol> and multiply and divide
00:04:36 <oklopol> or smth
00:04:36 <bsmntbombdood> I found an algo to do it
00:04:39 <oklopol> oaky
00:08:42 <bsmntbombdood> ok
00:09:16 <oklopol> show!
00:09:25 <bsmntbombdood> http://pastebin.ca/322056
00:09:42 <bsmntbombdood> .1 takes 31 chars
00:10:05 <CakeProphet> Homespring looks awesome.
00:10:12 <oklopol> farey does what?
00:10:22 <oklopol> or, is it understandable?
00:10:26 <bsmntbombdood> converts a float into a fraction
00:10:31 <bsmntbombdood> I didn't write it
00:10:58 <oklopol> that's why i assumed i wouldn't be able to read it 
00:10:59 <oklopol> fast
00:11:17 <oklopol> in form a/b?
00:11:31 <bsmntbombdood> farey(.2) => (1,5)
00:11:37 <oklopol> yeah
00:11:43 <oklopol> farey(1.2)?
00:11:55 <oklopol> ah
00:12:10 <oklopol> why did i not understand that last time :\
00:12:24 <CakeProphet> hmmm... BF works pretty damn well with threads.
00:12:33 <oklopol> i hope it's this headache... or then i'm getting stupider
00:12:40 <oklopol> CakeProphet, what you did?
00:12:45 <CakeProphet> the low-leveliness makes it a perfect candidate.
00:12:47 <CakeProphet> yeah.
00:13:00 <bsmntbombdood> now it is WAAAAAAY better with non integers
00:16:13 <oklopol> CakeProphet, what did you do?
00:18:16 <bsmntbombdood> ok, this algorithm is good now
00:20:05 <bsmntbombdood> ...except farey is very slow
00:20:35 <oklopol> hmm i'd read it but my brain is dead
00:20:42 <oklopol> the farey
00:22:02 <CakeProphet> threaded BF...
00:22:11 <CakeProphet> read [[Weave]]
00:22:14 <bsmntbombdood> heh, pi is 740 chars
00:27:35 <oklopol> link it again
00:27:40 <oklopol> CakeProphet
00:31:02 <CakeProphet> http://esolangs.org/wiki/Weave
00:31:29 <bsmntbombdood> brainfork
00:38:41 <oklopol> there are no examples :)
00:38:46 <oklopol> i've seen that
00:38:58 <oklopol> bsmntbombdood, that is a simplification of it :)
00:39:43 <CakeProphet> hmmm
00:39:49 <CakeProphet> didn't know there was a brainfork.
00:39:53 <CakeProphet> it looks kind of silly though.
00:40:00 <CakeProphet> I like Weave much better.  :D
00:40:54 <CakeProphet> Weave is intended to execute as if you had literally just started running a bunch of BF programs at the same time at the very start... 
00:41:04 <CakeProphet> with a single array shared amongst them as well as their own private ones.
00:41:43 <oklopol> brainfork is ingenious, one of my favorites
00:42:06 <oklopol> forking is so nice
00:42:25 <oklopol> but, weave might be useful
00:43:00 <CakeProphet> well...
00:43:17 <CakeProphet> it's sort of like... programming a bunch of little minions
00:45:45 <CakeProphet> Brainfork doesn't have a mechanism for data sharing.
00:49:36 <oklopol> it does
00:49:44 <oklopol> it has only data sharing
00:51:26 <CakeProphet> ah
00:51:36 <oklopol> the specs are bad
00:52:19 <CakeProphet> hmmm... brainfuck would be really easy to hide in other documents.
00:52:30 <CakeProphet> because everything-else-is-comments
00:52:40 <oklopol> yeah
00:52:59 <oklopol> you can get better ways tho...
00:54:22 <CakeProphet> you could hide whitespace in the whitespace on the edges of a document.
00:59:01 <bsmntbombdood> ok, the brainfuck->logfuck conversions don't work for input
01:05:00 <oklopol> true
01:05:07 <oklopol> but not that big a problem
01:05:38 <oklopol> CakeProphet, i can think of a million ways to hide for example bf in a document...
01:23:46 -!- ihope has joined.
01:24:33 <bsmntbombdood> What's wrong with the input?
01:24:55 <ihope> You typed it wrong.
01:25:02 <bsmntbombdood> ?
01:25:51 <ihope> If there's something wrong with the input, you typed it wrong.
01:26:04 <ihope> The problem may be fixed by typing it correctly.
01:26:30 <bsmntbombdood> no
01:26:41 <bsmntbombdood> converting logfuck to brainfuck
01:28:02 -!- sebbu2 has quit ("@+").
01:31:35 <bsmntbombdood> I like my number generation algorithm :)
02:15:15 -!- ihope has quit (Read error: 110 (Connection timed out)).
03:31:07 -!- anonfunc has quit (Read error: 104 (Connection reset by peer)).
03:32:41 -!- anonfunc has joined.
03:56:28 -!- oerjan has quit ("Destiny").
03:57:07 <bsmntbombdood> hmph
03:57:17 <bsmntbombdood> you lispers should tell me a better way to do this:
03:57:26 <bsmntbombdood> (defun inp (what where &key (test #'equal))
03:57:26 <bsmntbombdood>    "is what in where according to test?"
03:57:26 <bsmntbombdood>    (reduce (lambda (x y) (or x y)) (mapcar (lambda (x) (funcall test x what)) where)))
04:47:38 -!- pikhq has joined.
05:15:48 -!- Sgeo has quit (Remote closed the connection).
05:17:33 <CakeProphet> what's the purpose of funcall?
05:17:52 <CakeProphet> why can't you just put the function variable at the front of the list and expect the normal evaluation?
05:49:22 <bsmntbombdood> CakeProphet: Because common lisp is fucking stupid
05:50:37 <bsmntbombdood> each symbol has a different slot for its function and its variable
05:50:49 <bsmntbombdood> in that case, the variable slot has a function in it
06:05:34 <CakeProphet> the variable is a function though
06:05:58 <bsmntbombdood> The regular syntax only works if the function slot has the function
06:06:33 <CakeProphet> that's pretty stupid.
06:07:38 <bsmntbombdood> indeed
06:18:02 <bsmntbombdood> scheme isn't like that iirc
06:47:34 -!- pikhq has quit ("leaving").
07:58:42 -!- sebbu has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
10:01:54 -!- wooby has joined.
10:01:59 -!- wooby has quit (Remote closed the connection).
11:39:47 -!- oerjan has joined.
12:15:19 -!- anonfunc has quit.
12:35:35 -!- oerjan has quit ("Desire").
13:14:58 -!- NK` has quit (Remote closed the connection).
13:15:01 -!- NK` has joined.
13:44:07 -!- jix__ has joined.
13:45:24 -!- jix__ has changed nick to jix.
14:05:15 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
14:09:43 -!- jix__ has joined.
16:03:09 -!- helios24 has quit (Read error: 113 (No route to host)).
16:28:02 -!- Sgeo has joined.
16:37:53 -!- pikhq has joined.
17:04:47 -!- ihope has joined.
17:51:02 -!- CakeProphet has quit ("haaaaaaaaaa").
19:10:08 -!- lament has quit (Remote closed the connection).
19:10:17 -!- lament has joined.
19:16:11 -!- lament_ has joined.
19:16:39 -!- lament has quit (Remote closed the connection).
19:26:29 -!- lament has joined.
19:27:01 -!- lament_ has quit (Remote closed the connection).
19:31:50 -!- lament has quit (Remote closed the connection).
19:31:52 -!- lament has joined.
19:35:49 -!- jix__ has changed nick to jix.
19:38:13 -!- lament has quit (Remote closed the connection).
19:38:30 -!- lament has joined.
19:44:45 -!- lament_ has joined.
19:45:39 -!- lament has quit (Remote closed the connection).
19:49:57 -!- lament_ has quit (Remote closed the connection).
19:50:01 -!- lament has joined.
20:55:54 -!- lament has quit (Remote closed the connection).
20:55:59 -!- lament has joined.
21:03:09 -!- lament has quit (Remote closed the connection).
21:03:14 -!- lament has joined.
21:09:42 -!- lament_ has joined.
21:11:23 -!- lament has quit (Read error: 104 (Connection reset by peer)).
21:31:14 -!- oklopol has quit.
21:58:21 -!- oklopol has joined.
22:30:05 * SimonRC goes.
22:30:58 * bsmntbombdood arrives
22:54:30 -!- oklofok has joined.
22:54:30 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
23:01:12 -!- oklofok has quit (Read error: 104 (Connection reset by peer)).
23:01:18 -!- oklopol has joined.
23:32:21 -!- CakeProphet has joined.
23:49:39 -!- sebbu2 has joined.

2007-01-21:

00:08:06 -!- sebbu has quit (Read error: 110 (Connection timed out)).
00:08:15 * pikhq just had a really stupid idea. . .
00:08:33 <pikhq> Make a BF->C compiler which outputs C code which is also valid BF code.
00:09:14 -!- sebbu2 has quit ("Leaving").
00:09:43 <oklopol> well, that's a more amphibious version of me thinking of making A program that is both C and BF
00:09:50 <oklopol> tho, pretty easy
00:09:56 <pikhq> Indeed it is.
00:09:57 <oklopol> *amphibious xD
00:10:05 <oklopol> no, not a correction
00:10:07 <pikhq> An example method:
00:10:10 <oklopol> ambitious
00:10:14 <pikhq> p++; // -
00:10:17 <pikhq> == +
00:10:22 <pikhq> p--; // +
00:10:23 <pikhq> == -
00:10:29 <pikhq> while { // [
00:10:31 <pikhq> == [
00:10:34 <pikhq> } // ]
00:10:36 <pikhq> == ]
00:10:39 <pikhq> etc.
00:10:54 <oklopol> well, yeah
00:10:59 <pikhq> Easy.
00:11:11 <oklopol> includes have even <>'s
00:11:14 <oklopol> that's nice
00:11:17 <oklopol> :)
00:11:25 <oklopol> *even even
00:12:38 <oklopol> of course, that way it's easier than making one program that is sensible c++ code and the same in brainfuck without comments
00:12:49 <oklopol> sensible as in not clearly brainfuck
00:12:58 <oklopol> of course need a lot of redundance
00:19:28 <oklopol> without comments p++-1; p--+1;
00:19:52 <oklopol> [ and ] are hard tho
00:20:19 <oklopol> well, you can have 1[...] and have code normally in it, separated by commas
00:20:38 <oklopol> so, it's pretty trivial actually
00:22:39 <oklopol> commas are an operator tho, which i realized in the bathroom
00:22:41 <pikhq> Got it done.
00:23:01 <oklopol> so you have to do '[',']' or something everywhere
00:23:04 <pikhq> So take advantage of that. . . :p
00:23:05 <oklopol> cool
00:23:16 <pikhq> Want me to upload the script?
00:23:16 <oklopol> whaaaat?
00:23:25 <oklopol> you can
00:23:28 <oklopol> do
00:23:28 <oklopol> please
00:25:01 <pikhq> http://pikhq.nonlogic.org/bf.tcl
00:25:16 <pikhq> Not very complex, but not bad for a quick hack.
00:27:09 <oklopol> me read
00:27:27 <pikhq> Hell. . . I released a different way of doing it.
00:27:31 <pikhq> Define some macros.
00:27:40 <pikhq> +();-();>();, etc.
00:28:03 <oklopol> what lang?
00:28:21 <oklopol> the script?
00:28:21 <pikhq> Um. . . C?
00:28:23 <pikhq> Oh.
00:28:24 <pikhq> Tcl.
00:29:05 <oklopol> < {
00:29:05 <oklopol>     puts "p-=1; // +<"
00:29:05 <oklopol> }
00:29:11 <oklopol> p+=-1;
00:29:13 <oklopol> :P
00:29:54 <oklopol> p+=+(-1); // <- and you can have the nice arrow
00:30:19 <pikhq> Hahah.
00:30:38 <oklopol> i don't think this is a C script
00:31:36 <oklopol> it gets fairly complicated with no comments
00:31:43 <oklopol> unless you do constants
00:31:44 <pikhq> It compiled to C.
00:31:48 <pikhq> And is written in Tcl.
00:31:49 <oklopol> then it's trivial again
00:31:52 <oklopol> ah
00:31:55 <oklopol> i don't know tcl
00:32:05 <oklopol> i mean, i can read it of course
00:32:18 <oklopol> but i've never seen it before
00:32:24 <oklopol> i've heard the name tho
00:33:24 <oklopol> while ('['&&*p) {
00:33:33 <oklopol> ']';}
00:33:40 <oklopol> :P
00:34:34 <oklopol> (p++)>--0;
00:34:38 <oklopol> (p--)>++0;
00:35:01 <oklopol> convert those, much nicer
00:35:02 <oklopol> :)
00:35:37 <oklopol> (p--)<++0; of course
00:36:04 <pikhq> Me like.
00:36:38 <oklopol> putchar((*p)*1.0);
00:36:59 <oklopol> *p=getchar(),*p*=!feof(stdin);
00:37:08 <pikhq> Except for one thing. . .
00:37:09 <oklopol> no comments yay
00:37:13 <oklopol> what is that?
00:37:14 <pikhq> (p++)>--0;
00:37:18 <oklopol> <
00:37:23 <oklopol> (p--)<++0; of course
00:37:24 <pikhq> That adds two, moves right, then subtract two.
00:37:25 <oklopol> oh
00:37:34 <oklopol> fuck
00:37:35 <oklopol> true
00:37:38 <oklopol> sorry
00:37:54 <oklopol> --(p++)>0;
00:38:01 <oklopol> ++(p--)<0;
00:38:08 <oklopol> now it should work
00:38:10 <pikhq> That's equivalent to "" from a C perspective, I believe.
00:38:24 <oklopol> ?
00:38:36 <pikhq> ++(--p)==p
00:38:47 <pikhq> I'm pretty certain, that is.
00:39:02 <oklopol> what do you mean?
00:39:14 <pikhq> (p++)|(--0)>0;
00:39:17 <pikhq> That's my solution.
00:39:21 <oklopol> you might need +(+(p--)<0);
00:39:29 <oklopol> --0 won't work
00:39:32 <oklopol> -(-0)
00:39:33 <pikhq> What I'm saying is that that performs the ++ operator, then the -- operator.
00:39:43 <oklopol> no
00:39:45 <pikhq> Mmkay.
00:39:47 <oklopol> oh
00:40:05 <oklopol> well, yes, but i meant it with the parenthesis, forgot to actually put them
00:40:13 <pikhq> It's like (p-=1)+=1;
00:40:15 <oklopol> or just + + p-- == 0;
00:40:32 <oklopol> yeah, a million possibilities
00:40:41 <oklopol> you can put many in, to be selected a t random
00:40:42 <oklopol> *at
00:41:25 <pikhq> That'd be a bit of a trickier thing, and I'm lazy.
00:41:36 <oklopol> i like *p=getchar(),*p*=!feof(stdin); most
00:41:42 <oklopol> :)
00:41:56 <oklopol> because the , is actually used
00:42:47 <oklopol> *p+=1 uses the bf-operator more tho
00:44:05 <oklopol> i'll learn lisp now, bye ->
00:45:08 <pikhq> Your . interpretation doesn't work. . .
00:45:09 <pikhq> Hmm.
00:46:36 <pikhq> I added int a;float b;
00:46:40 <pikhq> And
00:46:51 <pikhq> a=putchar(*p),b=1.0;
00:47:23 <pikhq> And now it's complaining about the unary minus thing.
00:50:17 <pikhq> basm.0.b.c:4458: error: wrong type argument to unary minus
00:50:37 <oklopol> where
00:51:03 <oklopol> putchar(int((*p)*1.0)); just do
00:51:20 <oklopol> swap c++ and english
00:51:58 <oklopol> where does it complain about an unary minus?
00:53:12 <oklopol> a*
00:53:17 <oklopol> *a unary
00:53:27 <pikhq> +(+(p--)<0);
00:55:26 <oklopol> complains about that?
00:55:51 <oklopol> i can't see a unary minus
00:56:22 <pikhq> -(-(p++)>0); as well.
00:57:29 <oklopol> well, try converting the bool to an int
00:58:06 <pikhq> In C, there is no such thing as a "bool". . . "0" is an int.
00:58:15 <oklopol> ah
00:58:16 <pikhq> It doesn't complain about -0-0;
00:58:22 <pikhq> It's complaining about the pointer./
00:58:23 <oklopol> sorry
00:58:31 <oklopol> char* doesn't support unary minus of course
00:58:40 <oklopol> sorry about the
00:58:41 <oklopol> *that
00:58:47 <oklopol> -(-int(p++)>0);
00:58:52 <oklopol> for example
00:59:46 <CakeProphet> negative pointers are like lol
01:00:17 <oklopol> i don't like it when non-rational things are not supported
01:00:38 <oklopol> no matter how much it helps newbies :\
01:00:45 <pikhq> Got a working version.
01:00:51 <oklopol> me too
01:00:57 <oklopol> -(-int(p++)>0);
01:01:07 <oklopol> what did you do?
01:01:20 <pikhq> -(-(int(p++)<0);
01:01:23 <pikhq> Err.
01:01:26 <pikhq> -(-(int)(p++)<0);
01:01:46 <oklopol> c doesn't have int(...)$?
01:01:49 <oklopol> -$
01:02:06 <CakeProphet> oklopol,  yeah... all the weird stuff should be allowed for the sake of being there to tinker with.
01:02:32 <pikhq> It's not a function.
01:02:36 <pikhq> (int)foo
01:02:44 <pikhq> is the way to cast "foo" to an integer.
01:03:00 <fizzie> C++ would accept int(foo), too.
01:03:13 <CakeProphet> int(...) is a C++-ism I believe.
01:03:17 <pikhq> Probably.
01:03:39 <oklopol> yeah, i've read that somewhere actually, didn't remember :\
01:03:45 <CakeProphet> (int) foo   is even referred to as c-like type declaration in C++-lingo
01:03:47 <pikhq> http://pikhq.nonlogic.org/bf.tcl
01:03:59 <pikhq> Polyglot BF->C compiler.
01:04:05 <fizzie> Isn't that a "c-style cast"? 
01:04:09 <pikhq> Now with thanks to oklopol.
01:04:18 <CakeProphet> sure
01:04:29 <oklopol> puts "putchar(*p*(1.0));"
01:04:36 <oklopol> convert to int maybe?
01:04:41 <oklopol> or?
01:04:49 <oklopol> it might do that with putchar actually :)
01:05:15 <pikhq> puts "putchar(*p*(1.0));"
01:05:17 <pikhq> That works.
01:05:32 <pikhq> It probably casts to char automagically.
01:05:33 <oklopol> yeah, you said something about it not working, but maybe you didn't
01:05:39 <pikhq> I thought it didn't work.
01:05:56 <oklopol> yeah, would be weird id they'd've added a float version to get it not working for floats
01:05:56 <pikhq> But there were a lot of errors. . . And I apparently did something stupid in saying that.
01:06:14 <oklopol> good you said it, i don't like it when i imagine things
01:06:23 <oklopol> happens often :\
01:08:15 <fizzie> "(int)foo" is called "the cast notation" in the C++ standard (5.4), while "int(foo)" is simply "explicit type conversion (functional notation)" (5.2.3).
01:08:36 <oklopol> N +'s of brainfuck -> *p+={(N-1)*"+ "}1;
01:08:53 <oklopol> where {(N-1)*"+ "} of course means "+ " N-1 times
01:09:19 <pikhq> 'cept that instead of "one" it'd be "N".
01:09:32 <oklopol> ...?
01:09:55 <oklopol> yeah
01:10:36 <oklopol> same with minus of course
01:10:36 <fizzie> Why  putchar(*p*(1.0));  and not the much simpler (and lacking the silly float conversion)  putchar((1.0, *p)); ?
01:10:41 <pikhq> Right.
01:10:51 <fizzie> Oh, the comma.
01:11:08 <oklopol> fizzie, it doesn't really matter, one can easily come up with tons of those :\
01:11:10 <fizzie> I only now realized what you were trying to do, anyway.
01:11:20 <oklopol> and that
01:13:31 <oklopol> N >'s -> puts "-(int)(p+=N){>0 N times};"
01:13:43 <oklopol> but, of course you can't do it in the puts
01:13:56 <pikhq> I can do something different. . .
01:14:02 <oklopol> k
01:14:13 <oklopol> what is that?
01:14:21 <pikhq> set string "-(int)(p+=$n)"
01:14:57 <pikhq> for {} {$n != 0} {incr n -1} {append string ">0"}
01:15:03 <pikhq> puts "$string;"
01:15:03 <oklopol> yeah
01:15:48 <CakeProphet> so... language advocacy is really starting to annoy me.
01:15:59 <CakeProphet> and it's practically everywhere...
01:16:04 <CakeProphet> when talking about any language.
01:16:24 <pikhq> I like Tcl. . . It does what I need it to do, and I know it.
01:16:36 <pikhq> And I've grown fond of it. . .
01:16:40 <pikhq> What more reason do I need?
01:17:09 <CakeProphet> ...
01:17:26 <CakeProphet> at least you didn't turn into a living advertisement.
01:17:46 <pikhq> That's all the language advocacy I do.
01:17:48 <oklopol> c++ is the BEST by the way, i'll be off reading lisp now ->
01:17:58 <oklopol> (BEST)
01:18:40 <oklopol> btw
01:18:52 <oklopol> bsmntbombdood
01:19:13 <pikhq> C++ is a language.
01:19:20 -!- fizzie has quit (zelazny.freenode.net irc.freenode.net).
01:19:25 <pikhq> It happens to be pretty good.
01:19:25 <pikhq> There we go.
01:19:26 <oklopol> the function you had, i figured how you do that in the shower that morning
01:19:53 <oklopol> pikhq, i wasn't serious... just to be sure :)
01:20:14 <oklopol> okay, it didn't need clarification now that i see how i presented it :)
01:21:05 -!- fizzie has joined.
01:21:08 <oklopol> bsmntbombdood, just that if you like to have your own code there, i can tell you the algo, unless you either know it or don't care or whatever
01:21:22 <oklopol> now really ->
01:21:25 <fizzie> Re TCL, why not  string repeat ">0" $n  instead of the for loop? :p
01:21:54 <pikhq> fizzie: I don't have all of the string functions commited to memory.
01:35:29 <CakeProphet> hmmm... maybe a Category:Homoiconic should be added to the wiki?
01:43:25 <bsmntbombdood> oklopol: what?
01:44:58 <oklopol> the function you used to make the fractions
01:45:10 <bsmntbombdood> What about it?
01:45:30 <oklopol> well, just what i said :\
01:45:32 <oklopol> nothing more
01:45:46 <oklopol> just that it's trivial to do that
01:45:50 <oklopol> but you prolly know that
01:46:24 <oklopol> and just don't feel sad to use code written by someone you don't know in a small project like that
01:47:22 <oklopol> i don't see why you would, tho
01:48:11 <bsmntbombdood> That code is very slow
01:48:42 <bsmntbombdood> O(n) it looks like
01:48:59 <bsmntbombdood> at least O(n) that is
01:49:10 <bsmntbombdood> O(n) for whole numbers
01:49:20 <oklopol> well, you take the fraction straight from the double, then just gcm it
01:49:56 <bsmntbombdood> What do you mean, take the fraction?
01:50:22 <oklopol> the double is in a format ... * 2**..
01:50:26 <oklopol> *-a
01:50:54 <oklopol> so, you take the mantissa and the exponent straight from the number
01:51:00 <oklopol> assuming those are the terms
01:51:32 <oklopol> that is the gist of the problem
01:51:42 <oklopol> so i'm pretty sure it's the most efficient one
01:51:51 <oklopol> most efficient algorithm i mean
01:52:56 <oklopol> you can easily get the mantissa and exponent from a double in haskell, so why not in python
01:53:28 <oklopol> (i'm not sure if that makes sence, i just think of both as non- implementation spesific...)
01:53:55 <oklopol> (like, not having limits on how floating point numbers are stored)
01:54:28 <oklopol> (ignore all "<oklopol> \(.*\)")
02:21:59 -!- jix__ has joined.
02:26:39 -!- jix__ has quit (Client Quit).
02:33:53 -!- jix has quit (Read error: 110 (Connection timed out)).
02:49:08 -!- ihope has quit (Read error: 110 (Connection timed out)).
03:09:00 <SimonRC> zZzZ
03:17:34 <oklopol> ozozozozo
03:37:50 -!- pikhq has quit ("leaving").
04:10:12 -!- Sgeo has quit ("Leaving").
06:02:32 <CakeProphet> !glass
06:02:37 <CakeProphet> !help
06:02:46 <CakeProphet> EGOBOTS DOWN
06:02:49 <CakeProphet> PANIC
06:04:07 <bsmntbombdood> zoooooooooooooooommmmmmmmmmmmg
06:06:56 -!- Lea has joined.
06:06:59 <Lea> ....
06:07:21 <CakeProphet> lol hi. :)
06:07:28 <Lea> LOLSUP
06:07:33 <CakeProphet> How's life?
06:07:35 <CakeProphet> peachy?
06:07:39 <Lea> Oh wonderful.
06:07:41 <Lea> You?
06:07:41 <CakeProphet> splendid.
06:07:44 <Lea> Grand.
06:07:45 <CakeProphet> awesome
06:07:46 <Lea> Excellent.
06:07:49 <CakeProphet> yup
06:07:50 <Lea> WOnderful.
06:07:52 <Lea> ..Oh
06:07:55 -!- CakeProphet has changed nick to GrandmotherChaos.
06:07:59 <Lea> So how do I make t-...
06:08:03 <GrandmotherChaos> ...
06:08:05 <Lea> Grandmotherchaos, mm.
06:08:09 <GrandmotherChaos> hrm
06:08:12 <GrandmotherChaos> Lea, whoooo
06:08:24 -!- GrandmotherChaos has changed nick to SevenInchBread.
06:08:35 <SevenInchBread> now what were you saying?
06:08:35 -!- Lea has changed nick to SixInchBread.
06:08:41 <SevenInchBread> :o scandalous
06:08:44 <SixInchBread> Wow. SixInchBread is used by someone.
06:08:49 <SevenInchBread> I don't like the emoticon they give to :o
06:08:53 <SixInchBread> ..no
06:08:55 -!- SixInchBread has changed nick to Lea.
06:09:00 <SevenInchBread> yeah... someone made it after I made this one.
06:09:11 <SevenInchBread> posers no doubt
06:09:18 <Lea> Indeed.
06:09:58 -!- Lea has changed nick to LeaLeaLea.
06:10:09 <SevenInchBread> oooh
06:10:13 <SevenInchBread> it's wavy
06:10:21 <LeaLeaLea> Two Lea's will simply not cut it.
06:10:27 <SevenInchBread> nope.
06:10:34 <SevenInchBread> we're totally spamming this channel.
06:10:43 <LeaLeaLea> ..We're speaking.
06:10:48 <SevenInchBread> yup
06:10:50 <LeaLeaLea> WHAT DO YOU DO ON IRC BUT CHAT?
06:10:58 <SevenInchBread> IT'S NOT ALLOWED
06:11:07 <LeaLeaLea> FUCK YOU
06:11:34 <SevenInchBread> WHY ISN'T EGOBOT WORKING
06:11:43 <LeaLeaLea> It  hates you.
06:11:47 <SevenInchBread> someone turn it on!
06:11:51 <LeaLeaLea> Refuse him.
06:11:52 * SevenInchBread downloads the source
06:15:31 <LeaLeaLea> ....
06:17:30 <SevenInchBread> SOMEONE MAKE EGOBOT WORK
06:17:33 <LeaLeaLea> NOPE.
06:17:35 <SevenInchBread> I can't figure out how to run it.
06:17:47 <LeaLeaLea> You = suck.
06:17:47 <SevenInchBread> LeaLeaLea fizzie SevenInchBread oklopol lament_ NK` MM2 GregorR sekhmet cmeme bsmnt_bot bsmntbombdood puzzlet clog sp3tt mtve meatmanek SimonRC tokigun pgimeno 
06:17:50 <LeaLeaLea> ...
06:17:51 <SevenInchBread> I ping you all
06:17:53 <SevenInchBread> like an ass
06:17:57 <LeaLeaLea> Don't you ever ping me again.
06:18:01 <LeaLeaLea> Or I'll 'ping' you.
06:18:08 <SevenInchBread> I'LL PING YOU EVERY FUCKING DAY
06:18:13 <LeaLeaLea> ....
06:18:22 <SevenInchBread> anywho.
06:18:27 <LeaLeaLea> ... Defeated.
06:18:27 <SevenInchBread> how do you run egobot?
06:18:32 <LeaLeaLea> It's down.
06:18:41 <SevenInchBread> ...yes
06:18:47 <LeaLeaLea> I ATE IT
06:19:00 <SevenInchBread> ..poop
06:19:05 <LeaLeaLea> A noble cause.
06:19:18 * LeaLeaLea tests.
06:19:20 <LeaLeaLea> ... :)
06:19:27 * SevenInchBread whooooo
06:19:46 <LeaLeaLea> SEVENINCHBREAD?
06:19:50 <LeaLeaLea> SEVENINCHBREAD???
06:19:53 <SevenInchBread> Yah?
06:19:56 * LeaLeaLea refuses to tell.
06:20:01 <SevenInchBread> ...
06:20:19 <SevenInchBread> LeaLeaLea, I wonder why you would be here...
06:20:25 <SevenInchBread> hrm...
06:20:29 <LeaLeaLea> ... So do I..
06:20:58 <SevenInchBread> wheee
06:22:08 <LeaLeaLea> :)
06:23:01 <LeaLeaLea> Do de doo..
06:24:55 -!- LeaLeaLea has quit ("Chatzilla 0.9.77 [Firefox 1.5.0.9/2006120612]").
06:25:46 -!- LeaLeaLea has joined.
06:25:50 <LeaLeaLea> I have returned.
06:26:13 <SevenInchBread> hi. :)
06:26:17 <LeaLeaLea> Hi. :)
06:30:29 <SevenInchBread> ?????>>>>>>>
06:30:31 <SevenInchBread> ?>">'.
06:30:33 <SevenInchBread> rl
06:32:53 <LeaLeaLea> ...
06:35:19 <SevenInchBread> HEY GREGOR
06:35:27 <SevenInchBread> GregorR,   GREGOR
06:35:30 <SevenInchBread> WAKE UP
06:35:52 -!- SevenInchBread has changed nick to CakeProphet.
06:36:09 <CakeProphet> GregorR,  Get egobot back up
06:37:29 -!- LeaLeaLea has quit ("Chatzilla 0.9.77 [Firefox 1.5.0.9/2006120612]").
06:38:07 -!- LeaLeaLea has joined.
06:38:20 <LeaLeaLea> CakeProphet.
06:38:25 <CakeProphet> yah?
06:38:30 <LeaLeaLea> I don't like you.
06:38:41 <LeaLeaLea> ..Have you made the bot work yet..
06:38:52 <LeaLeaLea> HAVE YOU?
06:39:05 <CakeProphet> NO
06:39:07 <LeaLeaLea> :)
06:39:09 <CakeProphet> I'm not familiar with C
06:39:15 <LeaLeaLea> I GUESS YOU SUCK THEN.
06:39:15 <CakeProphet> you have to compile it and shit
06:39:19 <CakeProphet> NOPE
06:39:21 <CakeProphet> I ROCK
06:39:23 <LeaLeaLea> ... :):):)
06:39:44 <bsmntbombdood> hmmm?
06:39:45 <CakeProphet> Gregor!!!!!!!!!!!
06:39:53 <CakeProphet> bsmntbombdood,  make EgoBot work
06:39:54 <LeaLeaLea> He is intentionally ignoring you.
06:39:57 <LeaLeaLea> Because he does not like cake.
06:40:00 <LeaLeaLea> Nor prophets.
06:40:07 <CakeProphet> damn...
06:40:23 <CakeProphet> you can get the source
06:40:26 <CakeProphet> and like... compile it
06:40:27 <CakeProphet> and stuff
06:40:33 <CakeProphet> and make it work
06:40:36 <LeaLeaLea> You lie.
06:40:43 <CakeProphet> I don't
06:40:45 <LeaLeaLea> You do.
06:40:52 <CakeProphet> erm nope
06:40:53 <LeaLeaLea> DO.
06:40:59 <LeaLeaLea> ..Premeditated ftw.
06:41:13 <CakeProphet> hrm
06:41:20 <LeaLeaLea> !help
06:41:24 <LeaLeaLea> NEVER SPEAK OF THAT
06:41:42 <CakeProphet> bsmntbombdood, make egobot work
06:41:49 <bsmntbombdood> ...
06:41:53 <CakeProphet> ...
06:42:00 <LeaLeaLea> .....
06:42:18 <CakeProphet> I want to play with glass
06:42:54 <LeaLeaLea> I want you to play with glass.
06:43:00 <CakeProphet> see?
06:43:02 <LeaLeaLea> Mhm.
06:43:10 <CakeProphet> and maybe brainfuck
06:43:13 <CakeProphet> but mostly glass
06:43:21 <CakeProphet> aha!
06:43:24 <LeaLeaLea> ...What
06:43:28 <CakeProphet> I'll make my own bot... WAY BETTER THAN EGOBOT
06:43:35 <LeaLeaLea> ..Yeah. Five years later..
06:43:38 <LeaLeaLea> Still no bot.
06:43:40 <CakeProphet> ...shut up
06:43:43 <LeaLeaLea> BUT LOTS OF TALKING ABOUT IT
06:43:46 <CakeProphet> I've got one like...
06:43:49 <CakeProphet> halfwaydone man
06:43:57 <LeaLeaLea> :)
06:44:00 <bsmntbombdood> code glass for bsmnt_bot 
06:44:11 * CakeProphet has lots of unfinished projects
06:44:15 <LeaLeaLea> ..Who are you
06:44:20 <CakeProphet> bsmntbombdood, it has a glass interpreter?
06:44:26 <bsmntbombdood> no
06:44:31 <bsmntbombdood> you need to code one
06:44:34 <CakeProphet> ....
06:44:36 <CakeProphet> fuck that
06:44:49 <CakeProphet> just use egobots
06:44:53 <CakeProphet> in a subprocess
06:45:00 <CakeProphet> or something
06:45:06 <bsmntbombdood> go ahead
06:45:09 <CakeProphet> ...
06:45:15 <CakeProphet> GOD DAMNIT
06:45:21 <bsmntbombdood> You are allowed to make net connections with bsmnt_bot 
06:45:28 <bsmntbombdood> download the interpreter
06:45:39 <CakeProphet> ...how do you run C on Windows?
06:46:37 <CakeProphet> I don't think I even have a compiler for it.
06:48:09 <CakeProphet> bsmntbombdood,  aaah
06:49:07 <CakeProphet> actually..
06:49:11 <CakeProphet> cygwin might have something for it.
06:49:15 * CakeProphet checks
07:00:53 <CakeProphet> nope
07:03:00 <bsmntbombdood> do it with bsmnt_bot 
07:05:09 -!- LeaLeaLea has quit ("Chatzilla 0.9.77 [Firefox 1.5.0.9/2006120612]").
07:16:26 <puzzlet> whats wrong with him
07:17:55 <CakeProphet> hmmm?
07:18:04 <CakeProphet> puzzlet,  who?
07:18:47 -!- bsmntbombdood has changed nick to lolipop.
07:20:14 -!- LeaLeaLea has joined.
07:20:20 <puzzlet> forget it
07:20:26 <LeaLeaLea> I have returned.
07:20:33 <CakeProphet> oh.
07:20:38 -!- lolipop has changed nick to bsmntbombdood.
07:21:49 * CakeProphet frowns.
07:21:59 * CakeProphet consternates
07:22:00 <LeaLeaLea> ..Quiet.
07:22:09 <CakeProphet> we all hate you
07:22:10 <LeaLeaLea> I have no time for your shenanagens.
07:22:12 <LeaLeaLea> NO.
07:22:18 <CakeProphet> yep
07:22:24 <LeaLeaLea> Unfortunate.
07:22:39 <CakeProphet> ~help
07:22:47 <CakeProphet> :o  scandalous
07:22:53 <LeaLeaLea> SHUT UP.
07:22:56 <CakeProphet> ~exec print "Lol"
07:23:02 <CakeProphet> ....scandalous
07:23:15 <CakeProphet> bsmntbombdood,  your bot's dead.
07:23:32 <bsmntbombdood> what?
07:23:34 <bsmntbombdood> no it's not
07:23:39 <CakeProphet> lol yah
07:23:44 <bsmntbombdood> ~exec sys.stdout("lol")
07:23:45 <bsmnt_bot> lol
07:23:47 <CakeProphet> ...
07:23:52 <CakeProphet> oh
07:23:54 <CakeProphet> yeah
07:23:59 <CakeProphet> you do the wierd stdout wrapper
07:24:14 <CakeProphet> ~exec sys.stdout(str(globals()))
07:24:15 <bsmnt_bot> {'thread_info': <thread._local object at 0xb7d41890>, 'exec_global_tracer': <function exec_global_tracer at 0xb7cad994>, 'pprint': <module 'pprint' from '/usr/lib/python2.4/pprint.pyc'>, 're': <module 're' from '/usr/lib/python2.4/re.pyc'>, 'SysWrapper': <class __main__.SysWrapper at 0xb7ca935c>, 'exec_local_tracer': <function exec_local_tracer at 0xb7cc033c>, '__doc__': N
07:24:15 <bsmnt_bot> one, 'math': <module 'math' from '/usr/lib/python2.4/lib-dynload/math.so'>, 'IRCbot': <class __main__.IRCbot at 0xb7ca92fc>, 'args': {'IDENT': 'bsmnt', 'REALNAME': 'bsmntbombdood bot', 'CHAN': '#esoteric', 'NICK': 'bsmnt_bot', 'HOST': '85.188.1.26', 'PORT': 6667, 'VERBOSE': True}, '__builtins__': <module '__builtin__' (built-in)>, '__file__': '/bot/ircbot.py', 'inspect': <
07:24:15 <bsmnt_bot> module 'inspect' from '/usr/lib/python2.4/inspect.pyc'>, 'IRCFileWrapper': <class __main__.IRCFileWrapper at 0xb7ca932c>, 'sys': <module 'sys' (built-in)>, '__name__': '__main__', 'copy': <module 'copy' from '/usr/lib/python2.4/copy.pyc'>, 'types': <module 'types' from '/usr/lib/python2.4/types.pyc'>, 'socket': <module 'socket' from '/usr/lib/python2.4/socket.pyc'>, 'threa
07:24:20 <bsmnt_bot> d': <module 'thread' (built-in)>, 'os': <module 'os' from '/usr/lib/python2.4/os.pyc'>, 'traceback': <module 'traceback' from '/usr/lib/python2.4/traceback.pyc'>, 'bot': <__main__.IRCbot instance at 0xb7cbf14c>, 'threading': <module 'threading' from '/usr/lib/python2.4/threading.pyc'>, 'time': <module 'time' from '/usr/lib/python2.4/lib-dynload/time.so'>, 'pickle': <module
07:24:25 <bsmnt_bot>  'pickle' from '/usr/lib/python2.4/pickle.pyc'>, 'marshal': <module 'marshal' (built-in)>}
07:24:51 <bsmntbombdood> ...smart
07:25:16 <CakeProphet> ~exec sys.stdout(repr(self))
07:25:16 <bsmnt_bot> <__main__.IRCbot instance at 0xb7cbf14c>
07:25:50 <CakeProphet> What's the quick way to match all the beginner stuff with register_raw?
07:26:49 <bsmntbombdood> what?
07:26:56 <CakeProphet> STOP BEING CONFUSED DAMNIT
07:27:13 <CakeProphet> the beginning
07:27:15 <CakeProphet> of an IRC line
07:27:21 <CakeProphet> is there a quick way to match it?
07:27:24 <CakeProphet> in a regex
07:27:29 <CakeProphet> of register_raw() thing
07:27:36 <bsmntbombdood> "^"?
07:27:46 <CakeProphet> ...
07:27:49 <CakeProphet> the address stuff
07:27:57 <CakeProphet> well..
07:28:06 <CakeProphet> I could just do .*?
07:28:16 <bsmntbombdood> \S* would be better
07:28:22 <bsmntbombdood> but what do you mean?
07:28:39 <bsmntbombdood> If you want to get stuff like the nick, match it against self.message_re
07:29:13 <CakeProphet> what are the arguments of the function?
07:29:27 <CakeProphet> in the second argumet of register_raw
07:29:44 <bsmntbombdood> message, regex match object
07:32:07 -!- Sartak has joined.
07:32:17 -!- Sartak has left (?).
07:32:45 <CakeProphet> ~exec import random;self.register_raw("\S*: *~roll (?<d>\d*) *$", lambda x,y: sys.stdout(random.randint(1,y.groupdict.get("d", 6)))) 
07:32:54 <CakeProphet> ~roll 6
07:33:02 <CakeProphet> CONTROVERSY
07:33:43 <CakeProphet> ~exec import random;self.register_raw("\S*: *~roll (?P<d>\d*) *$", lambda x,y: sys.stdout(random.randint(1,y.groupdict.get("d", 6)))) 
07:33:48 <CakeProphet> ~roll 10
07:33:54 <CakeProphet> CONTROVERSY
07:34:20 <bsmntbombdood> nope
07:34:21 <CakeProphet> bsmntbombdood, what was the error message.
07:34:30 <bsmntbombdood> #bsmnt_bot_errors 
07:34:34 <CakeProphet> ...damnit
07:34:37 <bsmntbombdood> your regex is wrong
07:34:46 <CakeProphet> ~exec import random;self.register_raw("\S*: *~roll (?P<d>\d*) *$", lambda x,y: sys.stdout(random.randint(1,y.groupdict.get("d", 6)))) 
07:34:52 <CakeProphet> oh..
07:34:54 <bsmntbombdood> ...still wrong
07:35:24 <CakeProphet> ~exec import random;self.register_raw("^\S*: *~roll (?P<d>\d*) *$", lambda x,y: sys.stdout(random.randint(1,y.groupdict.get("d", 6)))) 
07:35:31 <CakeProphet> ~roll 5
07:35:35 <CakeProphet> ...
07:35:40 <CakeProphet> what's wrong?
07:35:43 -!- LeaLeaLea has quit ("Chatzilla 0.9.77 [Firefox 1.5.0.9/2006120612]").
07:36:17 <bsmntbombdood> this is the format of a message: ":CakeProphet!n=CakeProp@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :what's wrong?
07:36:24 <CakeProphet> oooh...
07:36:28 <CakeProphet> yeah
07:36:31 <CakeProphet> forgot the leading semicolon
07:36:57 <bsmntbombdood> no
07:37:05 <bsmntbombdood> \S matches non-whitespace chars
07:37:56 <CakeProphet> ~exec import random;self.register_raw("^\S* PRIVMSG #esoteric : *~roll (?P<d>\d*) *$", lambda x,y: sys.stdout(random.randint(1,y.groupdict.get("d", 6)))) 
07:38:01 <CakeProphet> ~roll 10
07:38:01 -!- bsmnt_bot has quit (Remote closed the connection).
07:38:05 -!- bsmnt_bot has joined.
07:38:21 <CakeProphet> I broken it
07:40:24 <CakeProphet> ~exec import random;self.register_raw("^\S* PRIVMSG #esoteric : *~roll (?P<d>\d*) *$", lambda x,y: sys.stdout(random.randint(1,int(y.groups("d")))))
07:40:34 <CakeProphet> ~roll 10
07:40:35 -!- bsmnt_bot has quit (Remote closed the connection).
07:40:37 -!- bsmnt_bot has joined.
07:40:50 <CakeProphet> ~exec import random;self.register_raw("^\S* PRIVMSG #esoteric : *~roll (?P<d>\d*) *$", lambda x,y: sys.stdout(str(random.randint(1,int(y.groups("d"))))))
07:40:54 <CakeProphet> ~roll 10
07:40:54 -!- bsmnt_bot has quit (Remote closed the connection).
07:40:56 -!- bsmnt_bot has joined.
07:41:22 <bsmntbombdood> y.group
07:41:32 <CakeProphet> ~exec import random;self.register_raw("^\S* PRIVMSG #esoteric : *~roll (?P<d>\d*) *$", lambda x,y: sys.stdout(str(random.randint(1,int(y.group("d"))))))
07:41:37 <CakeProphet> ~roll 10
07:41:38 -!- bsmnt_bot has quit (Remote closed the connection).
07:41:40 -!- bsmnt_bot has joined.
07:41:41 <CakeProphet> nope lol
07:42:18 <bsmntbombdood> global name random not defined
07:42:25 <CakeProphet> ~exec import random;self.register_raw("^\S* PRIVMSG #esoteric : *~roll (?P<d>\d*) *$", lambda x,y: sys.stdout(str(__import__("random").randint(1,int(y.groups("d"))))))
07:42:28 <CakeProphet> ~roll 10
07:44:32 <CakeProphet> ~exec import random;self.register_raw("^\S* PRIVMSG #esoteric : *~roll (?P<d>\d*) *$", lambda x,y: sys.stdout.write(str(__import__("random").randint(1,int(y.groups("d"))))))
07:44:36 <CakeProphet> ~roll 10
07:44:48 <bsmntbombdood> weird
07:46:04 <CakeProphet> ~exec import random;self.register_raw("^\S* PRIVMSG #esoteric : *~roll (?P<d>\d*) *$", lambda x,y: sys.stdout.write(str(__import__("random").randint(1,int(y.group("d"))))))
07:46:06 <CakeProphet> ~roll 10
07:46:06 <bsmnt_bot> 1
07:46:08 <CakeProphet> ~roll 10
07:46:09 <bsmnt_bot> 9
07:46:10 <CakeProphet> ~roll 10
07:46:10 <bsmnt_bot> 1
07:46:12 <CakeProphet> ~roll 10
07:46:12 <bsmnt_bot> 2
07:46:13 <CakeProphet> ~roll 10
07:46:13 <bsmnt_bot> 2
07:46:16 <CakeProphet> how novel
07:46:44 <bsmntbombdood> ...
07:47:44 <CakeProphet> ~exec globals()["random"] = __import__("random");self.register_raw("^\S* PRIVMSG #esoteric : *~roll (?P<d>\d*) *$", lambda x,y: sys.stdout.write(str(random.randint(1,int(y.group("d"))))))
07:47:49 <CakeProphet> ~roll 10
07:47:49 <bsmnt_bot> 5
07:47:50 <bsmnt_bot> 6
07:47:54 <CakeProphet> :o
07:48:40 <CakeProphet> get rid of the old one.
07:49:20 <bsmntbombdood> ~exec del self.raw_regex_queue[-2]
07:49:34 <CakeProphet> ~roll 56
07:49:35 <bsmnt_bot> 9
07:49:38 <CakeProphet> ~roll 4345694569049560945609456
07:49:39 <bsmnt_bot> 937767620971671047976646
07:49:40 <CakeProphet> ~roll 4345694569049560945609456
07:49:41 <bsmnt_bot> 2838600485402488068531576
07:49:42 <CakeProphet> ~roll 4345694569049560945609456
07:49:43 <bsmnt_bot> 2269477471378303337011121
07:49:44 <CakeProphet> ~roll 4345694569049560945609456
07:49:45 <bsmnt_bot> 2115576699285482581859932
07:50:39 <bsmntbombdood> fun
07:56:33 <CakeProphet> ~exec self.__class__.imlazy = lambda x,f: self.register_raw("^\S* PRIVMSG #esoteric : *%s (?:(?: (.*?) ))* *", lambda ge,ha: sys.stdout(str(f(*ha.groups()))))
07:57:00 <CakeProphet> oh...
07:57:13 <CakeProphet> ~exec self.__class__.imlazy = lambda x,f: self.register_raw("^\S* PRIVMSG #esoteric : *%s (?:(?: (.*?) ))* *" % x, lambda ge,ha: sys.stdout(str(f(*ha.groups()))))
07:57:43 <CakeProphet> hmmm...
07:58:33 <CakeProphet> ~exec self.__class__.imlazy = lambda x,f: self.register_raw("^\S* PRIVMSG #esoteric : *%s (?P<inp>.*)$" % x, lambda ge,ha: sys.stdout(str(f(*ha.group("inp")))))
07:58:53 <CakeProphet> ~exec self.imlazy("cat", lambda foo: foo)
07:59:23 <bsmntbombdood> what are you doing?
07:59:25 <CakeProphet> ~exec self.__class__.imlazy = lambda self, x,f: self.register_raw("^\S* PRIVMSG #esoteric : *%s (?P<inp>.*)$" % x, lambda ge,ha: sys.stdout(str(f(*ha.group("inp")))))
07:59:32 <CakeProphet> ~exec self.imlazy("cat", lambda foo: foo)
07:59:42 <CakeProphet> cat h
07:59:42 <bsmnt_bot> h
07:59:46 <CakeProphet> being lazy
07:59:50 <CakeProphet> cat whoooo
07:59:54 <CakeProphet> ERROR
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:00:51 <CakeProphet> ....how could it possibly get a typeerror?
08:01:12 <CakeProphet> ah.
08:01:27 <CakeProphet> ~exec self.__class__.imlazy = lambda self, x,f: self.register_raw("^\S* PRIVMSG #esoteric : *%s (?P<inp>.*)$" % x, lambda ge,ha: sys.stdout(str(f(ha.group("inp")))))
08:01:49 <CakeProphet> ~exec del self.raw_regex_queue[-1]
08:01:59 <CakeProphet> ~exec self.imlazy("cat", lambda foo: foo)
08:02:01 <CakeProphet> cat whooo
08:02:02 <bsmnt_bot> whooo
08:02:05 <CakeProphet> cat hahahahahaha
08:02:06 <bsmnt_bot> hahahahahaha
08:02:08 <CakeProphet> mehehehehehe
08:02:15 <CakeProphet> ~exec del self.raw_regex_queue[-1]
08:02:20 <CakeProphet> ~exec self.imlazy("~cat", lambda foo: foo)
08:02:23 <CakeProphet> ~cat wha 
08:02:24 <bsmnt_bot> wha
08:03:03 <CakeProphet> ~exec self.imlazy("~dup", lambda x: x*2)
08:03:08 <CakeProphet> ~dup hello
08:03:08 <bsmnt_bot> hellohello
08:03:13 <CakeProphet> :(
08:03:17 <CakeProphet> ~exec del self.raw_regex_queue[-1]
08:03:32 <CakeProphet> ~exec self.imlazy("~dup", lambda x: "%s %s" % (x,x))
08:03:39 <CakeProphet> ~dup ha
08:03:40 <bsmnt_bot> ha ha
08:03:50 <CakeProphet> ~dup ~dup ~dup ha
08:03:50 <bsmnt_bot> ~dup ~dup ha ~dup ~dup ha
08:03:57 <CakeProphet> :(
08:04:20 <CakeProphet> ~exec self.imlazy("~dog", lambda x: x[::-1])
08:04:23 <CakeProphet> ~dog wha
08:04:23 <bsmnt_bot> ahw
08:09:43 <CakeProphet> ~exec self.imlazy("~rot", lambda x:"".join( [(chr((ord(c) if ord(c) < ord("n")  else ord(c)-26)+13) if c != " " else " ") for c in x]))
08:09:52 <CakeProphet> ~rot whooo
08:10:31 <bsmntbombdood> python 2.4
08:10:38 <CakeProphet> ....crap
08:11:01 -!- helios24 has joined.
08:13:50 <CakeProphet> ~exec self.imlazy("~A", lambda x: " ".join(["".join(["A" for c in w]) for w in x.split()]) + "!")
08:13:54 <CakeProphet> ~A hmmmm
08:13:54 <bsmnt_bot> AAAAA!
08:13:57 <CakeProphet> ~A hmmmm hmmmm
08:13:58 <bsmnt_bot> AAAAA AAAAA!
08:14:07 <CakeProphet> ~A to be or not to be, that is the question
08:14:07 <bsmnt_bot> AA AA AA AAA AA AAA AAAA AA AAA AAAAAAAA!
08:15:02 <CakeProphet> I had to do a cheap hack to bypass the lack of conditionals.
08:15:18 <CakeProphet> I couldn't conditionally exclude whitespace from being converted... so I used split and applied a for loop to each word.
08:15:46 <bsmntbombdood> It works
08:18:38 <CakeProphet> hrm...
08:18:49 <CakeProphet> time to implement dupdog
08:18:50 <CakeProphet> :D
08:27:07 <CakeProphet> ~exec def mfit(src):; cmd = src[0]; src = src[1:]; if cmd == "~":;  return src*2; elif cmd == "?":;  if len(src)%2 == 0:   return src.replace("?","\n").replace("~", "\t").replace("!","?").replace("\n","~").replace("\t","!");   else:;    return src; else;  print len(src);  return ""
08:27:39 <CakeProphet> ...damn
08:49:02 -!- sebbu has joined.
09:24:27 -!- wooby has joined.
10:00:30 -!- oerjan has joined.
10:13:33 <oerjan> amphibious programming FTW
10:36:41 <oerjan> ~A Good grief.
10:36:41 <bsmnt_bot> AAAA AAAAAA!
11:11:55 <oklopol> ~A
11:12:01 <oklopol> ~A          
11:12:05 <oklopol> ~A          
11:12:05 <bsmnt_bot> AAAA!
11:12:18 <oklopol> ~A     
11:12:18 <bsmnt_bot> AAAAA AAAA AAA AA A!
11:49:38 -!- wooby has quit.
12:40:22 -!- Sgeo has joined.
12:50:56 -!- oerjan has quit ("Dream").
13:54:18 -!- helios24 has quit ("Leaving").
14:46:12 -!- ihope has joined.
15:10:22 * SimonRC lols at the original iPod announcement at Slashdot.
15:10:22 <SimonRC> "No wireless. Less space than a nomad. Lame."
15:10:23 <SimonRC> X-P
15:10:47 <SimonRC> oklopol: have you been reading Uncyclopedia again?
15:15:15 <oklopol> oh me?
15:15:30 <oklopol> i've never read uncyclopedia :\
15:15:33 <oklopol> why you ask?
15:27:37 <CakeProphet> I made the AAAA! thing
15:27:52 <CakeProphet> (AAAAAAAAA! is something from uncyclopedia)
15:28:37 <CakeProphet> http://uncyclopedia.org/wiki/AAAAAAAA%21
15:34:44 <oklopol> http://esoteric.voxelperfect.net/wiki/AAAAAAAAAAAAAA%21%21%21%21
15:34:48 <oklopol> do that too
15:43:28 <CakeProphet> hmmm
15:43:40 <CakeProphet> what's the servername and hostname parameters of a USER IRC message for?
15:43:56 <CakeProphet> it seems odd that the server would request its own name in a USER message
15:46:01 <oklopol> you don't send them
15:46:09 <oklopol> it's for their internal messaging
15:46:26 <oklopol> just the same format between users and servers && servers and servers
15:46:34 <oklopol> if you supply it, it's ignored
15:46:48 <oklopol> read the rfc like us the rest of us
15:46:48 <oklopol> :)
15:47:04 <oklopol> you put a * usually
15:47:10 <SimonRC> CakeProphet: ok, my mistake
15:48:13 <CakeProphet> ....I did read the rfc... it didn't explain any of that
15:49:35 <oklopol> really :O
15:49:40 <oklopol> it's a big rfc 
15:49:48 <oklopol> it explains it all
15:51:30 <oklopol> hmm, i'm not sure if the client rfc explains it, just saying they are ignored should suffice
15:51:42 <oklopol> you can read the server rfc if you care about details :)
15:52:55 <oklopol> Note that hostname and servername are normally ignored by the IRC
15:52:56 <oklopol>    server when the USER command comes from a directly connected client
15:52:56 <oklopol>    (for security reasons), but they are used in server to server
15:52:56 <oklopol>    communication.
15:52:58 <oklopol> client rfc
15:53:38 <oklopol> for security reasons... a very thorough explanation :)
15:58:27 <CakeProphet> I'm reading the server rfc...
15:58:31 <CakeProphet> didn't know there was more than one
16:00:45 <oklopol> god i chose the wrong lisp book :)
16:01:15 <oklopol> i've read 111 pages and i know EVAL, DEFUN and lists
16:01:40 <oklopol> i couldn't gotten all this information in 10 minutes from anyone who knows lisp
16:01:59 <oklopol> plus the book is from 1989... prolly changed quite a bit :)
16:02:10 <oklopol> but, gotta finish what i started
16:29:24 <ihope> There are two RFCs, eh?
16:29:32 <ihope> Is RFC 1459 the client one?
16:34:58 <oklopol> i think so
16:49:31 <fizzie> No.
16:49:37 <fizzie> RFC 1459 is the old RFC.
16:49:49 <fizzie> The newer ones (there are 4 or 5 of them) start with a 2.
16:50:01 <fizzie> See http://www.irchelp.org/irchelp/rfc/
16:50:08 <oklopol> :o
16:50:17 <oklopol> why am i always so goddamn obsolete
17:10:36 -!- Sgeo has quit (Remote closed the connection).
17:12:44 * SimonRC wonders why seperate layers are a good thing in software but a bad thing in your mind.
17:16:13 <oklopol> they're bad in your mind?
17:16:28 <oklopol> i thought mind was the ultimate layer management system
17:18:19 <SimonRC> Nonono, I was thinking about the Superego/Ego/Id thing, which IIRC Freud blames for many mental problems.
17:18:28 <SimonRC> OTOH, Freud wrote a lot of crap at times.
17:19:40 <oklopol> ah, you didn't mean different layers of abstraction, but that
17:20:21 <oklopol> isn't that more like... multithreading?
17:20:29 <oklopol> haven't read about that actualyl
17:20:32 <oklopol> ylylyly
17:21:50 -!- jix__ has joined.
18:07:54 * SimonRC goes to dinner
18:31:26 -!- oerjan has joined.
18:41:33 -!- helios24 has joined.
18:56:48 -!- helios24 has quit ("Leaving").
18:57:31 -!- helios24 has joined.
18:57:42 -!- helios24 has quit (Read error: 104 (Connection reset by peer)).
18:58:22 -!- helios24 has joined.
19:03:32 -!- wooby has joined.
19:04:35 -!- helios24 has quit ("Leaving").
19:04:51 -!- helios24 has joined.
19:35:20 * CakeProphet watches as he bzips his entire computer.
19:35:45 <CakeProphet> I'm finally getting a linux distro.
19:35:47 <CakeProphet> how exciting.
19:36:46 <oerjan> Entire computer? Including hardware? :)
19:37:00 <CakeProphet> ....of course
19:37:02 <CakeProphet> ...
19:37:10 <CakeProphet> nah... just the essentials and stuff I can't get elsewhere.
19:37:31 <CakeProphet> which compromises roughly 2.4 gigs of gzip compressed data.
19:37:38 <CakeProphet> which apparently is too large to... shove down my email... 
19:37:44 <CakeProphet> so... I'm bzipping the gzip of a tar
19:38:34 <CakeProphet> it's just a backup anywas.
19:38:44 <CakeProphet> once I get linux I can just access the partition directly.
19:39:38 <CakeProphet> I'm considering impatiently skipping the backup and booting it.
19:59:37 <pgimeno> knoppix?
20:00:22 -!- CakeProphet has quit ("haaaaaaaaaa").
20:11:49 -!- CakeProphet has joined.
20:14:45 -!- CakeProphet has quit (Client Quit).
20:40:16 -!- pikhq has joined.
20:42:43 <meatmanek> SevenInchBread is apparently a dick.
21:46:49 <ihope> He is?
21:47:08 <bsmntbombdood> ~A AAAAAAAAAA
21:47:09 <bsmnt_bot> AAAAAAAAAA!
21:47:36 <ihope> Or is it she?
21:48:17 <bsmntbombdood> ~A AAAAAAAAA=
21:48:18 <bsmnt_bot> AAAAAAAAAA!
22:03:27 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:10:43 <bsmntbombdood> ~A AAAAAAAAA=
22:10:52 <bsmntbombdood> ?
23:15:30 -!- CakeProphet has joined.
23:36:57 -!- Sgeo has joined.
23:50:23 -!- sebbu2 has joined.
23:58:35 -!- CakeProphet has quit (Read error: 104 (Connection reset by peer)).

2007-01-22:

00:02:31 <pikhq> >--<+-.>
00:02:37 <pikhq> Err. . .
00:02:42 <pikhq> ><+-.>
00:02:44 <pikhq> It's a fish!
00:03:14 <oerjan> Maybe it can be part of that amphibious language
00:03:17 -!- wooby has quit.
00:03:26 <pikhq> I don't think it's valid Homespring. . .
00:03:30 <pikhq> Valid Brainfuck, though.
00:04:41 <oerjan> Now there is a task - make a program that means the same in Homespring and Brainfuck.
00:05:14 <pikhq> LMAO
00:05:39 <pikhq> Given that one can't even be sure Homespring is Turing complete, that could be tricky. . .
00:06:46 <oklopol> homespring?
00:08:17 <oerjan> Actually I meant that amphibious language oklopol was blathering about ;)
00:09:17 -!- sebbu has quit (Connection timed out).
00:12:30 <oklopol> i thought you might've ment it :)
00:12:45 <oklopol> meant
00:13:00 <oklopol> maybe i'll make an amphibious language
00:13:43 <pikhq> Well, homespring *is* in some way amphibious. . .
00:13:49 <oklopol> in what way?
00:14:06 <pikhq> It involves salmon as the message-passing system. . .
00:15:25 <oklopol> ah
00:15:35 <oklopol> i had a more symbolic meaning for the word :)
00:15:37 <pikhq> Google it.
00:15:48 <oklopol> i'm lookin at a tutorial
00:15:53 <oklopol> *looking
00:16:04 <pikhq> K.
00:16:06 <oklopol> i just didn't see the amphibi..a?
00:16:20 <oklopol> because i had my own idea about it
00:16:32 <oklopol> but then again, maybe you see when i do it
00:16:42 <oerjan> I hope so.  Homespring seems to have a serious shortage of frogs.
00:17:03 -!- wooby has joined.
00:17:23 -!- wooby has quit (Client Quit).
00:17:35 <oklopol> Also, it should be noted that the null program (that is, a completely blank program) is special. When this program is run, the interpreter prints the message 'In Homespring, the null program is not a quine.' and exits.
00:17:42 <oklopol> :D
00:17:58 <oklopol> oerjan, mine wouldn't have any water animals really
00:18:24 <oklopol> just the concept of code being run in multiple ...platforms simultaneously
00:19:03 <oklopol> because now that i've come to think of it, amphibious was imo a nice for for describing programs that run the samu way in many languages
00:19:08 <oklopol> *same
00:19:15 <oklopol> even tho it was a typo then
00:19:20 <oklopol> well, mental typo
00:20:49 <oklopol> that homespring... what the fuck 8|
00:22:02 <oerjan> Eye-popping?
00:23:11 -!- CakeProphet has joined.
00:25:53 <oklopol> i didn't understand anything really
00:26:26 <pikhq> It's crazy.
00:26:29 <oklopol> the tree-parsing was not explained at all
00:26:40 <oklopol> and it'd take time for me to decrypt it
00:26:45 <oklopol> from the examples
00:26:57 <oklopol> but a massive set of gizmos :D
00:27:03 <oerjan> You can take a look at Good Math/Bad Math
00:27:13 <pikhq> It's described in there?
00:27:23 <oerjan> That blog had an article on it recently
00:27:42 <pikhq> Kewl.
00:27:50 <oklopol> Good Math/Bad Math?
00:28:28 <oerjan> http://scienceblogs.com/goodmath/goodmath/programming/pathological_programming/
00:30:36 <CakeProphet> wow... Google might be making an OS?
00:30:41 <CakeProphet> that would be sweet...
00:33:06 -!- sebbu2 has quit (""Que les puces d'un millier de chiens galeux infestent le cul de celui qui gachera une seule seconde de ta vie, et que les br).
00:45:20 -!- CakeProphet has quit ("haaaaaaaaaa").
00:53:57 -!- pikhq has quit (Read error: 110 (Connection timed out)).
00:55:27 -!- oerjan has quit ("Nothing clever here").
00:57:07 -!- pikhq has joined.
00:57:49 -!- CakeProphet has joined.
00:58:38 -!- CakeProphet has quit (Client Quit).
00:59:05 -!- CakeProphet has joined.
01:02:28 -!- CakeProphet has quit (Client Quit).
02:30:53 -!- lament_ has changed nick to lament.
02:35:19 -!- ihope has quit (Read error: 110 (Connection timed out)).
02:36:38 -!- pikhq has quit (Read error: 110 (Connection timed out)).
03:21:31 -!- wooby_ has joined.
03:21:32 -!- wooby_ has quit (Remote closed the connection).
03:22:23 -!- CakeProphet has joined.
03:26:35 -!- CakeProphet has quit (Client Quit).
03:48:29 -!- CakeProphet has joined.
03:53:18 -!- wooby_ has joined.
03:55:31 -!- CakeProphet has quit ("haaaaaaaaaa").
04:05:39 -!- helios24 has quit (Read error: 113 (No route to host)).
04:07:11 -!- CakeProphet has joined.
04:20:37 <bsmntbombdood> foo
04:21:17 * CakeProphet is hacking linux to get his wireless to work .
04:21:23 <CakeProphet> damn Belkin.
04:21:30 <CakeProphet> and their Windows-centric adapter drivers
04:23:29 -!- CakeProphet has quit ("haaaaaaaaaa").
04:46:15 -!- wooby_ has quit.
05:00:39 <GregorR> http://www.codu.org/win1.avi
06:00:23 -!- tokigun has quit ("finally i have quit message! yay!").
06:20:41 -!- CakeProphet has joined.
06:35:38 -!- tokigun has joined.
06:48:17 <CakeProphet> hmm..
06:48:27 <CakeProphet> kernels are way too big..
07:00:28 <CakeProphet> WE NEED A KERNEL
07:00:32 <CakeProphet> SMALLER THAN A PICOKERNEL
07:00:40 <CakeProphet> ...but I can't remember the prefix
07:34:33 -!- sebbu has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:29:46 -!- Sgeo has quit (Read error: 110 (Connection timed out)).
08:34:48 -!- wooby_ has joined.
09:11:41 -!- helios24 has joined.
09:14:49 -!- wooby_ has quit.
10:41:14 -!- ihope has joined.
10:45:19 -!- oerjan has joined.
11:51:30 -!- CakeProphet has quit ("haaaaaaaaaa").
13:05:39 <oklopol> FEMTO
13:06:53 <fizzie> Then atto, zepto and yocto. The last two always make me smile.
13:08:23 <oklopol> yeah
13:08:40 <oklopol> memorized those some years ago
13:08:41 <fizzie> "Our system has a yoctokernel architecture."
13:08:46 <oklopol> :D
13:18:52 <oerjan> Those last ones sound like the names of Marx brothers
13:32:41 -!- oerjan has quit ("Hunting for food").
13:51:43 -!- helios24 has quit (Read error: 110 (Connection timed out)).
15:44:45 -!- helios24 has joined.
16:04:56 -!- ihope has quit (Connection timed out).
16:22:27 -!- sebbu has quit ("reboot").
16:33:38 -!- tgwizard has joined.
16:34:54 -!- FabioNET has joined.
16:36:46 -!- jix__ has joined.
16:42:40 -!- sebbu has joined.
16:51:19 -!- jix__ has changed nick to jix.
18:34:38 -!- helios24 has quit (Read error: 113 (No route to host)).
19:40:20 -!- helios24 has joined.
20:01:51 -!- sebbu2 has joined.
20:20:42 -!- sebbu has quit (Read error: 110 (Connection timed out)).
20:31:04 -!- helios24 has quit ("Leaving").
20:31:09 -!- helios24 has joined.
20:39:43 -!- oerjan has joined.
20:47:08 -!- ihope has joined.
20:56:40 -!- tgwizard has quit (Read error: 110 (Connection timed out)).
21:12:35 -!- CakeProphet has joined.
21:13:57 <CakeProphet> hrm...
21:14:10 <CakeProphet> I still can't get my network adapter to run in linux.
21:14:16 <CakeProphet> even with ndiswrapper
21:14:26 <SimonRC> :-(
21:18:11 <ihope> What is ndiswrapper, exactly?
21:18:21 <ihope> A Windows driver loader thingy?
21:19:03 <CakeProphet> it's a interface for working with windows-centric drivers.
21:19:17 <CakeProphet> my network adapter sucks and was only made to work with Windows.
21:22:15 * CakeProphet is going to try something new.
21:22:19 -!- CakeProphet has quit ("haaaaaaaaaa").
21:23:00 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
21:25:10 -!- helios24 has quit ("Leaving").
21:25:18 -!- helios24 has joined.
21:30:37 -!- helios24 has quit ("Leaving").
21:30:45 -!- helios24 has joined.
22:00:02 -!- FabioNET has quit ("goooood night tox").
22:05:51 -!- ihope has changed nick to naIioth.
22:05:59 -!- naIioth has changed nick to ihope.
22:16:11 -!- sebbu2 has changed nick to sebbu.
22:17:36 -!- GreaseMonkey has joined.
22:17:40 <GreaseMonkey> ;> #"87*3+,'>,' ,'#,ff+4+,>:#,_ff+4+,87*3+,'#,'0,'<,@";#0<
22:18:01 <GreaseMonkey> (quine in befunge-98)
22:18:26 <oklopol> 1d?
22:19:03 <GreaseMonkey> well, unefunge-98, but can be run in befunge-98 or trefunge-98
22:19:44 <oklopol> coools
22:19:47 <oklopol> you made it?
22:19:52 <GreaseMonkey> yep
22:19:55 <oklopol> [00:14:23] * GreaseMonkey has joined #esoteric
22:19:55 <oklopol> [00:14:26] <GreaseMonkey> ;> #"87*3+,'>,' ,'#,ff+4+,>:#,_ff+4+,87*3+,'#,'0,'<,@";#0<
22:19:56 <GreaseMonkey> i'm working on a befunge98 interpreter
22:19:58 <oklopol> in 3 secs?
22:20:09 <GreaseMonkey> nah, i copy-pasted from a file
22:20:11 <oklopol> oh
22:20:14 <GreaseMonkey> which i made fyi
22:20:17 <oklopol> that's a dissappoinment
22:21:07 <oklopol> befunge-98 is n-dimensional?
22:31:10 <GreaseMonkey> befunge-98 = 2D
22:31:23 <GreaseMonkey> but can emulate unefunge, which = 1D
22:31:32 <GreaseMonkey> actually
22:31:33 -!- CakeProphet has joined.
22:31:49 <CakeProphet> :(
22:32:00 <GreaseMonkey> befunge runs unefunge as-is, unless someone's being a bastard and they set up a trap
22:32:24 * bsmntbombdood got SICP from the library today
22:33:19 * oerjan wonders if oklopol has a bit too high expectations
22:33:21 <GreaseMonkey> like: ;@,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,"its unefunge not befunge you git";# ](code goes here)
22:46:54 <ihope> Say, how's SOAP coming along?
22:49:13 * oerjan wonders if SOAP shouldn't be written in Clean...
22:51:10 <ihope> Wonderful...
22:54:14 <CakeProphet> hrm
22:54:59 * CakeProphet could use bits of his half-developed MUD codebase for the user-end/event stuff.
22:58:15 * oklopol feels like /meing
22:58:43 * ihope does too
23:00:40 * oklopol goes to bed now ->
23:09:51 -!- GreaseMonkey has quit (Nick collision from services.).
23:10:12 -!- GreaseMonkey has joined.
23:10:14 <GreaseMonkey> oops
23:23:22 <ihope> Do not /nickserv GHOST yourself.
23:25:30 <bsmntbombdood> eh
23:25:32 <bsmntbombdood> heh
23:28:22 <GreaseMonkey> whyzat?
23:28:26 <GreaseMonkey> wait
23:28:38 <GreaseMonkey> no, i got disconnected
23:29:19 <GreaseMonkey> !ctcp #esoteric ACTION is having fun
23:29:38 <GreaseMonkey> bugger
23:30:08 <oerjan> You need \001 characters
23:30:15 <bsmntbombdood> bsmnt_bot: do what you're told
23:30:39 <oerjan> or maybe not.
23:30:50 <bsmntbombdood> ~ctcp #esoteric ACTION FOOF
23:30:51 * bsmnt_bot FOOF
23:34:46 <GreaseMonkey> OH
23:34:55 <GreaseMonkey> ah, i know why you use ~ instead
23:35:00 <bsmntbombdood> egobot
23:35:56 <GreaseMonkey> http://greasemonkey.shadowarts.org/befunge98-r002.zip - a kinda incomplete but still very useable befunge-98 interpreter, comes with examples, what's implemented, what's not, etc.
23:36:01 <GreaseMonkey> oh, and source
23:39:11 <GreaseMonkey> ;> #"87*3+,'>,' ,'#,ff+4+,>:#,_ff+4+,87*3+,'#,'0,'<,@";#0<
23:39:15 <GreaseMonkey> my quine :D
23:40:00 <GreaseMonkey> i believe that daemons should be coded in a funge
23:40:32 <GreaseMonkey> befunge-98 preferably - that's about as expandable as befunge gets
23:41:12 * oerjan recalls a norwegian fantasy book in which daemons were six-dimensional creatures
23:42:02 <GreaseMonkey> 4D is enough for me
23:42:27 <GreaseMonkey> why, have you used hexefunge?
23:43:28 <oerjan> Always use hexefunge for your magical programming!
23:44:33 <GreaseMonkey> man, that'd be frikkin intense
23:44:55 <oerjan> (btw the answer is no)
23:45:20 <GreaseMonkey> i think trefunge is intense enough, and i haven't even tried it
23:47:26 <GreaseMonkey> >;        ;v
23:47:26 <GreaseMonkey> v"## # # "0<
23:47:26 <GreaseMonkey> >:#,_;    ;^
23:48:02 <GreaseMonkey> that puts REALLY weird effects on your screen
23:52:40 <GreaseMonkey> afk food

2007-01-23:

00:17:38 -!- LeaLeaLea has joined.
00:17:57 <LeaLeaLea> I COME SEEKING CAKEPROPHET.
00:18:37 <CakeProphet> WHO
00:18:39 <CakeProphet> A
00:18:40 <CakeProphet> LIEK
00:18:42 <CakeProphet> HI
00:18:50 * CakeProphet tells some prophesy
00:18:55 <CakeProphet> about... hrm..
00:19:02 <oerjan> cake?
00:19:02 <CakeProphet> IN FOUR DAYS THERE WILL BE SOURDOUGH BREAD.
00:19:08 <CakeProphet> l
00:19:14 <oerjan> ahem. bread is not cake.
00:19:15 <CakeProphet> hmmm... I just typed "look"
00:19:24 -!- CakeProphet has changed nick to SevenInchBread.
00:19:35 <SevenInchBread> The guise of cake is merely an illusion over bread.
00:19:39 <LeaLeaLea> You HUGE nerd.
00:19:40 -!- SevenInchBread has changed nick to CakeProphet.
00:19:59 <LeaLeaLea> I TIRE OF YOUR BREAD RELATED NICKNAMES.
00:20:09 <CakeProphet> hmm... lemme pull up the list.
00:20:54 <CakeProphet>  1) CakeProphet
00:20:56 <CakeProphet> 2) GrandmotherChaos
00:20:57 <CakeProphet> 3) GrandfatherSoul
00:21:10 <CakeProphet> 4) notCakeProphet
00:21:10 <CakeProphet> 5) SevenInchBread
00:21:10 <CakeProphet> 6) MotherNature
00:21:10 <CakeProphet> 7) DaughterLove
00:21:10 <CakeProphet> 8) FatherTime
00:21:10 <CakeProphet> 9) SonMind
00:21:10 <CakeProphet> pick
00:21:19 <oerjan> NoneOfTheAbove
00:21:25 <CakeProphet> hrm..
00:21:29 <CakeProphet> I hate you.
00:21:33 <CakeProphet> is egobot still down?
00:21:35 <CakeProphet> !help
00:21:36 <oerjan> you asked for it :)
00:21:48 * CakeProphet whines some more about egobot being down.
00:22:37 <CakeProphet> LeaLeaLea, YOUR VISIT IS MERELY REPUTATIONAL
00:22:40 <CakeProphet> YOU DO NOT CARE
00:22:43 <CakeProphet> ABOUT US
00:22:46 <LeaLeaLea> WHAT THE HELL.
00:22:49 <LeaLeaLea> Also.
00:22:53 <CakeProphet> YOUR JUST A POPULARITY PRINCESS
00:22:55 <CakeProphet> hrm?
00:22:59 <LeaLeaLea> Where is all the bitches.
00:23:12 <CakeProphet> I do not know where all the bitches is at
00:23:18 <LeaLeaLea> You better be findin' the bitches.
00:23:25 <CakeProphet> !bitches
00:23:35 * LeaLeaLea becomes incensed.
00:23:46 <CakeProphet> oh... I thought you said "incested"
00:23:52 <bsmntbombdood> what?
00:23:53 * LeaLeaLea also lights some incense.
00:23:55 <oerjan> oh no, the frankincense monster
00:24:03 <LeaLeaLea> WHY ELLO BSMNTBOMBDOOD
00:24:06 * CakeProphet lights some incest.
00:24:06 <LeaLeaLea> ..Hm
00:24:15 <LeaLeaLea> Leaving off the H in hello was not intentional.
00:24:34 <CakeProphet> GregorR,  fix egobot or I'll choke your goat
00:24:38 <LeaLeaLea> He will.
00:24:39 <CakeProphet> it made you sound pixie... or elvish
00:24:43 <CakeProphet> actually a hobbit
00:24:46 <LeaLeaLea> He choked my goat once. 
00:24:49 <LeaLeaLea> She never recovered.
00:24:56 <LeaLeaLea> Poor Wednesday.
00:25:11 <CakeProphet> ....hrm
00:25:19 <CakeProphet> I wish I had a goat
00:25:21 <CakeProphet> like Wednesday.
00:25:30 <LeaLeaLea> .. MOVING RIGHT ALONG. There are two people besides (Insert any one in an array bread product nicks here) speaking today.
00:25:45 <CakeProphet> scandalous
00:26:02 * CakeProphet still needs to fix his borken internets.
00:26:14 <LeaLeaLea> Damn those borken nets..
00:28:08 * SimonRC barges back in
00:28:21 <SimonRC> Have you lot heard of _The Eye Of Argon_?
00:28:54 <SimonRC> Well I have found something a bit like it:
00:28:58 <LeaLeaLea> Nope.
00:29:07 <CakeProphet> ...what?
00:29:11 <CakeProphet> describe this eye
00:29:58 <SimonRC> Oh, it's the worst amature sword-and-sourcery story ever (partly-) written.
00:30:02 <SimonRC> google it
00:30:11 <SimonRC> anyway, the thing I have found is a book:
00:30:15 <SimonRC> "The world is full of bad books written by amateurs. But why settle for the merely regrettable? Atlanta Nights is a bad book written by experts."
00:30:29 <LeaLeaLea> ..Hmm.
00:30:33 <SimonRC> It was written as a sting by some writers against a publisher
00:30:37 <CakeProphet> sounds like scholarly nerd humor
00:30:43 * CakeProphet prompt gets it.
00:31:03 <LeaLeaLea> CakeProphet?
00:31:08 <CakeProphet> ?
00:31:10 <LeaLeaLea> CakeProphet??
00:31:11 <CakeProphet> yah?
00:31:13 <CakeProphet> yah?
00:31:13 * LeaLeaLea refuses to tell.
00:31:17 <oerjan> Error: No parse
00:31:29 <CakeProphet> LOLCODERHUMOR
00:32:02 <CakeProphet> ...if I had linux working I could probably compile erm... egobot.
00:33:27 <LeaLeaLea> If I had linux I would hit you in the face.
00:33:59 <CakeProphet> LeaLeaLea,  linux can send people through my monitor?
00:34:07 <CakeProphet> and here I thought the whole linux thing was just hype.
00:34:53 <LeaLeaLea> Linux has infinite capabilites, MANY MORE than Windows! I heard, with Redhat you can stab wily opponants in the heart with a poisonous barb with the click of a button.
00:35:12 <CakeProphet> lol redhat is lame
00:35:24 <LeaLeaLea> lol cakeprophet fuckoff
00:35:30 <LeaLeaLea> ...
00:35:35 <LeaLeaLea> ..CakeProphet
00:35:35 <CakeProphet> WINDOWS USER ARGH
00:35:44 <CakeProphet> and also... MY TEXT EDITOR IS SUPERIOR TO YOURS
00:35:47 <LeaLeaLea> YOU FUCKING WISH
00:35:48 <CakeProphet> AND C IS SUPERIOR TO JAVA
00:35:53 <LeaLeaLea> ..Well, yes.
00:36:06 <bsmntbombdood> obviously
00:36:12 <CakeProphet> lol yah, but c is for homosexual people.
00:36:22 <LeaLeaLea> HENCE WHY YOU SING IT'S PRAISES.
00:36:28 <LeaLeaLea> So.
00:36:30 <CakeProphet> OMFG YOU GOT ME
00:36:30 <LeaLeaLea> I enjoy juice.
00:36:36 <CakeProphet> hmm...
00:36:37 <LeaLeaLea> OMFG LIEK I NO M8
00:36:38 <CakeProphet> too much juice though
00:36:40 <LeaLeaLea> Want some juice?
00:36:41 <CakeProphet> is bad
00:36:43 <LeaLeaLea> I can give you some.
00:36:54 <CakeProphet> too much juice makes your tongue sore
00:37:06 <LeaLeaLea> If I had linux I could send you juice from across the internets.
00:37:18 <CakeProphet> yeah but you don't lol
00:37:28 <LeaLeaLea> OH HO. 
00:37:31 <LeaLeaLea> Also.
00:37:31 <GregorR> Am I the only person who would love to find a working development environment for Windows 1.0? :P
00:37:33 -!- sebbu2 has joined.
00:37:35 <LeaLeaLea> Stop using my chatspeak thing.
00:37:53 <CakeProphet> hI Gregor. :D
00:38:09 <CakeProphet> what chatspeak thing?  ? D ?D? LD ?LO LOLNOOB
00:38:19 <GregorR> 'lo
00:38:23 <CakeProphet> so..
00:38:27 <LeaLeaLea> Hello Signore GregoR with the inexplicable yet oddly alluring capital R. 
00:38:28 <CakeProphet> you should...
00:38:30 <CakeProphet> like
00:38:36 <CakeProphet> fix egobot
00:38:41 <CakeProphet> >.>
00:38:45 <LeaLeaLea> You can't make him.
00:38:50 <CakeProphet> can too
00:38:52 <LeaLeaLea> Can't.
00:38:57 <CakeProphet> I'll give him smurf porn in exchange
00:39:03 <LeaLeaLea> ..Hm.
00:39:05 <CakeProphet> call it a fair bargain if you will..
00:39:06 <LeaLeaLea> Thwarted.
00:39:38 <CakeProphet> smurf porn would be like bukkake
00:39:51 <CakeProphet> because there's only one, synthetically created smurf woman.
00:40:30 <GreaseMonkey> back
00:40:40 <CakeProphet> lol i bet you wear eyeliner like a noob lea
00:40:46 <LeaLeaLea> Yep.
00:40:47 <LeaLeaLea> Also
00:40:53 <CakeProphet> haha
00:40:58 <CakeProphet> you shouldn't
00:41:11 <LeaLeaLea> I never did send you my Smurf Village analysis story.
00:41:14 <LeaLeaLea> Like I said I would.
00:41:19 <LeaLeaLea> ..Or the poem that followed..
00:41:22 <CakeProphet> you never said you would
00:41:28 <CakeProphet> I've never even heard of it.
00:41:38 <LeaLeaLea> Oh ho ho.
00:41:42 -!- EgoBot has joined.
00:41:43 <LeaLeaLea> I KEEP LOGS, KURT.
00:41:51 <LeaLeaLea> ... So
00:41:53 <LeaLeaLea> This has become..
00:41:59 <LeaLeaLea> Strangely uninteresting..
00:42:06 <LeaLeaLea> Though at least egobot is apparantly here
00:42:09 <bsmntbombdood> tits or gtfo
00:42:12 <GregorR> Must ... find ... Windows 1.0 development libraries ...
00:42:16 <LeaLeaLea> :o
00:42:22 <GreaseMonkey> wtf egypts
00:42:47 <CakeProphet> !help
00:42:49 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
00:42:49 <CakeProphet> yah
00:42:51 <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:42:53 <CakeProphet> LeaLeaLea,  ...I never saw it
00:43:00 <LeaLeaLea> ..Yeah. I said that.
00:43:26 * LeaLeaLea engages in forcula battle with CakeProphet.
00:43:31 <CakeProphet> !glass {M[m(_o)O! "Nope"(_o)o.?]}
00:43:35 <EgoBot> Nope
00:43:37 <CakeProphet> THWARTED
00:43:48 <LeaLeaLea> ..Hmmm.
00:45:51 <CakeProphet> That was the ENTIRE reason I wanted egobot up
00:45:54 <CakeProphet> just so I could do that.
00:45:57 * CakeProphet is content now.
00:47:24 <CakeProphet> !glass {M[m(_o)O!((_a)A!(_noob)<40>=/(_noob) "Nope "(_o)o.?(_noob)<1>(_a)s.?\]}
00:47:27 <EgoBot> Nope 
00:47:33 <CakeProphet> ...
00:47:38 <GreaseMonkey> !funge93 0".os kniht t'nod I">:#,_@
00:47:41 <EgoBot> I don't think so.
00:48:16 <GreaseMonkey> i love befunge :D
00:48:54 <CakeProphet> !glass {M[m(_o)O!((_a)A!(_noob)<10>=/(_noob) "Nope "(_o)o.?(_noob)<1>(_a)s.?\]}
00:48:57 <EgoBot> Nope 
00:49:02 <CakeProphet> hmmm...
00:49:24 <oerjan> !unlambda ```````````````.C.a.n. .I. .j.o.i.n. .i.n.?ri
00:49:27 <EgoBot> Can I join in?
00:49:54 <GreaseMonkey> !funge93 0"daeha oG">:#,_@
00:49:59 <EgoBot> Go ahead
00:51:41 <CakeProphet> !glass {M[m(_o)O!((_a)A!(_s)S!(_noob)<10>=(_hehe)"Nope "=/(_noob) (_hehe)(_hehe)"Nope "(_s)a.?=(_noob)<1>(_a)s.?\(_hehe)(_o)o.?]}
00:51:42 <CakeProphet> ahoy
00:52:22 <oerjan> !unlambda `r`..`.u`.o`.y`. `.k`.n`.a`.h`.Ti
00:52:25 <EgoBot> Thank you.
00:53:33 <CakeProphet> !glass {M[m(_o)O!((_a)A!(_s)S!(_noob)<10>=(_hehe)"Nope "=/(_noob) (_hehe)(_hehe)*"Nope "(_s)a.?=(_noob)(_noob)*<1>(_a)s.?=\(_hehe)(_o)o.?]}
00:53:39 <CakeProphet> htm..
00:54:01 <CakeProphet> LeaLeaLea hates us.
00:54:03 <CakeProphet> you can tell
00:54:09 <LeaLeaLea> Wtf do you want..
00:54:10 <oerjan> You've got a (( in there.
00:54:11 <CakeProphet> by the look in her eyes...
00:54:11 <LeaLeaLea> Oh.
00:54:16 <LeaLeaLea> I hate the random pinging.
00:54:17 <CakeProphet> see?
00:54:20 <CakeProphet> yeah.
00:54:21 <LeaLeaLea> ..That isn't random at all..
00:54:22 <CakeProphet> well
00:54:24 <CakeProphet> LeaLeaLea
00:54:26 <LeaLeaLea> SHUT UP
00:54:29 <CakeProphet> NOPE
00:54:31 <LeaLeaLea> CakeProphet: 
00:54:33 <LeaLeaLea> .. FUCK
00:54:38 <CakeProphet> I turned off the orange blinking thing
00:54:43 <LeaLeaLea> Oh. 
00:54:47 <LeaLeaLea> THWARTED
00:54:49 <CakeProphet> forgot how though...
00:54:53 <LeaLeaLea> CakeProphet
00:55:06 <LeaLeaLea> CakeProphet?
00:55:08 <CakeProphet> ?
00:55:09 * LeaLeaLea refuses to tell.
00:55:10 <CakeProphet> yah?
00:55:35 * CakeProphet should learn befunge.
00:55:59 <CakeProphet> SO WHAT'S EVERYBODY DOING?
00:56:25 -!- sebbu has quit (Connection timed out).
00:57:01 <LeaLeaLea> ..Oh
00:57:03 <LeaLeaLea> I was ignoring you.
00:57:17 <CakeProphet> ...
00:57:28 <CakeProphet> I was just busy PLANNING LEA'S DEMISE
00:57:36 <CakeProphet> !help
00:57:36 <LeaLeaLea> .. :)
00:57:39 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
00:57:41 <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:57:42 <LeaLeaLea> STOP TYPING THAT
00:57:48 <LeaLeaLea> I wish Egobot would die.
00:57:50 <CakeProphet> I FORGOT THE BEFUNGE COMMAND
00:57:52 <CakeProphet> FUCK YOU
00:57:56 <LeaLeaLea> ..... :)
00:58:46 <LeaLeaLea> I should go inhale the noxious and poisonous fumes of a small white cylinder laden with nicotine.
00:58:48 <LeaLeaLea> ... Afk
00:59:01 <CakeProphet> omfg smoker
00:59:08 <CakeProphet> stop smoking dirty smoker
00:59:13 * CakeProphet throws cans.
01:01:55 <bsmntbombdood> holy crap
01:01:55 <CakeProphet> !funge93 "If I were a mushroom..."#@,
01:01:58 <CakeProphet> no
01:02:04 <CakeProphet> !funge93 "If I were a mushroom..."#@,<
01:02:06 <bsmntbombdood> Some guy's name is "Haskell Curry"
01:02:07 <EgoBot> ..
01:02:07 <CakeProphet> !ps
01:02:10 <bsmntbombdood> How fucking awesome is that
01:02:11 <EgoBot> 1 CakeProphet: ps
01:03:50 <CakeProphet> !funge93 0"If I were a mushroom..."#@,<
01:03:53 <EgoBot> ..
01:03:54 <CakeProphet> ...
01:04:21 <CakeProphet> !funge93 0"If I were a mushroom..."#@,# <
01:04:23 <EgoBot> .
01:04:26 <CakeProphet> .
01:04:35 <CakeProphet> IT TAUNTS ME
01:04:38 * CakeProphet faisl at befunge.
01:04:42 <GreaseMonkey> !funge93 "If I were a mushroom...">:#,_@
01:04:44 * CakeProphet reads the specification again.
01:04:45 <EgoBot> ...moorhsum a erew I fI
01:04:50 <CakeProphet> ...
01:04:54 <GreaseMonkey> flip it around...
01:04:59 <CakeProphet> why did you need to tell it to go the direction it was alread going?
01:05:12 <oerjan> Haskell Brooks Curry, to be precise.
01:05:12 <GreaseMonkey> !funge93 "...moorhsum a erew I fI">:#,_@
01:05:15 <EgoBot> If I were a mushroom...
01:05:25 <GreaseMonkey> cos the _ bounces it back
01:06:14 <bsmntbombdood> oerjan: He must have done a lot to get two different things named after him
01:06:30 <GreaseMonkey> _ in C: if(pop_from_stack()==0){go_right();}else{go_left();}
01:06:31 <oerjan> Just two?
01:06:47 <bsmntbombdood> ...
01:06:57 <CakeProphet> !funge93 "rekoms ytrid a si ea",@
01:06:59 <EgoBot> a
01:07:04 <bsmntbombdood> What else, then?
01:07:06 <oerjan> They first wanted to call the Haskell language Curry but then thought of all the bad jokes
01:07:07 <CakeProphet> oooh
01:07:17 <CakeProphet> the stack is character by character
01:07:18 <CakeProphet> gotcha
01:07:37 <oerjan> But later someone made the Curry language too
01:07:40 <GreaseMonkey> indian characters?
01:08:01 <CakeProphet> !funge93 "rekoms ytrid a si eaL">#,_@
01:08:02 <oerjan> and there is of course currying, which should have been schonfinkeling :)
01:08:04 <bsmntbombdood> I thought of Curry as in function currying
01:08:05 <EgoBot> a
01:08:10 <CakeProphet> FUCK YOU EGOBOT
01:08:22 <oerjan> Curry, anyhow, invented combinatory logic
01:08:28 -!- sebbu2 has quit ("@+").
01:08:33 <GreaseMonkey> !funge93 "rekoms ytrid a si eaL">:#,_@
01:08:35 <EgoBot> Lae is a dirty smoker
01:08:38 <GreaseMonkey> the : is a duplicator
01:08:49 <CakeProphet> but why do you need to duplicate?
01:08:50 <GreaseMonkey> sweet, i bags we make that a daemon
01:09:05 <GreaseMonkey> cos the _ function takes the top value off
01:09:16 <CakeProphet> aha
01:09:33 <CakeProphet> !funge93 22+.@
01:09:35 <EgoBot> 4 
01:09:39 <CakeProphet> I have mastered befunge!!!
01:09:42 <CakeProphet> by... adding 2 and 2
01:10:49 <CakeProphet> hrm... is it possible to do multiline befunge programs with egobot?
01:10:52 <LeaLeaLea> Mmmm.
01:11:12 <oerjan> if you use a URL.
01:11:21 <CakeProphet> to a...?
01:11:31 <oerjan> to a befunge program
01:11:46 * CakeProphet heckles Lea some more about smoking in an overtly satirical manner.
01:11:52 <CakeProphet> I think we should harass fat people some more.
01:12:09 <CakeProphet> ...like we do smokers.
01:12:14 <oerjan> be careful with that, they might sit on you.
01:12:35 * CakeProphet is a very small... person.
01:12:38 * oerjan already weighs more than he is comfortable with.
01:12:41 <CakeProphet> I would be ded
01:13:29 * LeaLeaLea flicks ash at CakeProphet.
01:13:55 <CakeProphet> oh noes
01:13:58 <LeaLeaLea> ONOES
01:13:59 * oerjan wonders if Marie Antoinette is a saint in the CakeProphet religion
01:14:03 <LeaLeaLea> ..Hm.
01:14:11 <CakeProphet> I forgot who that was...
01:14:13 <LeaLeaLea> A fair and just inquiry.
01:14:20 <oerjan> "Let them eat cake"
01:14:36 <oerjan> (Except she never really said that)
01:14:39 <CakeProphet> !funge93 "gmo",,,@
01:14:43 <EgoBot> omg
01:14:52 <LeaLeaLea> Boy did she ever pay for it, though.
01:14:58 <GreaseMonkey> !funge93 0"rekoms ytrid a si eaL">:#,_@
01:15:01 <EgoBot> Lae is a dirty smoker
01:15:10 <GreaseMonkey> !funge93 0"rekoms ytrid a si aeL">:#,_@
01:15:11 <LeaLeaLea> EgoBot cannot spell Lea, and thus renders her immune.
01:15:13 <EgoBot> Lea is a dirty smoker
01:15:16 <LeaLeaLea> OH HO
01:15:18 <CakeProphet> I am unable to spell backwards...
01:15:33 <oerjan> b a c k w a r d s. there.
01:15:34 <GreaseMonkey> !funge93 0"ufts ro stob ot ecin eb">:#,_@
01:15:37 <EgoBot> be nice to bots or stfu
01:15:43 <LeaLeaLea> NOPE.
01:15:55 <CakeProphet> ...
01:16:09 <GreaseMonkey> !funge93 0"rekoms ytrid uoy ufts">:#,_@
01:16:11 <EgoBot> stfu you dirty smoker
01:16:14 <LeaLeaLea> .. oh my.
01:16:42 <GreaseMonkey> !funge93 01"yldab shguoc NOITCA"1>:#,_@
01:16:45 * EgoBot coughs badly
01:18:22 <GreaseMonkey> !funge93 01"VERSION"1>:#,_@
01:18:35 <GreaseMonkey> !funge93 01"NOISREV"1>:#,_@
01:18:36 <oerjan> :D
01:18:48 <GreaseMonkey> i wonder what that'd do...
01:19:34 <GreaseMonkey> i bags that we use mIRC / irssi / whatever scripts so when we get versioned we automatically /msg !funge93 01"NOISREV"1>:#,_@ to egobot
01:20:18 <CakeProphet> !funge93  >"whooo"#,_?@
01:20:23 <EgoBot> o
01:20:28 <CakeProphet> FUCK
01:20:29 <CakeProphet> YOU
01:20:56 <CakeProphet> !funge93  >"whooo",?@
01:20:59 <EgoBot> ooooo
01:21:02 <CakeProphet> !funge93  >"whooo",?@
01:21:05 <EgoBot> ooo
01:21:08 <CakeProphet> !funge93  >"whooo",?@
01:21:11 <EgoBot> o
01:21:17 <bsmntbombdood> Ok, new channel: ##functional 
01:21:38 <CakeProphet> !funge93  >"whooo",?#@?#
01:21:41 <EgoBot> o
01:22:17 <CakeProphet> !funge93  >"whooo",?#,_@
01:22:30 * CakeProphet ...waits
01:22:30 -!- ihope has quit (Connection timed out).
01:22:58 <CakeProphet> !funge93  >"whooo"?#,_@
01:22:58 -!- LeaLeaLea has quit ("Chatzilla 0.9.77 [Firefox 1.5.0.9/2006120612]").
01:23:05 <EgoBot> oohoooohoohoohoohoooooohoohoohoohoooooooooooooooooohoohoooooooohoooohoooohoooooohoooooooohoohoohoohoooooooohoooohoooooohoohoooohoooohoohoooohoohoooohoooooohoooooohoooooohoooohoohoooooooooooooooooooohoohoohoooooooohoohoooooooooohoohoooooohoooooohoohoohoooohoohoohoohoohoooohoooohoohoohoohoooohoooooooooohoooooooooooohoohoooooooooohoohoooohoooohoohoohoooohoohoooooooooooohoooooohoooo
01:23:06 <CakeProphet> !ps
01:23:07 <EgoBot> 1 CakeProphet: ps
01:23:09 <CakeProphet> yay
01:23:09 <EgoBot> 2 CakeProphet: funge93
01:23:15 <EgoBot> ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
01:23:24 <CakeProphet> !ps
01:23:27 <EgoBot> 1 CakeProphet: ps
01:23:38 <CakeProphet> !funge93  >"Do you see?"?#,_@
01:23:49 <EgoBot> eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
01:24:25 <CakeProphet> !funge93  >"Do you see?"?:#,_@
01:24:32 <GreaseMonkey> !funge93 0"righty">#,:# _#:<
01:24:44 <GreaseMonkey> !funge93 0"righty">#,:# ?#:<
01:24:54 <oerjan> !ps
01:24:55 <EgoBot> 1 oerjan: ps
01:24:58 <EgoBot> 2 GreaseMonkey: funge93
01:24:59 <EgoBot> 3 GreaseMonkey: funge93
01:25:40 <CakeProphet> !funge93  >"Do you see?"?>:#,_@
01:25:41 <EgoBot> ?ees uoy oDDo you see??ees uoy oDDo you see??ees uoy oDDo you see??ees uoy oD
01:25:47 -!- pikhq has joined.
01:25:51 <CakeProphet> !funge93  >"Do you see? "?>:#,_@
01:25:53 <EgoBot>  ?ees uoy oD
01:25:55 <CakeProphet> !funge93  >"Do you see? "?>:#,_@
01:25:57 <EgoBot>  ?ees uoy oD
01:25:59 <CakeProphet> !funge93  >"Do you see? "?>:#,_@
01:26:01 <EgoBot>  ?ees uoy oD
01:26:05 <CakeProphet> ...
01:26:07 <CakeProphet> !funge93  >"Do you see? "?>:#,_@
01:26:07 <EgoBot> y
01:26:09 <EgoBot>  ?ees uoy oDDo you see?  ?ees uoy oD
01:26:11 <EgoBot> y
01:26:19 <CakeProphet> !funge93  >"Do you see? "?>:#,_@
01:26:21 <EgoBot>  ?ees uoy oDDo you see?  ?ees uoy oD
01:26:22 <GreaseMonkey> !funge93 :0g:84*-!#@_801p0>_#":2%86*+\2/01g1-:01p0\#"_$$,,,,,,,,1+
01:26:25 <EgoBot> 001110100011000001100111001110100011100000110100001010100010110100100001001000110100000001011111001110000011000000110001011100000011000000111110010111110010001100100010001110100011001000100101001110000011011000101010001010110101110000110010001011110011000000110001011001110011000100101101001110100011000000110001011100000011000001011100001000110010001001011111001001000010010000101
01:26:56 <CakeProphet> !funge93  >"001010101010101010101010111011011000101011101010010101011010100101 "?>:#,_@
01:26:59 <EgoBot>  101001010110101010010101110101000110110111010101010101010101010100001010101010101010101010111011011000101011101010010101011010100101  101001010110101010010101110101000110110111010101010101010101010100
01:27:21 <oerjan> !ps
01:27:23 <EgoBot> 1 oerjan: ps
01:27:24 <pikhq> !funge93 >"!dlorw ,olleH"?>:#,_@
01:27:27 <EgoBot> Hello, wrold!
01:27:32 <pikhq> XD
01:27:38 <pikhq> !funge93 >"!dlrow ,olleH"?>:#,_@
01:27:41 <EgoBot> Hello, world!!dlrow ,olleHHello, world!!dlrow ,olleHHello, world!!dlrow ,olleHHello, world!
01:27:48 <pikhq> . . .
01:28:22 <CakeProphet> !funge93  >"001010"?"10101"?"010101010"?"10"#?"10111011011000101011"?#"101010010101"?"01"?"1010100101"?>:#,_@
01:28:25 <EgoBot> 0101010100
01:28:29 <GreaseMonkey> >"olleH"?:#,_@
01:28:58 <GreaseMonkey> 0>"olleH"?:#,_@
01:29:01 <CakeProphet> !funge93  >"001010"?"10101"?"010101010"?"10"#?"10111011011000101011"?#"101010010101"?"01"?"1010100101"?>:#,_@
01:29:03 <GreaseMonkey> !funge93 0>"olleH"?:#,_@
01:29:03 <EgoBot> 0101010100001010
01:29:27 <EgoBot> HeHHHHelHeHeHHellHeHeHHHeHelloolleHlHeHeHeHHHeHeHellHHHHeHHeHeHeHHeHeHeHHHeHeHHHelHelloHHHHHellHeHellHelHelloolHHHelHHelHelHeHHHeHHHHeHHeHeHellHellooHHeHeHHHHeHeHHellHeHelloollHelHeHelloollHHellHellooHHHeHeHeHelHHHHHHeHeHHelHelHelHHHHHHHeHelHeHellHHeHHeHHelHeHHeHHHeHelloHeHeHHHelHelHHHHeHHellHHHHHHeHeHHHHHellHeHelHHHellooHeHHHeHelHeHeHHeHeHHHellHHHHellHellHHHeHHHHeHHHelHHHHelHHH
01:30:04 <CakeProphet> !funge93  >"00 1 010"?"10 10"#?"  1"?" 010 1  0 1 010" ?"10 "#?" 10 1 1 1 0110 11 00 01 01011"?#"101010010101"?"01"?"1010100101"?>:#,_@
01:30:23 -!- oerjan has quit ("Good night.").
01:30:31 * CakeProphet likes conditionally skipping string mode on number strings.
01:32:07 <CakeProphet> anyone want to make a huge esolang.
01:32:30 <CakeProphet> with literally hundreds of operators and syntax forms?
01:33:03 <CakeProphet> simple is fun and awesomely beautiful.... but sometimes I like to play around with languages like homespring. :?D
01:35:58 * CakeProphet calls upon the aid of the Adjudicated Blind Collaborative Design Esolang Factory to perform this task.
01:38:21 <GreaseMonkey> sure
01:38:25 <pikhq> Dear God. . .
01:38:37 <GreaseMonkey> i reckon that brainfuck needs more instructions to be practical
01:38:39 <pikhq> Make the factory have, say, *rules*.
01:38:59 <GreaseMonkey> #1: People with nonlogic accounts make the rules. ;D
01:39:06 <GreaseMonkey> hehe, jk
01:39:27 <CakeProphet> rules... what?
01:39:32 <pikhq> I like that one.
01:39:40 <CakeProphet> #1: huh?
01:39:44 <CakeProphet> that's the only rule.
01:39:50 <pikhq> Of course, that's because I'm only Leibniz.
01:39:50 <CakeProphet> THE MOST IMPORTANT ONE
01:39:51 <GreaseMonkey> LeaLeaLea = Witt
01:39:57 <CakeProphet> who?
01:40:42 <pikhq> Leibniz is the name of the Nonlogic server.
01:40:52 <GreaseMonkey> pikhq: i would suggest that you stick some more stuff on your site
01:41:08 <CakeProphet> Who's witt?
01:41:25 <pikhq> GreaseMonkey: If I had the time, I would.
01:41:32 <pikhq> (I'll probably do that over spring break)
01:41:51 <pikhq> At the moment, all it's got is an outdated spec for BFM.
01:42:00 <pikhq> (the *current* BFM spec is in bfm.tar.bz2)
01:42:33 <GreaseMonkey> oh ok
01:42:54 <GreaseMonkey> yeah, there's a lot of stuff lying around unused in your home dir
01:43:04 <pikhq> Indeed.
01:43:29 <pikhq> I'm lazy, HTML-wise.
01:43:37 <pikhq> As proven if you look at the source to my page. . .
01:43:47 <CakeProphet> good ol' .txt files win.
01:43:54 <GreaseMonkey> meh, looking at my page, i'm just lazy
01:44:05 <pikhq> greasemonkey.nonlogic.org?
01:44:11 <GreaseMonkey> yep
01:44:14 <GreaseMonkey> but it's VALID HTML 4.01!!! WOOT!!!!
01:44:18 <pikhq> Same here.
01:44:25 <GreaseMonkey> HTML 4.01 transitional, i meant
01:44:36 <pikhq> I'm HTML 4.01 strict and CSS 2.
01:44:45 <GreaseMonkey> dam yo
01:45:15 <pikhq> And you really need to get a new Seagate drive.
01:45:20 * pikhq <3 Seagate drives
01:45:38 <GreaseMonkey> hmm, yeah, i'm seeing if we can sort the prob out
01:45:48 <GreaseMonkey> i've asked someone about the samsung
01:45:51 <GreaseMonkey> so what's the gnuchess for?
01:47:17 <pikhq> I was *trying* to compile GNU Chess so I could play chess during my Cisco class.
01:50:13 <GreaseMonkey> oh ok
01:50:17 <GreaseMonkey> nice
01:50:27 <pikhq> Needed to install flex and bison. . .
01:50:31 <pikhq> Which didn't work out.
01:50:43 <pikhq> (GNU Chess, that is)
01:52:39 <GreaseMonkey> bummer - FYB's interpreter is dodgy (under Windows at least)
01:54:13 <CakeProphet> l
01:54:30 <pikhq> Compile using Cygwin?
01:57:55 <SimonRC> #23: If you are a security guard for a vast, powerful corporation, try to get assigned to the Marketing or Personnel departments, rather than R&D.
01:58:00 <SimonRC> http://web.archive.org/web/20050810082607/enphilistor.users4.50megs.com/innocent.htm
01:58:14 <SimonRC> #22 even
01:58:36 <GreaseMonkey> afk food
02:02:59 -!- calamari has joined.
02:10:30 -!- pikhq has quit (Read error: 145 (Connection timed out)).
02:29:46 <GreaseMonkey> back
02:29:57 <GreaseMonkey> man, they SO should have implemented NetFunge
02:30:59 <lament> who they
02:31:09 <lament> I saw cpressey and his wife today
02:31:23 <GreaseMonkey> cpressey ftw
02:35:43 -!- pikhq has joined.
02:39:16 <GreaseMonkey> !glass {B[b<99>^]}{P[(c__)oO!t$aA!][n<10>s(ns).?oo.?][poo.?tn.?][b(_m)1=,(_x)<0>
02:39:16 <GreaseMonkey> (_m)*ae.?=(_y)<1>=/(_x)"No more"oo.?(_x)0=(_y)0=\/(_y)(_m)*o(on).?(_y)0=\
02:39:16 <GreaseMonkey> " bottle"oo.?(_x)<1>(_m)*ae.?=/(_x)^(_x)0=\"s"oo.?]}{C[(c__)oO!aA!sS!pP!t
02:39:16 <GreaseMonkey> $][gn*][xn1=,][dnn*<1>as.?=][vn*pb.?" of beer on the wall,\n"pp.?n*pb.?qe
02:39:16 <GreaseMonkey> " of beer,\n"pp.?"Take one down, pass it around\n"pp.?ln*<1>as.?=l*pb.?wu
02:39:16 <GreaseMonkey> " of beer on the wall.\n\n"pp.?pn.?]}{M[moO!cC!bB!bb.?cx.?fcg.?=/fcv.?cd.
02:39:18 <EgoBot> OK
02:39:19 <GreaseMonkey> ?fcg.?=\]}
02:39:20 <GreaseMonkey> oops
02:39:44 <GreaseMonkey> !glass {B[b<99>^]}{P[(c__)oO!t$aA!][n<10>s(ns).?oo.?][poo.?tn.?][b(_m)1=,(_x)<0>(_m)*ae.?=(_y)<1>=/(_x)"No more"oo.?(_x)0=(_y)0=\/(_y)(_m)*o(on).?(_y)0=\" bottle"oo.?(_x)<1>(_m)*ae.?=/(_x)^(_x)0=\"s"oo.?]}{C[(c__)oO!aA!sS!pP!t$][gn*][xn1=,][dnn*<1>as.?=][vn*pb.?" of beer on the wall,\n"pp.?n*pb.?qe" of beer,\n"pp.?"Take one down, pass it around\n"pp.?ln*<1>as.?=l*pb.?wu" of beer on the wall.\n\n"pp.?pn.?]}{M[moO!cC!bB!bb.?cx.
02:39:46 <EgoBot> OK
03:02:26 -!- anonfunc has joined.
03:04:02 <GreaseMonkey> ;> #"87*3+,'>,' ,'#,ff+4+,>:#,_ff+4+,87*3+,'#,'0,'<,@";#0<
03:04:19 <GreaseMonkey> (unefunge-98 quine)
03:04:31 <GreaseMonkey> though i use it for befunge-98
03:04:48 <GreaseMonkey> damn, why are all the cool funges unimplemented?
03:06:03 <CakeProphet> hmm..
03:06:17 <GreaseMonkey> !funge93 <@_ #!,#:<"Hello World!"0
03:06:19 <EgoBot> Hello World!
03:06:24 <GreaseMonkey> sweet
03:06:29 <CakeProphet> I'd like to do a 2D grid language that uses gravitational pull to move around data..
03:06:31 <GreaseMonkey> there you go cakeprophet
03:06:37 <GreaseMonkey> nice concept
03:06:45 <CakeProphet> it'd be pretty simple.
03:06:59 <GreaseMonkey> i think RUBE uses gravity
03:07:13 <pgimeno> this funge93 nomenclature suffers from Y2K effect
03:07:25 <CakeProphet> force = G((mass1 * mass2)/DistanceBetweenTwoPoints)
03:07:41 <GreaseMonkey> meh, i prefer terminal velocity of 1
03:07:51 <CakeProphet> where G could be set by a declaration.
03:08:00 <GreaseMonkey> though 1 cell/cycle^2 would be good
03:08:45 <CakeProphet> if you used realistic newtonian models you could create planet-like systems.
03:08:53 <CakeProphet> but... that's far-fetched for a simple language, :P
03:11:13 <CakeProphet> oh!
03:11:30 <CakeProphet> Glass... but with befunge-like commands for weird backwards control flow and stuff.
03:12:20 <GreaseMonkey> uh, glass confuses me
03:12:29 <bsmntbombdood> CONFUZZLE?
03:12:33 <CakeProphet> it's just stack-based with OO
03:12:36 <CakeProphet> like fortran
03:12:54 <GreaseMonkey> never used fortran
03:13:39 <CakeProphet> 2 2 + 5 * 3 4 - *
03:13:59 <pikhq> It's just RPN.
03:14:13 <GreaseMonkey> !funge93 22+5*34-*.@
03:14:17 <EgoBot> -20 
03:14:19 <pikhq> Mmm. . . Reverse polish. . .
03:14:34 <GreaseMonkey> yes, i work with RPN
03:14:48 <pikhq> That's all that Glass does, in essence.
03:14:56 <pikhq> Same with Fortran.
03:14:57 <GreaseMonkey> as visible here (funge98, not funge93): ;> #"87*3+,'>,' ,'#,ff+4+,>:#,_ff+4+,87*3+,'#,'0,'<,@";#0<
03:15:10 <pikhq> Except, of course, Fortran is meant to be used on a regular basis.
03:15:13 <GreaseMonkey> 87*3+ and ff+4+
03:15:13 <CakeProphet> put 2 on the stack, put 2 on the stack, compute the sum of the the 1st and 2nd items of the stack, put 5 on the stack, multiply the top two items and place the produce on the stack, place 3 on the stack, place 4 on the stack, subtract the top two items, multiply the top two items.
03:15:15 <CakeProphet> whoo...
03:15:21 <bsmntbombdood> RPN IS DESTINY
03:15:29 <CakeProphet> hmmm...
03:15:38 <bsmntbombdood> See logfuck
03:15:44 <pikhq> (is 'PN 'destiny)
03:15:49 <CakeProphet> befunge isn't technically RPN... it is stack based though.
03:15:56 <GreaseMonkey> yah
03:15:59 <bsmntbombdood> pikhq: that too
03:16:03 <CakeProphet> so it works like it.
03:16:43 * CakeProphet has been using the a functional fungeoid model in a lot of his ideas lately.
03:17:06 <bsmntbombdood> There's fungus among us
03:17:36 <GreaseMonkey> PUSH dword 2; PUSH dword 2; POP eax; POP ebx; ADD ebx,eax; PUSH ebx; PUSH dword 5; (whatever pop eax, pop ebx, ebx*=eax is); PUSH ebx; PUSH dword 3; PUSH dword 4; POP eax; POP ebx; SUB ebx,eax; PUSH ebx
03:18:38 <bsmntbombdood> ?
03:19:10 <CakeProphet> so... g and p in befunge can be used as variables right?
03:19:22 <CakeProphet> I know they can be used like one-shot memory.
03:19:47 <pikhq> GreaseMonkey: Some horrid x86 asm syntax on the mind?
03:24:52 * CakeProphet waves.
03:24:53 -!- CakeProphet has quit ("haaaaaaaaaa").
03:27:06 <GreaseMonkey> prollaby
03:27:25 <GreaseMonkey> anyways, i'll /away
03:28:29 <bsmntbombdood> mete un gol?
03:44:41 <lament> goooooooool!
03:45:51 -!- thematrixeatsyou has joined.
03:46:07 <bsmntbombdood> The ma exits you
03:46:11 <thematrixeatsyou> my connection totaly fscked up before
03:46:16 <thematrixeatsyou> bugger, i forgot
03:46:32 -!- GreaseMonkey has quit (Nick collision from services.).
03:46:39 -!- thematrixeatsyou has changed nick to GreaseMonkey.
03:46:44 <GreaseMonkey> better! :D
03:47:00 <GreaseMonkey> then there's that other nick =D
03:47:10 -!- GreaseMonkey has changed nick to ^_`.
03:47:34 <^_`> it fits this channel: esoteric and up the top because it's esoteric
03:47:50 <^_`> so this channel is lead by esotericism
03:53:50 -!- Sgeo has joined.
04:10:08 <GregorR> Must ... find ... Windows SDK for Windows 1.0 ...
04:10:42 * bsmntbombdood burps
04:10:49 <pikhq> What's wrong with you, and where can I become wrong in the same way?
04:11:19 <GregorR> www.vetusware.com
04:11:28 * bsmntbombdood geegles
04:11:53 * pikhq has a stupid project idea. . .
04:11:59 <pikhq> Reimplement the Windows 1.0 API!
04:12:38 <GregorR> Excuse me ... I need to vomit.
04:12:42 <pikhq> And meanwhile, wish this laptop would stop melting the flesh off of my leg.
04:12:52 <GregorR> Can you smell burning solder?
04:13:09 <pikhq> Solder melts long before it burns.
04:13:24 <GregorR> Melting, whatever :-P
04:13:43 <pikhq> And my sloppy solder joint on the repaired power connector would have left my computer screwed by now.
04:16:11 * pikhq should stop using the CPU at near 100% for a bit. . .
04:16:15 <pikhq> Might make it cooler.
04:16:24 <pikhq> Of course, I could just throw it out in the snow. . .
04:41:32 -!- ^_` has quit (Read error: 110 (Connection timed out)).
05:17:14 -!- pikhq has quit ("leaving").
05:38:16 -!- MM2 has quit (Read error: 104 (Connection reset by peer)).
05:48:36 -!- MM2 has joined.
06:13:33 -!- calamari has quit ("Leaving").
06:47:22 -!- Sgeo has quit (Remote closed the connection).
07:43:17 -!- sebbu has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
11:23:39 -!- LeaLeaLea has joined.
11:33:30 -!- oerjan has joined.
11:59:01 -!- LeaLeaLea has quit ("Chatzilla 0.9.77 [Firefox 1.5.0.9/2006120612]").
12:06:03 * oerjan _thinks_ someone here recently confused Fortran and Forth.
12:08:17 <oerjan> At least I was not aware that Fortran was stack-based, except underlying implementation.
12:28:59 -!- helios24 has quit ("Leaving").
12:29:16 -!- helios24 has joined.
12:40:19 -!- ihope has joined.
13:15:59 -!- oerjan has quit ("Seahorse").
13:39:46 -!- calamari has joined.
14:39:58 -!- jix__ has joined.
15:07:43 -!- calamari has quit ("Leaving").
16:18:24 -!- FabioNET has joined.
17:00:58 -!- tgwizard has joined.
17:11:25 -!- anonfunc has quit.
18:32:34 -!- ihope_ has joined.
18:47:53 -!- ihope has quit (Connection timed out).
19:20:22 -!- sebbu2 has joined.
19:39:27 -!- sebbu has quit (Read error: 110 (Connection timed out)).
19:47:24 -!- _FabioNET_ has joined.
19:49:30 -!- FabioNET has quit (Read error: 145 (Connection timed out)).
19:50:07 -!- oerjan has joined.
19:53:07 <SimonRC> oerjan: real Fortran has static allocation of everything, and no stack
19:53:45 <lament> but not Object-Oriented Fortran!!!
19:54:01 <bsmntbombdood> oof
19:54:18 <lament> yeah
19:54:25 <lament> it's what people say when you hit them in the stomach
19:55:36 <SimonRC> Fortress looks cool.  it is designed to replace Fortran, though it is not similar.
19:55:54 <lament> so.. like C?
19:56:27 <SimonRC> e.g. its for loops are parallel, it uses real maths notation, and it has a datastructure system that is a superset of OO.
19:56:33 <SimonRC> roughly
19:56:54 <SimonRC> and the "module" system is interesting too, haven't seen that before.
19:56:56 <bsmntbombdood> You know what's stupid?
19:57:02 <bsmntbombdood> Scheme doesn't use t and nil
19:57:27 <lament> what?
19:57:48 <SimonRC> Schemers go for a bit more elegance and a bit less pragmaticism that Common Lispers.
19:58:04 <lament> bsmntbombdood: how's that stupid?
19:58:29 <bsmntbombdood> because
19:58:53 <lament> because what?
20:00:49 <bsmntbombdood> Because I said so
20:02:42 <lament> persuasive.
20:04:42 <bsmntbombdood> And weird how the end of a list is different from false
20:06:04 <bsmntbombdood> but meh
20:06:12 <lament> how is it weird?
20:06:21 <lament> "the end of a list" is a list
20:06:27 <lament> "false" is a boolean
20:06:28 <bsmntbombdood> nil is a list
20:06:31 <lament> they're different types
20:06:31 <bsmntbombdood> and also false
20:06:45 <lament> well, then CL sucks at typing
20:06:52 <lament> since lists and booleans are clearly different things
20:07:47 <lament> same reason that false and 0 aren't the same thing
20:08:24 <bsmntbombdood> hmm
20:10:14 <lament> (math is actually very lax about this; but even in math 0 and empty set aren't usually taken to be the same)
20:43:14 <oerjan> Well, math typing is intensional so things may be "implemented" as the same set despite being distinguished in practice.  As a von Neumann ordinal 0 is the empty set, and this is often used as the first step in building numbers out of set theory.
20:43:38 <lament> well, the real 0 can't possibly be an empty set
20:46:10 <oerjan> Of course it can, in fact precisely because 0 has no intrinsic set semantics, you can choose any set whatsoever to represent it.
20:47:57 <oerjan> In a sense the "real" 0 is not a set at all, which makes what you say true in one sense.
20:48:55 <lament> well, you can choose anything to represent anything
20:49:09 <lament> but not in any nice consistent way, which is the whole point of "implementing" stuff on top of other stuff in math
20:50:01 <lament> the reason we "implement" reals in the first place is so that we can derive their properties from the definition
20:50:20 <lament> a definition where 0 is the empty set is unlikely to be useful for that
20:50:48 <oerjan> For 0 the nice consistent representation depends on which 0 you are talking about - natural, integer, real, complex, ordinal, cardinal.  And even then there may be more than one choice for each, depending on how you choose to model the whole set.
20:50:56 <lament> i said real
20:51:47 <lament> in any case, the "nice consistent representation" is usually not the empty set.
20:51:53 <lament> Certainly not the empty set for vectors and matrices.
20:52:01 <oerjan> I admit that neither the Dedekind cut nor the equivalence class of Cauchy sequences for 0 is the empty set.
20:53:07 <oerjan> The surreal number (which embeds the reals and could be taken as their representation) is the empty game which gets close.
20:53:51 <oerjan> Essentially a pair of empty sets.
20:54:54 <lament> ()()
20:55:17 <pgimeno> that's a sexy pair of empty sets
21:19:08 -!- sebbu has joined.
21:26:51 -!- ihope_ has quit ("http://tunes.org/~nef/logs/esoteric/06.08.09").
21:33:40 -!- sekhmet has quit (Remote closed the connection).
21:34:14 -!- sekhmet has joined.
21:37:12 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
21:38:11 -!- sebbu2 has quit (Connection timed out).
22:15:16 -!- CakeProphet has joined.
22:25:25 -!- _FabioNET_ has quit ("goooood night").
23:32:19 -!- Sgeo has joined.
23:49:55 -!- tgwizard has quit (Remote closed the connection).
23:52:37 <bsmntbombdood> I want slime for scheme
23:59:48 * oerjan coughs up something.

2007-01-24:

00:10:36 -!- sebbu has quit (Connection timed out).
00:13:12 <oerjan> Malbolge seems awfully resistant to attempts to remove its size limitations. :(
00:15:21 <oerjan> At least without totally breaking backwards compatibility.
00:26:29 -!- ihope has joined.
00:29:46 <ihope> So does the platform for our operating system exist yet?
01:06:48 <SimonRC> "Wikipoedia -- Wikipedia for kids!"
01:06:49 <SimonRC> X-P
01:07:14 <SimonRC> mayby my classical roots are mixed up :-S
01:07:25 <bsmntbombdood> heh
01:09:30 <bsmntbombdood> There should be a way to recurse in lambdas
01:11:09 <SimonRC> IIRC lisp has LAMREC
01:11:36 <SimonRC> Some typesystems will allow the definition of the y-operator, too
01:13:01 <ihope> Yeah.
01:13:06 -!- bsmnt_bot has quit (Read error: 131 (Connection reset by peer)).
01:13:45 -!- bsmntbombdood has quit (Read error: 104 (Connection reset by peer)).
01:17:09 -!- bsmntbombdood has joined.
01:18:14 <bsmntbombdood> which lisp?
01:20:04 <bsmntbombdood> y-operator?
01:21:51 <ihope> fix f = f (fix f)
01:22:12 <ihope> (And y = fix)
01:24:51 <bsmntbombdood> What's the point of that?
01:25:16 <ihope> That's all the recursion you need.
01:25:59 <ihope> If you want f x y = x (y f) y y (f y x), then f = fix (\b -> x (y b) y y (b y x)).
01:28:00 <bsmntbombdood> oh
01:31:57 <CakeProphet> hmmm... this is nifty.
01:32:27 <CakeProphet> I've got a USABLE esolang, designed to be used in an actual application, that resemvles English, and looks weird.
01:32:46 <CakeProphet> still writing the spec... of course.
01:32:54 <SimonRC> what is it like?
01:33:20 <CakeProphet> It reminds me of ORK superficially..
01:33:26 <CakeProphet> but it doesn't have a myriad of special keywords.
01:33:27 <SimonRC> Quick, you must give it only linear types in order to make it more useless and esoteric!
01:33:47 <bsmntbombdood> There is a Scribe named SimonRC.
01:33:55 * SimonRC wonders what would happen if you crossed "ORCS!" with "Ork".  Both are OO.
01:34:07 <SimonRC> "ORCS!" is a lang for writing roguelikes.
01:34:16 <CakeProphet> You there, cat
01:34:21 <SimonRC> bsmntbombdood: Oooooh no there isn't!
01:34:22 <bsmntbombdood> SimonRC is to right "something"
01:34:23 <CakeProphet> You have stuff the letters
01:34:27 <CakeProphet> -
01:34:35 -!- pikhq has joined.
01:34:42 <CakeProphet> we are saying our stuff
01:34:47 <SimonRC> CakeProphet: :-S
01:34:55 <CakeProphet> Thank you, good sir!
01:35:03 <CakeProphet> that was a cat program.
01:35:07 <SimonRC> ah, ok
01:35:26 <CakeProphet> but none of that, except "Thank you, good sir!" was a reserved keyword.
01:35:49 <bsmntbombdood> pics or it didn't happen
01:36:26 <CakeProphet> right now I'm just calling conSTABLE
01:37:29 <SimonRC> What kind of bloody keyword is "Thank you, good sir!"?
01:37:37 <CakeProphet> ends the function.
01:38:00 <pikhq> What'd I miss, and what the hell is wrong with you?
01:38:25 <bsmntbombdood> There is a Scribe named pikhq.
01:38:30 <CakeProphet> well... You there, cat    amy or may not be special syntax...
01:38:37 <bsmntbombdood> pikhq is to write "Hello, world".
01:38:57 <CakeProphet> You there, hello
01:38:58 <pikhq> bsmntbombdood: The class is "scribe", not "Scribe".
01:38:58 <CakeProphet> -
01:39:00 <CakeProphet> a hello world program
01:39:10 <bsmntbombdood> pikhq: fine!
01:39:44 <CakeProphet> -
01:39:46 <CakeProphet> -
01:39:47 <CakeProphet> We are saying "Hello, World!"
01:39:49 <CakeProphet> Thank you, good sir!
01:39:50 <CakeProphet> We hello
01:40:21 * pikhq thinks of a brilliantly insane idea. . .
01:40:53 <pikhq> Make a Brainfuck variant which makes use of every character which one can type on a standard US English keyboard.
01:41:10 <ihope> That would be printable ASCII.
01:41:22 * oerjan thinks of an even more brilliantly insane idea.
01:41:34 <oerjan> Make that a Chinese keyboard.
01:41:39 <ihope> And I have final exams tomorrow and it's bedtime. Bye-bye.
01:41:50 <SimonRC> oerjan: Have you seen a chinese keyboard
01:41:56 -!- ihope has quit ("No, make that Unicode. Very insane.").
01:41:57 <CakeProphet> hrm... and it apparently will be using list-like symbols.
01:42:26 <CakeProphet> but... not exactly.. like you can set objects as well as symbols, which has the effect of being in-place assignment.
01:42:57 <CakeProphet> er... lisp-like symbols
01:46:27 <pikhq> God. . .
01:47:19 <SimonRC> oerjan: http://www.fi.muni.cz/usr/wong/teaching/chinese/notes/node11.html
01:47:20 <pikhq> You could even make this Brainfuck++ include a couple of stacks. . . Forking. . . Two arrays. . .
01:47:24 <pikhq> God, that's just evil.
01:47:36 <SimonRC> THE kb HAS CHARACTER FRAGMENTS ON IT WHICH THE COMPUTER ASSEMBLES
01:47:44 <SimonRC> dAMN cAPSlOCK.
01:48:18 <SimonRC> There ought to be a distributed-computing version of Brainfuck.
01:48:33 <SimonRC> It would be called "Clusterfuck"
01:48:42 <SimonRC> the OO version would be "OFuck"
01:48:47 <pikhq> The multiple-threaded Brainfuck version could probably be ran on a distributed computing system.
01:48:58 <SimonRC> and the unicode version "Fuck-U"
01:49:13 <pikhq> Hahah.
01:49:14 <SimonRC> pikhq: (that was just a joke about the names)
01:49:28 <pikhq> I see that now.
01:50:25 <pikhq> And, I assume, there'd be an Internet-supporting version called "GoFuck", and one that's introspective, called "Yourself". . .
01:50:34 <pikhq> And the combined version, "GoFuckYourself".
01:50:41 <SimonRC> hehe
01:51:25 <SimonRC> If you add a command for turning off the computer, that would be "FuckOff"
01:52:27 -!- bsmntbombdood has quit (Read error: 104 (Connection reset by peer)).
01:52:39 <oerjan> I will leave to others to mention the name of the web camera version
01:52:40 <CakeProphet> SO
01:52:48 <CakeProphet> THIS SOUNDS LIKE A JOB FOR THAT ESOLANG FACTORY
01:52:50 <pikhq> And a version combined with Malbolge. . .
01:52:53 <pikhq> "GoToHell."
01:52:54 <CakeProphet> THE WORLD'S LARGEST BF IMPLEMENTATION
01:53:01 <pikhq> Variant, you mean.
01:53:08 <CakeProphet> ...yeah
01:53:32 <CakeProphet> concurency, networking, oo, functional, extended control flow, etc
01:53:45 <SimonRC> oerjan: Actually I can't guess that one.
01:54:17 <CakeProphet> Sexy BrainFuck Live?
01:54:48 -!- bsmntbombdood has joined.
01:55:40 <SimonRC> CakeProphet: it would be like OO COBOL.  you would only see clear code when in your programming class, buit in the Real World, you would keep finding code that still had raw <>+_[]., in it.
01:55:57 <SimonRC> OST, that would what BFM would be like as a commercial language.
01:56:21 <CakeProphet> SimonRC,  In what?
01:56:52 <SimonRC> If BF was extended into a commercial language.
01:56:58 <oerjan> ok then, it would obviously be FuckFace
01:57:01 <CakeProphet> no no
01:57:01 <SimonRC> Yo0u know what real-world COBOL is like, right?
01:57:04 <CakeProphet> not a commercial language..
01:57:14 <CakeProphet> just a... really stuffed language.
01:57:19 <SimonRC> oerjan: sigh.  That is the one with interface definitions, surely?
01:57:53 <CakeProphet> I've never quite figured out the use of an interface -type-
01:57:58 <pikhq> Yes. . . We must engage in factoriness.
01:58:26 <CakeProphet> put it on the wiki?
01:58:40 * CakeProphet could do it.
01:58:48 <pikhq> *grin*
01:58:59 <CakeProphet> which inevitably means that I'll be the lucky one implementing it later...
01:59:01 <CakeProphet> ...
01:59:17 <oerjan> this, however, would be a Fucktory.
01:59:57 <pikhq> Heheh.
02:00:21 <CakeProphet> I really like the space-delimits-both-functions-and-class-attributes syntax of conSTABLE
02:00:55 <CakeProphet> 2 + 2       gets the + method of the first two, and calls it on the second two... the parser can easily eliminate all ambiguity.
02:02:58 <oerjan> Is that a fact or wishful thinking.
02:03:20 <pikhq> I think it's a magical parser.
02:03:27 <CakeProphet> nah... as far as I can tell... the parser can't create ambiguity.
02:03:36 <CakeProphet> I've tried all sorts of situations... in my head anyways
02:03:40 <pikhq> Perhaps even an oracle machine?
02:04:30 <CakeProphet> the only restriction is that thee can't be default values for arguments and there can't be arbitrary numbers of arguments.
02:04:34 <CakeProphet> which doesn't matter much to me.
02:04:59 <bsmntbombdood> shit
02:05:03 <CakeProphet> you can easily stuff a list of "arbitrary arguments" into the last parameter... which is essentially what most do.
02:10:47 * pikhq proposes that Fucktory support networking and file access. . .
02:16:40 <CakeProphet> functional.
02:16:48 <CakeProphet> hmmm... I'd rather do this with befunge actually...
02:16:55 <pikhq> Bah.
02:16:59 * CakeProphet has never actually liked brainfuck  -GASP-
02:17:07 <pikhq> Make it a superset of Dimenisfuck.
02:17:25 <pikhq> Add in parts of the Befunge command set.
02:17:33 * pikhq is t3h evil
02:17:50 <GregorR> I've written one of the most important pieces of software in history.
02:18:00 <CakeProphet> that would basically be like.... a rail-ish befungefuck
02:18:14 <CakeProphet> spam bot?
02:18:26 <pikhq> CakeProphet: A functional multithreaded befungefuck.
02:19:25 <CakeProphet> I still like befunge more than bf... it's FUN. It's a spatial system with a stack... that's just great.
02:19:31 * oerjan diagnoses GregorR with megalomania and gets out the straightjacket.
02:19:35 <pikhq> Fine.
02:19:40 <pikhq> Dimensifuck with a stack.
02:19:44 <CakeProphet> like electric wiring... with like a weird stack.
02:19:50 <pikhq> Voila; you've got Funge.
02:20:03 <pikhq> Well, n-dimensional Funge.
02:20:21 <CakeProphet> functional OO befunge!!!
02:20:25 <GregorR> oerjan: You don't understand.
02:20:29 <GregorR> oerjan: This is significant.
02:20:31 <CakeProphet> with network support, file access, and concurency.
02:20:31 <GregorR> This is ...
02:20:35 <GregorR> The Order of Urinals emulator.
02:21:23 <oerjan> No no, I understand perfectly.  I am here to help, after all.  Now just put your arm in here...
02:21:39 <pikhq> Order of Urinals?
02:22:01 <GregorR> pikhq: Given a number of arrival times and wee times for a number of men, and an arrangement of urinals, one can predict with almost 100% certainty which urinals each man will go to.
02:22:19 <GregorR> I'm trying to figure out if I can turn that into a rudimentary computer X-P
02:22:21 <pikhq> I. . . You. . .
02:22:26 <pikhq> Hahah.
02:24:57 <SimonRC> CakeProphet: I agree about BF versus BF
02:26:21 * CakeProphet dies of laughter.
02:26:28 <CakeProphet> oh god...
02:26:33 <CakeProphet> that's brilliantly hilarious.
02:27:35 * CakeProphet gets to work on that oracle machine pikhq seems to be baffled at.
02:28:38 <pikhq> What sort of oracle?
02:34:06 <CakeProphet> the 2 + 2 thing
02:34:10 <CakeProphet> that constable uses
02:35:18 <pikhq> Ah.
02:38:14 -!- oerjan has quit ("Good night.").
02:40:23 * SimonRC lolololololols at the ST:TNG plot generator:
02:40:30 <SimonRC> "Whlist on leave Captain Picard starts de-aging rapidly when the Enterprise encounters some kind of spacetime rift thingy which is in fact Wesley's fault—as well as Q which pisses them about for fun and affects the entire ship, throws the ship thousands of light years off course, and depletes the shields to 5% while Wesley is precocious so Riker delivers a phaser blast, which means everything turns out okay, though Picard has had to deal with children. 
02:40:37 <SimonRC> You could swear it was real.
02:40:38 <SimonRC> http://www.bargaintuan.com/sttngplotgen/
02:48:05 <GregorR> Oh come on ... this HAS to be TC :P
02:48:08 <GregorR> [OoU]
02:56:17 <SimonRC> "Imagine the heartaches / Of diplomatic attaches / When the wind detaches / Their false moustaches" :-)
02:59:21 <CakeProphet> erm..
02:59:28 <CakeProphet> emacs stopped... detecting my capslock.
02:59:31 <CakeProphet> how bizzare
03:09:52 <bsmntbombdood> Hmm
03:10:05 <bsmntbombdood> Im thinking logfuck might not need dup to be turing complete
03:10:33 <CakeProphet> it needs dupdog!
03:11:06 <bsmntbombdood> ']' can become '[11g]>]<' or something like that
03:11:43 <bsmntbombdood> brainfuck -> logfuck, that is
03:12:05 <CakeProphet> I usually don't worry about Turing completeness.... some of the more interesting languages out there are finite-state and cellular automatons.
03:14:31 <pikhq> Some cellular automatons are Turing complete.
03:14:46 <pikhq> The Game of Life and Wireworld are good examples.
03:15:29 <CakeProphet> well yeah... since they're not mutually exclusive terms.
03:15:35 <pikhq> (in both of them, a Turing-complete system has been designed. . . Life has a Turing machine, Wireworld has an OISC system (it's instruction is MOVE))
03:16:43 <GregorR> I'd still like OoU to be TC :P
03:16:52 <GregorR> I don't think it is, though ;)
03:17:34 -!- wooby has joined.
03:19:34 <GregorR> Unfortunately, I don't even really know where to start on writing a OoU program ...
03:19:44 <CakeProphet> What's OoU?
03:19:46 <CakeProphet> oooh
03:19:51 <CakeProphet> order of urinal
03:19:59 <CakeProphet> well... it depends on how many urinals we're talking
03:20:21 <bsmntbombdood> I had to explain urinal ettiquette to a girl the other day
03:20:23 <GregorR> Any finite number in any sensible arrangement.
03:20:25 <CakeProphet> and hell, if something as rudementary as LIFE is Turing complete... I'd imagine OoU could be too.
03:20:34 <CakeProphet> it's mostly implied etiquette.
03:20:42 <GregorR> It's programmed into every man.
03:20:49 <GregorR> And I determined these rules for my emulator:
03:20:56 <GregorR> 1) Farthest from any neighbor.
03:21:00 <GregorR> 2) Fewest neighbors.
03:21:05 <GregorR> 3) Closest
03:21:37 <bsmntbombdood> Farthest is not always the best, in a situation with lots of urinals
03:21:52 <GregorR> (Though I wrote it such that I could write men with different roles)
03:22:13 <GregorR> bsmntbombdood: I could put a limit on farthest easily *shrugs*
03:22:43 <CakeProphet> The  Shy Man, The Lazy Man, and the Claustophobic.
03:22:55 <CakeProphet> determines priority of which to achieve first. :D
03:23:14 <bsmntbombdood> \-| |-/ \-| |-/
03:23:28 <GregorR> I was thinking: Lazy (closest first), creepy (most neighbors, closest to neighbors), lonely (tries to be close, but still one urinal between)
03:24:58 <GregorR> However, I think I'd like to try to find TC with only the standard rules.
03:26:07 <bsmntbombdood> yeah [11g]>]< doesn't work
03:26:54 <bsmntbombdood> obviously
03:35:07 <CakeProphet> you could use each block of three urinals as morse code.
03:35:29 <CakeProphet> at the end of the program... each three urinals stands for a character.
03:44:40 <bsmntbombdood> call/cc makes no sense
03:52:34 -!- pikhq has quit ("leaving").
03:59:44 <GregorR> Hm
04:00:15 <GregorR> I think I need one more factor to make OoU TC ... wee schedules. Right now there's no capacity for looping.
04:12:15 <SimonRC> bsmntbombdood: yes it does
04:12:22 <SimonRC> quite simple once you understand it.
04:16:16 <GregorR> I think I can implement cat in this O_O
04:22:56 <bsmntbombdood> SimonRC: Which I don't
04:24:40 -!- wooby has quit.
04:24:46 -!- wooby has joined.
04:28:17 * bsmntbombdood likes how SICP says that for,while loops are mere abstractions
04:30:12 <CakeProphet> GregorR,  if your output is the data itself converted to characters... a NOP would be the cat program.
04:30:42 <CakeProphet> I envisioning it working a lot like a string-rewriting language... but without explicitly rewriting and with multiple symbols for each character
04:31:50 -!- CakeProphet has changed nick to SevenInchBread.
04:32:14 <bsmntbombdood> String rewriting
04:32:16 * SimonRC goes to bed
04:33:37 <SevenInchBread> ...I hate parsing.
04:33:44 <SevenInchBread> at least initially..
04:33:48 <SevenInchBread> semantics are fun though
04:33:54 <SevenInchBread> but the initial parsing out tokens sucks bawls.
05:00:13 -!- SevenInchBread has quit (Read error: 113 (No route to host)).
05:31:29 <GregorR> I was thinking a special "output" urinal which would output a bit: 1 if time >= 10, 0 otherwise.
06:22:22 -!- calamari has joined.
06:24:27 -!- Sgeo has quit (Remote closed the connection).
06:27:30 -!- calamari has quit ("Leaving").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:30:56 -!- sebbu has joined.
13:01:37 -!- wooby has quit.
13:47:58 -!- jix__ has joined.
13:48:53 -!- jix__ has changed nick to jix.
13:50:34 -!- calamari has joined.
14:54:27 -!- calamari has quit ("Leaving").
15:47:27 -!- tgwizard has joined.
15:49:21 <bsmntbombdood> oh no!
15:49:25 <bsmntbombdood> bsmnt bot is gone!
15:49:45 -!- bsmnt_bot has joined.
15:50:18 <bsmntbombdood> foo
15:51:14 <bsmntbombdood> ~exec print >> sys.stdout, "foo"
15:51:15 <bsmnt_bot> foo
16:23:31 <bsmntbombdood> gah
16:23:40 <bsmntbombdood> combinatory logic makes no sense
16:24:01 <bsmntbombdood> SENSELESS!
16:40:19 -!- FabioNET has joined.
17:07:36 -!- FabioNET has quit (Read error: 145 (Connection timed out)).
17:10:53 -!- FabioNET has joined.
18:20:33 -!- Sgeo has joined.
20:34:33 -!- sebbu2 has joined.
20:53:41 -!- sebbu has quit (Read error: 110 (Connection timed out)).
21:00:36 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
21:18:37 -!- ihope has joined.
21:20:05 -!- sebbu has joined.
21:39:19 -!- sebbu2 has quit (Connection timed out).
21:39:33 -!- oerjan has joined.
21:44:59 <ihope> The problem with cloaks is that you can't collect them or anything.
21:47:27 <ihope> Unless I can get tapthru/resident/pdpc/supporter/active/ihope or something.
21:47:46 <ihope> Or tapthru/resident/pdpc/supporter/active/unaffiliated/ihope.
21:50:08 <oerjan> Wireworld is not Turing-complete unless you have an unbounded starting pattern.
21:50:49 <ihope> Indeed.
21:51:01 <oklopol> ?
21:51:16 * oerjan is reading yesterday's logs
21:52:23 <oerjan> However, that can still be interesting for cellular automata.  The rule 110 1D-automaton is the same way at least for the known construction.
21:52:43 <oklopol> what do you mean unbounded starting pattern?
21:53:36 <oerjan> Wireworld patterns cannot grow, so to have infinite memory you need some kind of infinite initial pattern.
21:55:49 <oklopol> ah yeah
21:56:35 <oerjan> (Rule 110 patterns can grow leftwards however, so it may be possible in that case although yet unknown)
21:58:12 <GregorR> Hmmmmmmmmmmm, that has some implications in terms of OoU too ... could still be a BSM though.
21:58:23 <oklopol> well, i think it's turing complete if it's capability can be increased with trivial changes
21:59:01 <oklopol> i mean, changes the system itself could theoretically implement
21:59:14 <oklopol> *changes that could be implemented on the system itself
21:59:25 -!- tgwizard has quit (Remote closed the connection).
22:00:16 <GregorR> For it to be TC, you'd need to be able to use a recursive algorithm that could feasibly take unlimited memory.
22:29:57 -!- FabioNET has quit ("notte ragassuoli").
22:34:29 <bsmntbombdood> GregorR: wha?
22:34:57 <GregorR> WireWorld is not TC, because you can't implement an algorithm that takes unbounded memory.
22:36:03 <bsmntbombdood> Ooh I misread 
22:36:07 <bsmntbombdood> I thought you were talking to me
22:36:21 <bsmntbombdood> apparently my irc client highlights on "BSM"
22:37:14 <SimonRC> GregorR: erm, it should be easy enought to construct a WW TM with infinite tape.
22:37:27 <pgimeno> you can't?
22:38:54 <oklopol> why are you whining about the fact a ww computer need more memory to be able to do more, are you saying assembly isn't tc?
22:39:07 <oklopol> *needs
22:44:43 <ihope> If assembly doesn't have infinite memory, it's not Turing-complete.
22:45:00 <bsmntbombdood> Nothing is turing complete
22:45:18 <ihope> Nothing in the universe is Turing-complete.
22:45:24 <bsmntbombdood> yeah
22:45:47 <ihope> Unless, that is, the universe is infinite and you can build something that'll never break down.
22:46:51 <ihope> Building such a thing will probably be very hard until very near the heat death of the universe, and I don't know whether such a thing could do anything after its heat death.
22:53:11 <SimonRC> :-P
22:53:12 <SimonRC> "It takes N Prolog programmers to change a lightbulb."  "N=1" "N=2" "N=3" "N=4" "N=5" "N=6" ... etc.
22:53:15 <SimonRC> "It takes N Prolog programmers to change a lightbulb."  "N=1" "N=2" "N=3" "N=4" "N=5" "N=6" ... etc.
22:53:19 <SimonRC> :-P
22:53:21 <SimonRC> erm, oops
22:53:32 <oklopol> of course you could say any abstract language is tc, which means most languages, but you just cant create an interpreter for them
22:55:01 <GregorR> A language can be TC, an implementation cannot.
22:55:16 <GregorR> Assembly is not TC, mainly because it's tied so thoroughly to the processor.
22:55:25 <GregorR> Higher level languages are sometimes TC.
22:55:57 <ihope> oklopol: *any* abstract language?
22:56:32 <oklopol> any abstract language that is turing complete is theoretically turing complete is the gist of my mumbling
22:56:34 <oklopol> :)
22:56:54 <oklopol> exactly what GregorR said
22:56:58 <oklopol> word to word
22:56:59 <oerjan> you tautologist you
22:57:01 <oklopol> that's what i said
22:58:14 <ihope> So, to change the topic radically, what base language should we use for our esoteric programming language?
22:58:50 <oklopol> :)
22:58:54 <oklopol> itself?
22:59:13 <ihope> s/programming language/operating system/, sheesh
22:59:23 <ihope> The Big Kahooey is that it's self-modifying and extensible and virtualizable.
22:59:31 <ihope> ("Kahooey" is Spanish for "criterion".)
23:01:20 * oerjan thinks ihope should fire his Spanish teacher.
23:01:37 <ihope> oerjan: good idea! :-)
23:01:57 <ihope> I nominate Smurf.
23:04:05 <SimonRC> Befunge
23:04:26 <ihope> Wonderful.
23:04:38 <ihope> I take it Befunge is virtualizable.
23:04:57 <SimonRC> OST, Funge98.  It has the same big-O running times as everything else.
23:05:20 <ihope> OST?
23:05:34 <SimonRC> Funge98 can manage a 4G * 4G space.  Make the whole disk into swap!
23:05:37 <oerjan> OST=cheese
23:05:42 <SimonRC> On Second Thoughts
23:05:52 <ihope> Pff, make it RAM.
23:06:06 <ihope> Any Befunge variant should be wonderful enough.
23:06:20 <SimonRC> With whole-disk swap, you don't need any file-handling.
23:06:34 <ihope> Mmh.
23:06:47 <SimonRC> but a Bef98 address fits nicely into a 64-bit word.
23:06:48 <ihope> You need to separate RAM from disk space, don't you?
23:07:10 <SimonRC> no, there si nothing to stop you making the whoel disk into swap.  Some "real" OSes do that.
23:07:15 <ihope> Well, hey, it'd be a base. Let's not have any fancy features that can't be removed.
23:07:37 <ihope> We'd build the operating system on top of Funge.
23:07:37 <GregorR> Nothing wrong with memmapping everything.
23:07:46 <GregorR> Anybody want my Order of Urinals emulator? :-P
23:08:15 <ihope> Do real *platforms* do that?
23:08:37 <ihope> Surely we could build this swap stuff on top of the Funge.
23:09:50 <SimonRC> ihope: yeah, real platforms do that.  I will try and find an example
23:10:09 <ihope> And, uh, I guess the Order of Urinals thing sounds interesting.
23:10:46 <ihope> Also, what actual reason is there to build this stuff into the platform?
23:11:40 <oklopol> "whole disk swap"...like virtual?
23:12:04 <GregorR> Just the whole disk memory mapped.
23:12:04 <oklopol> *into
23:12:28 <GregorR> On a 64-bit platform or a 32-bit platform 20 years ago that'd be a perfectly good way to get to the HD.
23:12:51 <oklopol> yeah
23:13:17 <oklopol> thought so
23:13:23 <oklopol> well, unununium?
23:13:38 <ihope> What if you have a weird hard drive?
23:13:41 <ihope> Or multiple hard drives?
23:13:48 <ihope> Or no hard drives at all?
23:13:56 <oklopol> os is for that
23:14:09 <ihope> Hmm?
23:14:27 <oklopol> it takes care of the type of your hardware
23:14:31 <GregorR> The OS should be able to detect it and memory map everything properly.
23:14:59 <oklopol> GregorR always think what i'm thinking and say what i can't get out :\
23:15:03 <oklopol> *thinks
23:15:04 <GregorR> ^^
23:15:09 <oklopol> *says
23:15:12 <GregorR> lol
23:15:15 <oklopol> my s has a flow
23:15:18 <oklopol> *flaw
23:15:21 <oklopol> okay
23:15:26 <GregorR> Suuuuuuuuuuure
23:15:26 <oklopol> i shut up now :O
23:15:37 <oklopol> really!
23:15:41 <oklopol> it's screwedx
23:17:17 <oklopol> GregorR, can i have the emulator?
23:17:23 <oklopol> OoU
23:18:08 <GregorR> Oh, sure - it's in D, so I presume you want a binary? (What OS?)
23:18:17 <oklopol> windows
23:18:21 <oklopol> xP
23:18:37 <GregorR> Uno momento.
23:19:09 <SimonRC> aha!  "SpeedOS"
23:20:00 <SimonRC> http://www.informatik.uni-ulm.de/rs/projekte/monads/PersistentVMemoryE.html
23:20:53 <SimonRC> also, "Unununium"
23:21:39 <oklopol> OLD
23:21:51 <oklopol> i said that a while ago haha :)
23:22:21 <GregorR> http://www.codu.org/oou-2007-01-24-win.zip
23:22:26 <oklopol> thx
23:25:40 <oklopol> wow
23:25:45 <oklopol> that's so cool :O
23:25:48 <GregorR> lol
23:25:54 <GregorR> Where "cool" = "ridiculous" :-P
23:26:00 -!- sebbu2 has joined.
23:26:18 <oklopol> how do you do console non-appending output?
23:26:39 <GregorR> I just clear the screen between displays
23:26:43 <oklopol> ah
23:27:06 <oklopol> but, really, cool
23:27:08 <oklopol> hmm
23:27:17 <oklopol> do they come and og randomly?
23:27:19 <oklopol> go
23:27:48 <GregorR> Yeah - I'm considering writing a proper event list format, so you can make event lists. Then comes output, etc.
23:28:07 <oklopol> good
23:28:16 <oklopol> too hard to do anything if it's all random
23:28:24 <GregorR> "Too hard" == "impossible" :P
23:28:28 <oklopol> yeah
23:28:58 <oklopol> just delays between peeers and the amount of pee in their baggies
23:30:17 <GregorR> "baggies"
23:30:50 <oklopol> you can supply me with the right term if you can
23:31:12 <oklopol> no matter how tautological that is
23:33:07 -!- sebbu2 has quit ("Leaving").
23:36:15 <oerjan> "bladder"
23:36:56 <oklopol> i was looking for that
23:37:13 <oklopol> but i settled with baggies since it didn't come right out
23:39:33 <oklopol> hmm, what are the rules?
23:39:37 <oklopol> in OoU
23:40:16 <oklopol> i'm pretty sure i'm not supposed to be this fascinated about watching little ascii men pee :\
23:40:37 <GregorR> Hahahah
23:40:53 <GregorR> In order of preference:
23:41:02 <GregorR> 1) Farthest from any other used urinals.
23:41:07 <GregorR> 2) Fewest neighbors.
23:41:12 <GregorR> 3) Closest
23:42:30 <oklopol> toilets and sinks not currently in use?
23:42:45 <oklopol> Fewest neighbors?
23:42:48 <oklopol> meaning?
23:43:03 <GregorR> Only urinals are in the algorithm.
23:43:16 <oklopol> you could add those later too
23:43:23 <GregorR> Fewest neighbors == for example, in this arrangement:   @|U|@|U   it would prefer the far right one.
23:43:37 <oklopol> ah of course
23:43:40 <GregorR> Or in this arrangement:   U|U|@|U|U|U|@   it would prefer the far left one.
23:44:12 <oklopol> but, if there's a wall between them, they shouldn't care
23:44:55 -!- sebbu has quit (Connection timed out).
23:44:57 <oklopol> i mean, they don't need as big a distance as possible, because when eye contact is avoided for certain, the distance is as good as infinite
23:45:12 <oklopol> right?
23:46:24 <GregorR> In real life, yes.
23:46:27 <GregorR> In the simulator, no.
23:46:29 <oklopol> why not?
23:46:36 * GregorR == lazy :P
23:46:45 <oklopol> nah, it's trivial
23:47:07 <oklopol> well, okay, finding the best possible is then not, probably
23:47:12 <GregorR> Exactly.
23:47:19 <oklopol> and, that would eliminate the possibility of tc
23:47:29 <GregorR> Not necessarily, but it sure wouldn't help.
23:48:50 <oklopol> in real life the guys make solutions based on what they see of course, so they woulnd't turn right back out if all urinals are taken either
23:49:02 <oerjan> This _could_ be fixed simply by replacing "|" with " ", you know.
23:49:24 <oklopol> or
23:49:55 <oklopol> okay, i find this lack of words a bit frustratingf
23:49:57 <oklopol> *-f
23:50:15 <GregorR> Yes, I know, but forming a line would be a huge PITA :P
23:50:55 <oerjan> why? aren't "|" and " " the same width?
23:51:31 <GregorR> It was a look thing :P
23:53:00 <oklopol> sleep ->
23:53:24 <GregorR> Watching them find their way to a urinal in a maze = hilarity :P
23:54:13 <GregorR> What's particularly lame about this is I spent more time getting A* working than actually implementing OoU :P
23:57:23 <oerjan> I didn't see a maze.
23:59:58 <GregorR> stages/maze[2].txt

2007-01-25:

00:58:05 <bsmntbombdood> wow
00:58:13 <bsmntbombdood> CLEVAR!
00:59:37 <bsmntbombdood> http://pastebin.ca/327529
00:59:40 <bsmntbombdood> (from SICP)
01:03:18 * ihope rings a bell for no good reason
01:03:25 <ihope> So yes, platform = funge?
01:03:42 <pgimeno> why not Java2K? it comes with built-in random crashes
01:03:43 <ihope> If there's any memory mapping at all, it should be a throw-together.
01:03:48 <ihope> Pff.
01:03:55 <ihope> What are we writing here, Windows?
01:04:48 <pgimeno> well, you can make the random crashes less likely than Windows'
01:05:43 <ihope> True.
01:06:11 <ihope> But I think maybe serious answers might be better. :-P
01:06:54 <pgimeno> er...
01:08:48 <ihope> Er?
01:09:36 <pgimeno> just I'm not prepared for a serious one :)
01:10:58 <ihope> I think we can do a funge.
01:14:04 <ihope> Now, get to work on a fungeoid that has a user mode, troops!
01:14:08 <ihope> Or something!
02:05:19 -!- anonfunc has joined.
02:21:09 -!- ihope has quit (Connection timed out).
02:44:48 -!- oerjan has quit ("Natta").
03:31:11 * SimonRC goes
03:53:44 <bsmntbombdood> wow
03:53:48 <bsmntbombdood> SICP is a great book
05:06:06 <lament> er, yes, it is
05:08:17 * bsmntbombdood is reading
05:16:02 -!- Sgeo has quit (Remote closed the connection).
05:54:21 -!- anonfunc has quit.
05:57:51 -!- anonfunc has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:17:00 -!- sebbu has joined.
11:52:25 -!- sebbu2 has joined.
11:54:37 -!- anonfunc has quit.
12:19:33 -!- sebbu has quit (Connection timed out).
13:07:20 * SimonRC goes to lunch
14:10:29 -!- Keymaker has joined.
14:12:16 <Keymaker> this is hopeless. i can't get my underload interpreter written in normal languages, so i guess it's time to try the brainfuck approach.
14:45:29 <oklopol> Keymaker, i've seen your codes! :D
14:46:27 <oklopol> the name just rang a bell, nm :)
14:47:58 <Keymaker> ah :)
14:48:08 <Keymaker> ok
14:48:53 <oklopol> actually, now that i think of it i found this channel when i found logs searching your name i saw in a brainfuck program :O
15:27:18 -!- Keymaker has quit (Read error: 145 (Connection timed out)).
16:24:29 -!- tokigun has left (?).
16:24:44 -!- tokigun has joined.
16:26:58 -!- FabioNET has joined.
17:13:10 * SimonRC goes to a lecture
18:32:42 -!- GregorR has quit (zelazny.freenode.net irc.freenode.net).
18:32:44 -!- digital_me has joined.
18:39:15 -!- GregorR has joined.
19:31:33 <oklopol> omfg muriel is the sickest language i ever saw :O
19:38:33 -!- ihope has joined.
20:07:58 -!- helios24 has quit (Read error: 104 (Connection reset by peer)).
20:08:06 -!- helios24 has joined.
20:27:35 -!- tgwizard has joined.
20:39:00 -!- Sgeo has joined.
21:20:24 <ihope> I suddenly feel the need to watch a dramatic computer crash.
21:21:04 -!- wooby has joined.
21:51:39 -!- sebbu has joined.
22:08:03 -!- oerjan has joined.
22:10:23 -!- sebbu2 has quit (Connection timed out).
22:30:12 -!- SevenInchBread has joined.
22:41:41 <GregorR> SUPER DANCE EXPLOSION TIME
22:42:37 <bsmntbombdood> SICP == awesome
22:42:45 <oklopol> GregorR, OoU with eventlists out yet?
22:52:39 <GregorR> I could release it "any second now" :P
22:52:41 <SevenInchBread> hmmm... Smalltalk is pretty cool...
22:52:53 <GregorR> But first I want to store some data in OoU ^^
22:53:00 <GregorR> I've encoded three bits so far ^^
22:53:19 <SevenInchBread> it would be cooler if it were prototype-based though..
22:56:51 <GregorR> oklopol: Now four bits :)
22:57:32 <oklopol> encoded what bits?
22:58:33 <oklopol> if you wanted to make it easy to code with it, you could have some guys sleep on the toilets to be waken up only when someone pees near them etc
22:58:40 <GregorR> It can take input ;)
22:58:44 <oklopol> you'd need to put in T's of course
22:58:56 <GregorR> I don't want to make it any easier, my goal is to get JUST THIS to be TC :)
22:59:06 <oklopol> it's nice as it is of course
22:59:07 <oklopol> true
22:59:15 <oklopol> i just hope i can do stuff with it
23:01:26 <ihope> What's OoU stand for again?
23:01:32 <GregorR> Order of Urinals.
23:01:43 <ihope> Ah, right.
23:02:12 <GregorR> http://www.codu.org/oou-2007-01-25.zip (Binaries for Windows and GNU/Linux)
23:03:12 <bsmntbombdood> I bet you wrote it in D
23:03:16 <bsmntbombdood> tsk tsk
23:03:22 * GregorR huggles D
23:03:46 <GregorR> D is like C++ minus the stupid ^^
23:03:51 <GregorR> Plus coolitude.
23:04:21 <bsmntbombdood> scheme == teh shit
23:04:31 <GregorR> Oh, and it now takes a speed parameter: oou <speed> <stage> <event list>
23:04:36 <GregorR> Lower is faster :P
23:04:46 <GregorR> 50000 is default
23:06:02 <oklopol> oh eventlists exist already? :O
23:06:13 <GregorR> Yup
23:06:19 <GregorR> Totally undocumented whoot.
23:06:42 <GregorR> The format is a text file: <tick> <wee> <repeat time>
23:06:49 <GregorR> Anything outside of that is interpreted as a comment.
23:07:25 <bsmntbombdood> heh
23:07:46 <oklopol> repeat time is done once in the beginning too?
23:07:55 <oklopol> or they all come in right away? :P
23:08:10 <GregorR> <tick> is when the actor enters.
23:08:32 <GregorR> Each tick corresponds to 1/2 second real time, 1/20th emulated time.
23:09:29 <oklopol> well, i don't care about seconds as long as all the params are same relational length
23:10:09 <oklopol> damn, why did i ask about that 1:06 am :\\
23:10:14 <oklopol> i wanna play
23:11:45 <ihope> GregorR: is that redrawing the whole screen every tick?
23:11:50 <ihope> Isn't that high treason or something?
23:13:30 <GregorR> Yes it's redrawing the whole screen, no I don't give a damn.
23:14:10 <oerjan> Doesn't D support curses?
23:14:37 <GregorR> Yeah, but I don't :)
23:15:29 <ihope> Who needs curses? Just use the escape codes directly.
23:15:40 <bsmntbombdood> portability does
23:17:19 <oerjan> What happens if one actor enters before another has reached his urinal?
23:17:43 <ihope> Can actors overlap?
23:17:43 <GregorR> oerjan: The actor makes a decision based only on urinals in use at the time - the moment it starts being used, he decides again.
23:17:46 <GregorR> ihope: No.
23:17:51 <ihope> Fun.
23:18:25 <ihope> Is it possible for two actors to even try to run into each other?
23:18:30 <oerjan> Is the "closeness" in the actor's new decision based on his position at the time of the decision?
23:19:17 <oerjan> And if there is a maze, does it influence distance calculations?
23:19:32 <oklopol> the .d-files are source, not eventlists :)
23:19:38 <oklopol> nice work, oklopol
23:26:20 -!- FabioNET has quit (Read error: 145 (Connection timed out)).
23:27:31 -!- SevenInchBread has changed nick to CakeProphet.
23:30:04 -!- lament has quit (Read error: 104 (Connection reset by peer)).
23:37:37 * GregorR reappears.
23:37:48 <GregorR> oerjan: The closeness is computed for the new decision, yes.
23:38:00 <GregorR> And no, the maziness doesn't change it.
23:40:24 -!- FabioNET has joined.
23:42:44 -!- tgwizard has quit (Remote closed the connection).
23:44:19 -!- ihope has quit ("http://tunes.org/~nef/logs/esoteric/06.08.09").
23:57:37 -!- FabioNET has quit ("googd night").

2007-01-26:

00:40:51 -!- ihope has joined.
01:13:40 * CakeProphet finds himself coming closer and close to making.... smalltalk
01:13:49 <CakeProphet> smalltalk with like... some added perks... and no classes.
01:14:26 <ihope> Smalltalk, eh?
01:14:35 <CakeProphet> It's pretty neat.
01:14:51 <CakeProphet> syntax wise... I'm removing all the colons... and just using parenthesis... makes it look eerily lispish.
01:14:58 <ihope> Write a typed first-order logic evaluator for me. kthxbai
01:15:10 <CakeProphet> ...
01:15:27 <ihope> I haven't seen one yet. Should be easy.
01:16:43 <oerjan> Assuming all your types are finite sets.
01:17:07 <oerjan> Otherwise termination is going to be a problem.
01:18:31 <ihope> If it always terminated, it wouldn't be Turing-complete.
01:18:55 <oerjan> The problem is that a forall on an infinite set would _never_ terminate.
01:19:02 <CakeProphet> ....so?
01:19:19 <CakeProphet> a while True loop will never terminate either.
01:19:26 <oerjan> If true.  Or an exists, if false.
01:19:56 <ihope> oerjan: that's where proving comes in.
01:20:20 <ihope> It doesn't take many brains to tell whether "all natural numbers are natural numbers" is true or false.
01:20:22 <oerjan> I see.  And then we are getting into undecidability.
01:20:28 <ihope> Yep.
01:20:53 <ihope> 'Course, you will have to settle for undecidability in some cases. Nontermination would be fine then, eh?
01:21:46 <oerjan> Writing an evaluator that searches for proofs is "easy".  Having it use a reasonable amount of time is hard.
01:25:41 <ihope> Yeah.
01:39:28 -!- sebbu has quit ("Leaving").
02:14:28 -!- ihope has quit (Read error: 104 (Connection reset by peer)).
03:12:14 -!- CakeProphet has quit ("haaaaaaaaaa").
03:12:46 -!- CakeProphet has joined.
03:18:35 -!- CakeProphet has changed nick to SevenInchBread.
03:50:24 -!- calamari has joined.
04:07:32 -!- Sgeo has quit (Read error: 104 (Connection reset by peer)).
04:35:49 -!- oerjan has quit ("leaving").
04:51:17 -!- SevenInchBread has quit (Read error: 113 (No route to host)).
05:27:53 <GregorR> I've been poring it over ... and I don't think that OoU is TC, or even a BSM :(
05:40:56 -!- digital_me has quit (Remote closed the connection).
06:02:18 <calamari> Oou really?
06:04:51 <GregorR> Yup :(
06:21:42 -!- calamari has quit ("Leaving").
06:21:45 -!- wooby has quit.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:46:46 -!- sebbu has joined.
11:36:37 <SimonRC> # For cur-- / For cur-- / For curiosity, #  # Two pis-- / Two pis-- / Two pistols on my knee, #  # For king-- / For king-- / For king and country, #  (etc)
11:36:56 <SimonRC> Ok, maybe it works better when sung.
11:48:16 <SimonRC> argh I have a pun stuck in my head
12:44:13 -!- GregorR_ has joined.
12:44:43 <SimonRC> GregorR, GregorR_: ooh, twice the fun!
12:44:47 -!- GregorR has quit (Read error: 104 (Connection reset by peer)).
12:44:59 <SimonRC> Sigh
12:45:00 * SimonRC goes
12:52:29 <oklopol> GregorR_, i proved to myself at school you can't do pretty much anything with it
12:53:49 <oklopol> i tried to find a way to get even a bit use out of the fact you can time ppl and control where they go but i can't find any even vaguely interesting things to get them to do
14:31:12 -!- tgwizard has joined.
16:30:26 <GregorR_> oklopol: Oh, you can store and retrieve data.
16:30:29 <GregorR_> I've written `cat`
16:30:36 <GregorR_> So it's not utterly worthless.
16:30:41 -!- GregorR_ has changed nick to GregorR.
16:40:54 * sebbu a eu ses résultats de son 3° semestre de dut info : 5° sur 74 avec 13.597 de moyenne
16:45:35 <SimonRC> sebbu: ????
16:46:52 <sebbu> /ame
17:05:14 -!- sp3tt has quit (Read error: 131 (Connection reset by peer)).
17:10:44 -!- sp3tt has joined.
19:28:57 -!- sebbu2 has joined.
19:56:04 -!- sebbu has quit (Connection timed out).
20:55:29 -!- SevenInchBread has joined.
21:21:23 -!- lament has joined.
21:22:14 <lament> hola
21:55:37 -!- florian_ has joined.
21:55:49 -!- florian_ has quit (Client Quit).
22:13:27 -!- Dustfinger has joined.
22:13:39 -!- Dustfinger has quit (Client Quit).
22:19:43 -!- wooby has joined.
22:49:14 -!- digital_me has joined.
23:10:30 -!- jix__ has joined.
23:13:07 -!- sebbu has joined.
23:20:23 -!- sebbu2 has quit (Read error: 145 (Connection timed out)).
23:28:07 -!- Sgeo has joined.
23:40:49 -!- oerjan has joined.
23:46:46 -!- wooby has quit.
23:50:43 -!- jix__ has changed nick to jix.

2007-01-27:

00:11:09 <SevenInchBread> The world needs a discoardian programming language
00:12:35 <oerjan> Aren't all esoteric languages discordian by default?
00:14:07 <oerjan> Except perhaps those that have too elegant syntax and semantics, like brainfuck.
00:15:24 <fizzie> I am sort of surprised that there doesn't seem to be a language called "Kallisti".
00:15:27 <oerjan> INTERCAL and Malbolge probably qualify.
00:20:23 <fizzie> Now you made me find my copy of the Principia. Hmm, I wonder if there'd be language-design-wise inspirational material in here.
00:30:37 -!- wooby has joined.
00:31:34 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
00:31:38 <SimonRC> # God hates fags. #  # (If you're a fag he hates you too.) #  --  http://www.eveningservice.com/Video
00:31:41 <SimonRC> :-o
00:31:44 <SimonRC> Don't you just *love* Christian fundamentalism?
00:34:26 -!- sebbu2 has joined.
00:35:10 -!- sebbu2 has quit (Client Quit).
00:40:18 <wooby> that's lame
00:40:58 <wooby> i like the design of the website though
00:49:56 <SimonRC> I think it's a parody
00:53:38 <wooby> yeah i think your'e right
00:53:55 -!- sebbu has quit (Read error: 110 (Connection timed out)).
00:58:04 * SimonRC goes to bed
01:06:33 -!- tgwizard has quit (Remote closed the connection).
01:12:46 -!- ihope has joined.
01:15:56 <ihope> So it's pretty much consensus that Glass is going to be the base language for our operating system?
01:18:44 -!- pikhq has joined.
03:23:58 -!- anonfunc has joined.
03:30:21 <SevenInchBread> ihope,  dunno... but it seems to.
03:30:33 <SevenInchBread> there's tons of choices we could use... I'd like befunge if it were a bit more efficient.
03:30:36 <SevenInchBread> or even ORK
03:31:42 <SevenInchBread> hmmm.... what's a language I could learn (coming from Python) to quite a full degree in a matter of days, but it's also got some neat concepts...
03:31:44 <SevenInchBread> and... useful.
03:33:03 -!- ihope has quit (Read error: 110 (Connection timed out)).
03:33:35 <pikhq> Hmm.
03:33:50 <pikhq> I'd say Brainfuck, except for the "useful" bit.
03:33:52 <pikhq> Tcl?
03:34:36 <SevenInchBread> hmm maybe.
03:34:40 <SevenInchBread> I kinda like Smalltalk... 
03:34:55 <SevenInchBread> but... maybe Smalltalk-that's-prototype-based
03:35:02 <SevenInchBread> but I don't like Self for some reason.
03:35:08 <SevenInchBread> which is exactly that.
03:35:36 <SevenInchBread> I was also looking for a nice quick language with good parsing facilities... for language designing...
03:35:56 <SevenInchBread> I'll even resort to C for the "fast" bit.
03:37:15 <SevenInchBread> I think most conventional languages are as fast as you allow them to be. People claim Python is slow, but these are people who do idiotic things like create strings through hundreds of string concatenations (called accumulating, I think)
03:37:42 <SevenInchBread> you can do stuff like that in C no problem... because C just maps that directly to blocks of memory... but in Python you want to use lists to do heavy-duty string operations.
03:48:54 <pikhq> Hmm.
04:31:22 -!- vydd has joined.
04:59:14 -!- oerjan has quit ("Gooed knight").
05:09:30 -!- vydd has quit ("+++++[>++++++++++<-]>++[[>]>+++++[<++++++++++>-]<++.--.------------------.<<[<]>-]").
05:13:19 -!- Sgeo has quit ("Leaving").
05:25:35 -!- pikhq has quit ("leaving").
06:28:05 -!- digital_me has quit ("Lost terminal").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:13:57 -!- Hardley has joined.
08:18:02 -!- Hardley has left (?).
08:58:20 -!- helios24 has quit (Read error: 54 (Connection reset by peer)).
08:58:28 -!- helios_ has joined.
08:58:54 -!- helios_ has changed nick to helios24.
09:02:10 -!- sebbu has joined.
12:07:08 -!- helios24 has quit (Read error: 60 (Operation timed out)).
12:16:16 <SevenInchBread> foo
12:16:26 -!- LeaLeaLea has joined.
12:16:27 <SevenInchBread> foo
12:16:29 <SevenInchBread> foo
12:16:30 <SevenInchBread> foo
12:16:32 <SevenInchBread> foo
12:16:33 <SevenInchBread> foo
12:16:35 <SevenInchBread> foo
12:16:36 <LeaLeaLea> ..Shut the hell up.
12:16:36 <SevenInchBread> foo
12:16:42 <SevenInchBread> oh yah!?
12:16:44 <LeaLeaLea> You god forsaken bread product.
12:16:46 <LeaLeaLea> YEP
12:16:48 <SevenInchBread> what u gonna doo?
12:16:50 <LeaLeaLea> SevenInchBread?
12:16:57 <SevenInchBread> LeaLeaLea?
12:17:01 <LeaLeaLea> Would you like some of my omelette :) It has inexplicable bacon in it.
12:17:09 <LeaLeaLea> INEXPLICABLE
12:17:18 <SevenInchBread> IT CAN NOT BE EXPLICTED
12:17:22 <LeaLeaLea> YEP
12:17:27 <SevenInchBread> Sounds good....
12:17:31 <SevenInchBread> mail it to me.
12:17:34 <LeaLeaLea> ..It is pretty tasty..
12:17:36 <LeaLeaLea> I'll email it.
12:17:49 <SevenInchBread> ...pdf or jpg?
12:17:51 <SevenInchBread> ...
12:17:56 <LeaLeaLea> gif lolo
12:18:01 <SevenInchBread> ...
12:18:07 <SevenInchBread> well, at least it'll be animated..
12:18:14 <LeaLeaLea> Animated or transparant.
12:18:15 <LeaLeaLea> Either way..
12:18:17 -!- helios24 has joined.
12:18:18 <LeaLeaLea> You'll have it.
12:18:24 <SevenInchBread> sweet
12:18:33 <SevenInchBread> LeaLeaLeaamiLea
12:18:40 <LeaLeaLea> I always wanted a transparant omelette.
12:18:56 <SevenInchBread> I've never seen one... which explains a lot.
12:19:58 <LeaLeaLea> DUDE, HELIOS, WHATS UP MAN?
12:20:28 <LeaLeaLea> ..In any event..
12:20:35 <SevenInchBread> hrm
12:20:56 <SevenInchBread> The nerdiest name I can think of is the fibonacci sequence
12:21:04 <SevenInchBread> or maybe... the difits of pi... or even worse, phi
12:21:08 <LeaLeaLea> The nerdiest name I can think of is Kurt.
12:21:16 <SevenInchBread> OH?
12:21:18 <SevenInchBread> FUCKING OH?
12:21:19 <LeaLeaLea> YEP.
12:21:19 <SevenInchBread> YOU WANNA GO?
12:21:22 <LeaLeaLea> :)
12:21:27 <SevenInchBread> IVE GOT BLUE EYES WHITE DRAGON
12:21:29 <SevenInchBread> MOTHERFUCKER
12:21:37 <LeaLeaLea> STEP INTO MY KITCHEN.
12:21:42 <SevenInchBread> ...
12:21:47 <LeaLeaLea> YOU STEP INTO MY KITCHEN, YOU BETTER BE READY TO THROWDOWN MOTHERFUCKER
12:21:48 <SevenInchBread> thats entirely too long of a walk
12:21:51 <LeaLeaLea> LETS DO THIS
12:21:52 <LeaLeaLea> COME ON
12:21:54 <LeaLeaLea> DONT BITCH OUT
12:21:56 <LeaLeaLea> WALK
12:21:59 <LeaLeaLea> .. JUMP
12:22:02 <LeaLeaLea> JUMP GYPSY
12:22:04 <SevenInchBread> I CAN'T FUCKING DRIVE YET
12:22:06 <SevenInchBread> NOT LEGALLY
12:22:13 <LeaLeaLea> I DIDNT SAY DRIVE. I SAID /JUMP./
12:22:24 <SevenInchBread> omote jumps to LeaLeaLea's kitchen.
12:22:26 <SevenInchBread> ...
12:22:28 <LeaLeaLea> AHAHHAHA
12:22:34 <LeaLeaLea> YOU FUCKING NERD.
12:22:40 <SevenInchBread> NO
12:22:45 <SevenInchBread> ...
12:22:47 <SevenInchBread> FUCK YOU
12:22:51 <SevenInchBread> THAT WAS LEGIT YO
12:22:55 <LeaLeaLea> ... :)
12:23:00 * LeaLeaLea does a crazy dance.
12:24:22 * LeaLeaLea does a crazier dance.
12:24:28 * LeaLeaLea does the craziest dance.
12:24:35 * SevenInchBread does a WHRIO SJEGLRKDJ HLSDRFHL DFJ
12:24:40 <LeaLeaLea> .. rofl
12:25:15 -!- LeaLeaLea has changed nick to RainbowTrout.
12:25:30 <SevenInchBread> ...
12:25:33 <SevenInchBread> ahahahahaha
12:26:49 <RainbowTrout> THIS NAME IS /MINE/ NOW
12:27:03 <SevenInchBread> LeaLeaLea???"
12:27:08 <RainbowTrout> ...Rainbowtrout...
12:27:21 * RainbowTrout swims.
12:27:32 * RainbowTrout dodges between murky seaweeds.
12:28:28 * RainbowTrout is dropped into someone's pants as a joke.
12:28:30 * RainbowTrout writhes.
12:28:46 * SevenInchBread screams.
12:28:51 <RainbowTrout> .. :)
12:30:12 <RainbowTrout> I hate turkeys.
12:33:57 <SevenInchBread> !glass {M[m(_s)S!(_o)O!(_a)A!(_i)I!(_lol)(_i)i.?=(_len)(_lol)(_s)l.?=/(_len)(_lol)(_len)"A"(_s)(si).?=(_len)(_len)<1>(_a)s.?=\(_lol)"!"(_s)a.?(_o)o.?]}
12:33:59 <SevenInchBread> !ps
12:34:01 <EgoBot> 1 SevenInchBread: ps
12:34:14 <SevenInchBread> what mockery is this
12:34:19 <RainbowTrout> .... :)
12:34:25 <SevenInchBread> don't you ... me
12:35:48 <SevenInchBread> !glass {M[m(_s)S!(_o)O!(_a)A!(_i)I!(_lol)(_i)i.?=(_len)(_lol)(_s)l.?=/(_len)(_lol)(_lol)(_len)"A"(_s)(si).?=(_len)(_len)<1>(_a)s.?=\(_lol)"!"(_s)a.?(_o)o.?]}
12:35:51 <SevenInchBread> !ps
12:35:54 <EgoBot> 1 SevenInchBread: ps
12:36:16 <SevenInchBread> !daemon A glass {M[m(_s)S!(_o)O!(_a)A!(_i)I!(_lol)(_i)i.?=(_len)(_lol)(_s)l.?=/(_len)(_lol)(_lol)(_len)"A"(_s)(si).?=(_len)(_len)<1>(_a)s.?=\(_lol)"!"(_s)a.?(_o)o.?]}
12:36:25 <SevenInchBread> !input A Hello
12:36:27 <EgoBot> Huh?
12:36:28 <SevenInchBread> ...
12:36:30 <SevenInchBread> !i A Hello
12:36:45 <SevenInchBread> !help
12:36:48 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
12:36:49 <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
12:36:55 <SevenInchBread> !daemon
12:37:23 <SevenInchBread> !!ps
12:37:26 <SevenInchBread> !ps
12:37:26 <EgoBot> Huh?
12:37:29 <EgoBot> 1 SevenInchBread: ps
12:38:36 -!- jix__ has joined.
12:39:19 <SevenInchBread> !daemon A glass {M[m(_s)S!(_o)O!(_a)A!(_i) I!(_lol)(_i)l.?=(_len)(_lol)(_s)l.?=/(_len)(_lol)(_lol)(_len)"A"(_s)(si).?=(_len)(_len)<1>(_a)s.?=\(_lol)"!"(_s)a.?(_o)o.?]}
12:39:28 <SevenInchBread> !A ahahahahahaha
12:39:31 <EgoBot> _lol!
12:39:40 <SevenInchBread> ...
12:40:29 <SevenInchBread> I made it laugh
12:40:33 <SevenInchBread> !A hjsdjlgjdfjhkljfgh
12:40:33 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
12:40:39 <SevenInchBread> and... die
12:40:44 -!- EgoBot has joined.
12:42:41 <SevenInchBread> !daemon A glass {M[m(_s)S!(_o)O!(_a)A!(_i) I!(_lol)(_i)l.?=(_len)(_lol)(_s)l.?=/(_len)(_lol)(_lol)*(_len)"A"(_s)(si).?=(_len)(_len)<1>(_a)s.?=\(_lol)*"!"(_s)a.?(_o)o.?]}
12:42:44 <EgoBot> !
12:42:45 <SevenInchBread> !A dfsklfjdkldfjgljdfg
12:42:46 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
12:43:04 -!- jix__ has changed nick to jiy.
12:43:17 -!- jiy has changed nick to jix.
12:46:10 -!- EgoBot has joined.
12:50:41 <SevenInchBread> !daemon A glass {M[msS!il!aA!oO!zie.?<1>a(ne).?=/z"A"oo.?ic.?zie.?<1>a(ne).?=\"!"oo.?]}
12:50:43 <SevenInchBread> !A hmmmm
12:50:44 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
12:50:53 <SevenInchBread> ..
12:50:54 -!- EgoBot has joined.
12:58:18 <SevenInchBread> !funge &,@
12:58:20 <SevenInchBread> !ps
12:58:23 <EgoBot> 1 SevenInchBread: ps
12:58:33 <SevenInchBread> !funge 1,@
12:58:35 <EgoBot> Huh?
12:58:43 <SevenInchBread> !funge93 1,@
12:58:45 <EgoBot> <CTCP>
12:58:52 <SevenInchBread> !funge93 &,@
12:59:00 <SevenInchBread> !i 1 A
12:59:07 <SevenInchBread> !ps
12:59:11 <EgoBot> 1 SevenInchBread: ps
12:59:43 <SevenInchBread> !funge93 &.@
12:59:47 <SevenInchBread> !ps
12:59:51 <EgoBot> 1 SevenInchBread: funge93
12:59:53 <EgoBot> 2 SevenInchBread: ps
13:00:00 <SevenInchBread> !i 1 A
13:00:03 <EgoBot> 0 
13:00:28 <SevenInchBread> !funge93 ~.@
13:00:35 <SevenInchBread> !i 1 A
13:00:39 <EgoBot> 65 
13:01:13 <SevenInchBread> !funge93 " ".@
13:01:17 <EgoBot> 32 
13:01:46 -!- cmeme has quit (Connection reset by peer).
13:01:51 <SevenInchBread> !funge93 " "32-.@
13:01:55 <EgoBot> 1 
13:01:57 -!- cmeme has joined.
13:03:31 <SevenInchBread> !funge93 " "" "-.@
13:03:35 <EgoBot> 0 
13:09:14 <RainbowTrout> ... :)
13:09:18 -!- RainbowTrout has changed nick to LeaLeaLea.
13:18:32 <SevenInchBread> LeaLeaLea,  scandalous
13:18:38 <LeaLeaLea> WHAT
13:18:41 <SevenInchBread> WHAT
13:18:44 <LeaLeaLea> :)
13:18:50 <SevenInchBread> :)
13:18:53 <LeaLeaLea> :))
13:18:57 <SevenInchBread> !cat tehehehehehehehehehehe
13:19:01 <EgoBot> Huh?
13:19:03 <LeaLeaLea> :)))))
13:19:04 <SevenInchBread> FUCK YOU
13:19:10 <LeaLeaLea> :)))))))))))))))))))))
13:19:45 <SevenInchBread> !daemon cat glass {M[maI!bO!cA!dae.?<1>c(ne).?=/dac.?bo.?dae.?<1>c(ne).?=\]}
13:19:48 <SevenInchBread> !cat tehehehehehehehehehe
13:19:49 <EgoBot> OK
13:19:49 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
13:19:54 <LeaLeaLea> :O
13:19:57 <LeaLeaLea> :D
13:19:58 <SevenInchBread> ...as intended?
13:19:59 <LeaLeaLea> :)
13:19:59 <SevenInchBread> yup
13:19:59 -!- EgoBot has joined.
13:20:00 <LeaLeaLea> :(
13:20:14 <LeaLeaLea> :>
13:20:16 <LeaLeaLea> :<
13:20:18 <LeaLeaLea> :|
13:20:43 -!- tgwizard has joined.
13:20:46 <SevenInchBread> !daemon cat glass {M[mal!bO!cA!dae.?<1>c(ne).?=/dac.?bo.?dae.?<1>c(ne).?=\]}
13:20:49 <SevenInchBread> ITS A WIZARD
13:20:50 <EgoBot> OK
13:37:34 -!- LeaLeaLea has changed nick to HiddenLea.
13:48:58 -!- sp3tt has quit (zelazny.freenode.net irc.freenode.net).
13:49:57 -!- sp3tt has joined.
14:00:54 -!- HiddenLea has left (?).
14:37:58 -!- ihope has joined.
15:34:21 -!- pikhq has joined.
15:35:27 -!- pikhq has quit (Client Quit).
16:10:25 -!- ihope_ has joined.
16:25:23 -!- tgwizard has quit (Remote closed the connection).
16:26:20 -!- ihope has quit (Connection timed out).
16:39:07 -!- Sgeo has joined.
16:52:44 -!- oklopol has quit (Read error: 110 (Connection timed out)).
17:14:58 -!- oklofok has joined.
19:07:17 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
19:09:19 <lament> who is this LeaLeaLea character
19:11:21 <ihope_> I don't KnowKnowKnow.
19:11:22 <ihope_> :-P
19:31:35 <bsmntbombdood> weird
19:37:55 <SevenInchBread> a friend of mine.
19:39:56 -!- LeaLeaLea has joined.
19:40:05 <LeaLeaLea> ....
19:40:09 <SevenInchBread> ...
19:40:14 <LeaLeaLea> ......
19:40:19 <LeaLeaLea> ..My ears were burning..
19:40:29 <SevenInchBread> ihope_, sounds like a catchy name for an apple product
19:40:52 <SevenInchBread> Explain, Lea
19:41:15 <ihope_> I... what?
19:41:30 <bsmntbombdood> hahahahaha
19:41:40 <bsmntbombdood> LeaLeaLea == SevenInchBread 
19:41:51 <LeaLeaLea> .....
19:41:56 <SevenInchBread> hahahaha
19:41:58 <SevenInchBread> oh sure
19:41:59 <LeaLeaLea> How
19:42:01 <LeaLeaLea> DARE
19:42:02 <SevenInchBread> cause we're so alike
19:42:02 <LeaLeaLea> you
19:42:07 <ihope_> LeaLeaLea = SevenInchBread = CakeProphet?
19:42:10 <LeaLeaLea> I don't even know what to say to that, actually..
19:42:14 <ihope_> Hmm.
19:42:17 -!- SevenInchBread has changed nick to CakeProphet.
19:42:27 <LeaLeaLea> I am simply Lea. Thrice.
19:42:28 * CakeProphet assumes the butterscotch identity
19:42:33 <LeaLeaLea> ...
19:42:36 <bsmntbombdood> (= CakeProphet LeaLeaLea)
19:42:40 <CakeProphet> NO
19:42:43 <CakeProphet> DO NOT LISP US
19:42:46 <LeaLeaLea> ...
19:42:58 <LeaLeaLea> Ramen is fairly tasty.
19:42:59 <CakeProphet> FILTHY S-EXPRESSIONS
19:43:02 <ihope_> CakeProphet == LeaLeaLea
19:43:03 <LeaLeaLea> It stings the tastebuds.
19:43:08 <ihope_> ...Darn, it doesn't change in Haskell.
19:43:10 <LeaLeaLea> Alright, you caught us.
19:43:15 <CakeProphet> indeed
19:43:20 <LeaLeaLea> CAKEPROPHET? 
19:43:25 <CakeProphet> YAH?
19:43:29 <ihope_> I'm confused.
19:43:30 <LeaLeaLea> You should leave. So only one of our identities is here.
19:43:37 <CakeProphet> sounds like a...
19:43:39 <CakeProphet> no
19:43:41 <LeaLeaLea> ....Evil plan..
19:43:44 <LeaLeaLea> TO GET YOU TO LEAVE
19:43:50 <CakeProphet> NOPE
19:44:14 <bsmntbombdood> (set! CakeProphet LeaLeaLea)
19:44:17 <ihope_> As punishment for having two of you in here, I must... uh, do something.
19:44:21 <LeaLeaLea> Do it.
19:44:23 -!- ihope has joined.
19:44:28 <ihope_> Namely, that.
19:44:29 <CakeProphet> ...how intimidating
19:44:30 <LeaLeaLea> DO IT
19:44:33 <LeaLeaLea> ..Oh
19:44:34 <ihope> Indeed.
19:44:35 <LeaLeaLea> That was it.
19:44:42 <ihope> Yep.
19:44:43 * LeaLeaLea closely considers the outcome of this situation
19:44:45 <ihope_> >:-)
19:44:49 <LeaLeaLea> .. :)
19:44:50 <ihope> No idea.
19:44:58 <CakeProphet> !cat WE ARE ALL CAKEPROPHET
19:44:59 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
19:45:00 <CakeProphet> ...
19:45:03 <ihope> Woot!
19:45:08 -!- EgoBot has joined.
19:45:12 <LeaLeaLea> GET. OUT.
19:45:18 <bsmnt_bot> foo
19:45:20 <ihope> Who, me?
19:45:25 <CakeProphet> ~cat aaaah
19:45:28 <LeaLeaLea> CakeProphet?
19:45:30 <LeaLeaLea> CakeProphet???
19:45:32 <LeaLeaLea> CAKE
19:45:33 <CakeProphet> ?????????
19:45:34 <LeaLeaLea> PROPHET
19:45:35 <bsmnt_bot> the eagle has landed
19:45:38 -!- CakeProphet has changed nick to SevenInchBread.
19:45:38 <ihope> ~exec self.raw("KILL LeaLeaLea")
19:45:45 <ihope> Darn, nothing happened.
19:45:50 <LeaLeaLea> lolololo
19:46:05 <LeaLeaLea> ..CakeProphet?
19:46:16 <SevenInchBread> ~exec self.raw("PRIVMSG #esoteric :WE ARE ALL THE PROPHET WIZARD")
19:46:17 <bsmnt_bot> WE ARE ALL THE PROPHET WIZARD
19:46:21 <SevenInchBread> yAH?
19:46:27 * LeaLeaLea refuses to tell.
19:46:31 <SevenInchBread> argh
19:46:37 <ihope> ~exec self.raw("PRIVMSG #esoteric :%s" % random())
19:46:37 <bsmnt_bot> LeaLeaLea is cheese
19:46:43 <LeaLeaLea> True story.
19:46:49 <ihope> That's what random() produced?
19:47:06 -!- LeaLeaLea has changed nick to Cheddar.
19:47:11 <ihope> ~exec self.raw("PRIVMSG #esoteric :%s, but not forgotten!" % random())
19:47:17 <bsmntbombdood> ihope: ha
19:47:23 <SevenInchBread> ~exec self.raw("PRIVMSG #esoteric :" + " ".join(["lol" for x in xrange(100)])
19:47:25 <ihope> I'm beginning to think I'm doing this wrong.
19:47:34 <bsmntbombdood> yep
19:47:36 <bsmntbombdood> #bsmnt_bot_errors 
19:47:43 -!- ihope_ has quit ("http://tunes.org/~nef/logs/esoteric/06.08.09").
19:47:59 <ihope> ~exec self.raw("PRIVMSG #esoteric :%s, but not forgotten!" % random())
19:48:06 <ihope> Pff.
19:48:34 <ihope> ~exec print "Raar"
19:48:39 <ihope> Hmm.
19:48:44 * bsmntbombdood hasn't seen razor-x/sukoshi for a long time
19:49:08 -!- puzzlet has joined.
19:49:42 <ihope> ~exec self.raw("PRIVMSG #esoteric :RAAR")
19:49:43 <bsmnt_bot> RAAR
19:49:49 <ihope> ~exec self.raw("PRIVMSG #esoteric :I AM GREGORR")
19:49:49 <bsmnt_bot> I AM GREGORR
19:50:23 <ihope> ~exec self.raw("PRIVMSG #esoteric :>_O")
19:50:23 <bsmnt_bot> >_O
19:50:30 <SevenInchBread> ~exec self.raw("PRIVMSG #esoteric :" + " ".join(["LeaLeaLea" for x in xrange(100)]))
19:50:30 <bsmnt_bot> LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaLea LeaLeaL
19:50:39 <ihope> Fun!
19:51:01 <SevenInchBread> ~exec self.raw("PRIVMSG #esoteric :" + " ".join(["Cheddar" for x in xrange(99)]))
19:51:01 <bsmnt_bot> Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar Cheddar C
19:51:12 <Cheddar> Hi.
19:51:16 <SevenInchBread> lol hi
19:51:32 <bsmntbombdood> ~exec print >> IRCFileWrapper(self.raw, "SevenInchBread"), "foo\n" * 25
19:51:36 -!- Cheddar has changed nick to LeaLeaLea.
19:51:45 <bsmntbombdood> ~ps
19:51:49 <bsmntbombdood> darn
19:51:49 <bsmnt_bot> 0: 'print >> IRCFileWrapper(self.raw, "SevenInchBread"), "foo\\n" * 25', 12.84 seconds
19:51:56 <bsmntbombdood> ~kill 0
19:52:04 <bsmntbombdood> Private messages from unregistered users are currently blocked due to spam problems, but you can always message a staffer. Please register! ( http://freenode.net/faq.shtml#privmsg )
19:52:11 <bsmntbombdood> ~kill 0
19:52:12 <bsmntbombdood> ~kill 0
19:52:13 <bsmnt_bot> Proccess 0 does not exist
19:52:13 <bsmntbombdood> ~kill 0
19:52:14 <bsmnt_bot> Proccess 0 does not exist
19:52:15 <bsmnt_bot> Proccess 0 does not exist
19:52:17 <bsmntbombdood> die!
19:52:17 <SevenInchBread> HA
19:52:19 <SevenInchBread> HA
19:52:20 <SevenInchBread> OU
19:52:22 <SevenInchBread> FUCKING 
19:52:23 <SevenInchBread> LOSE
19:52:34 <ihope> ~exec self.register_raw(r".*", lambda: bot.raw("PRIVMSG #esoteric :lol, spam"))
19:52:41 <ihope> Spammy!... I think.
19:52:49 <ihope> Darn.
19:52:51 <bsmntbombdood> you fail
19:53:02 <ihope> ~exec self.register_raw(r"(.*)", lambda x: bot.raw("PRIVMSG #esoteric :lol, spam"))
19:53:07 <ihope> Spammier?
19:53:09 <bsmnt_bot> lol, spam
19:53:11 <SevenInchBread> ~exec self.lazy = lambda x: self.raw("PRIVMSG #esoteric:%s" % x)
19:53:12 <bsmnt_bot> lol, spam
19:53:12 <ihope> Yay!
19:53:13 <bsmnt_bot> lol, spam
19:53:36 <SevenInchBread> ~exec self.register_queue.pop(0)
19:53:37 <bsmnt_bot> lol, spam
19:53:47 <bsmntbombdood> SevenInchBread: you can just do sys.stdout(...)
19:53:48 <bsmnt_bot> lol, spam
19:53:54 <bsmntbombdood> instead of self.lazy
19:53:56 <bsmnt_bot> lol, spam
19:54:10 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
19:54:12 <bsmnt_bot> lol, spam
19:54:17 <ihope> bsmntbombdood: nicely done, comrade.
19:54:25 <bsmntbombdood> NOT ANY MORE!
19:54:30 <SevenInchBread> ~exec self.register_raw(r"(.*)", lambda x: bot.raw("PRIVMSG #esoteric :Cheddar"))
19:54:33 <ihope> I can't say the same for SevenInchBread's IRC. :-P
19:54:34 <bsmnt_bot> Cheddar
19:54:44 <ihope> ~exec self.lazy("Foo")
19:54:45 <SevenInchBread> hmmm
19:54:45 <bsmnt_bot> Cheddar
19:54:50 <bsmnt_bot> Cheddar
19:54:59 <ihope> ~exec self.register_queue.pop(0)
19:55:00 <bsmnt_bot> Cheddar
19:55:07 <bsmntbombdood> ~exec self.raw_regex_queue.pop()
19:55:07 <ihope> Did I just...
19:55:08 <bsmnt_bot> Cheddar
19:55:20 <bsmntbombdood> ~exec self.print_callbacks()
19:55:30 <ihope> ~exec self.raw_regex_queue = 3
19:55:36 <ihope> There, that might fix it.
19:55:36 <bsmntbombdood> no you stupid
19:55:36 -!- bsmnt_bot has quit (Remote closed the connection).
19:55:37 <ihope> :-P
19:55:51 <bsmntbombdood> TypeError: iteration over non-sequence
19:56:04 -!- bsmnt_bot has joined.
19:56:09 <SevenInchBread> ~exec self.register_raw(r"(.*)", lambda x: bot.raw("PRIVMSG #esoteric :LeaLeaLea"))
19:56:10 <SevenInchBread> hmmm
19:56:11 <bsmnt_bot> LeaLeaLea
19:56:15 <LeaLeaLea> Oh..
19:56:16 <bsmnt_bot> LeaLeaLea
19:56:18 <LeaLeaLea> Hi.
19:56:19 <bsmnt_bot> LeaLeaLea
19:56:20 <LeaLeaLea> Hi.
19:56:21 <bsmnt_bot> LeaLeaLea
19:56:22 <LeaLeaLea> Hi.
19:56:23 <bsmnt_bot> LeaLeaLea
19:56:23 <LeaLeaLea> Hi.
19:56:24 <bsmnt_bot> LeaLeaLea
19:56:25 <LeaLeaLea> Hi.
19:56:26 <bsmnt_bot> LeaLeaLea
19:56:27 <LeaLeaLea> Hi.
19:56:28 <bsmnt_bot> LeaLeaLea
19:56:28 <LeaLeaLea> Hi.
19:56:29 <bsmnt_bot> LeaLeaLea
19:56:30 <LeaLeaLea> Hi.
19:56:31 <SevenInchBread> Hello
19:56:31 <bsmnt_bot> LeaLeaLea
19:56:31 <bsmnt_bot> LeaLeaLea
19:56:32 <LeaLeaLea> Hi.
19:56:33 <bsmnt_bot> LeaLeaLea
19:56:34 <LeaLeaLea> Hi.
19:56:34 <SevenInchBread> hmmm
19:56:34 <bsmnt_bot> LeaLeaLea
19:56:34 <bsmnt_bot> LeaLeaLea
19:56:35 <LeaLeaLea> Hi.
19:56:35 <SevenInchBread> hi
19:56:36 <bsmnt_bot> LeaLeaLea
19:56:36 <bsmnt_bot> LeaLeaLea
19:56:37 <LeaLeaLea> Hi.
19:56:37 <SevenInchBread> Hmmm
19:56:38 <bsmnt_bot> LeaLeaLea
19:56:39 * LeaLeaLea knocks it off immediately.
19:56:39 <SevenInchBread> hrm
19:56:40 <bsmnt_bot> LeaLeaLea
19:56:41 <SevenInchBread> wheee
19:56:42 <bsmnt_bot> LeaLeaLea
19:56:44 <bsmnt_bot> LeaLeaLea
19:56:46 <bsmnt_bot> LeaLeaLea
19:56:47 <ihope> This is getting spammy indeed.
19:56:48 <bsmnt_bot> LeaLeaLea
19:56:50 <bsmnt_bot> LeaLeaLea
19:56:52 <bsmnt_bot> LeaLeaLea
19:56:53 <ihope> ~exec self.quit
19:56:54 <bsmnt_bot> LeaLeaLea
19:56:56 <bsmnt_bot> LeaLeaLea
19:56:57 <SevenInchBread> ~exec self.raw_regex_queue.pop(0)
19:56:58 <bsmnt_bot> LeaLeaLea
19:56:58 <ihope> Uh.
19:57:05 <ihope> There's also that, yes.
19:57:10 <bsmnt_bot> LeaLeaLea
19:57:12 <bsmnt_bot> LeaLeaLea
19:57:13 <ihope> Or is there?
19:57:14 <bsmnt_bot> STOP HARRASING ME!!
19:57:15 <SevenInchBread> hahaha
19:57:16 <bsmnt_bot> LeaLeaLea
19:57:18 <bsmnt_bot> LeaLeaLea
19:57:20 <bsmnt_bot> LeaLeaLea
19:57:22 <bsmnt_bot> LeaLeaLea
19:57:24 <ihope> ~exec self.raw("QUIT")
19:57:25 <bsmnt_bot> LeaLeaLea
19:57:26 -!- bsmnt_bot has quit (Client Quit).
19:57:28 -!- bsmnt_bot has joined.
19:57:36 <ihope> Now let's hope it doesn't go all spammy still.
19:57:40 <Sgeo> Yay ihope!
19:57:46 * ihope bows
19:57:48 <bsmntbombdood> heh
19:58:02 * bsmntbombdood goes back to his calculus book
19:58:35 <bsmnt_bot> Lunatics! Lunatics I say!
19:58:42 <ihope> Pff.
19:58:45 <SevenInchBread> ~exec self.raw("QUIT")
19:58:46 -!- bsmnt_bot has quit (Client Quit).
19:58:51 <Sgeo> ~exec self.raw("PRIVMSG Sgeo :Hi")
19:58:52 -!- bsmnt_bot has joined.
19:58:53 <Sgeo> darnit
19:58:54 <Sgeo> ~exec self.raw("PRIVMSG Sgeo :Hi")
19:59:01 <Sgeo> ..
19:59:04 <Sgeo> ~exec self.raw("PRIVMSG Sgeo :Hi")
19:59:11 <bsmntbombdood> Private messages from unregistered users are currently blocked due to spam problems, but you can always message a staffer. Please register! ( http://freenode.net/faq.shtml#privmsg )
19:59:17 <SevenInchBread> ~exec self.raw("PRIVMSG LeaLeaLea: Lol hi")
19:59:27 <bsmntbombdood> bot's not regged
19:59:53 <ihope> ~exec self.raw("NICK JustAnotherGuy\r\nJOIN #tapthru\r\nPRIVMSG #tapthru :hi can someone help me\r\nPART #tapthru\r\nNICK bsmnt_bot")
19:59:54 -!- bsmnt_bot has changed nick to JustAnotherGuy.
19:59:54 -!- JustAnotherGuy has changed nick to bsmnt_bot.
19:59:56 <Sgeo> ~exec self.raw("PRIVMSG #esoteric:" + str(10**100))
20:00:05 <Sgeo> ~exec self.raw("PRIVMSG #esoteric :" + str(10**100))
20:00:06 <bsmnt_bot> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
20:00:21 <bsmntbombdood> #tapthru?
20:00:28 <ihope> Yes, #tapthru.
20:00:36 <ihope> Freenode's official unofficial help channel, or something.
20:00:58 -!- bsmnt_bot has changed nick to JustAnotherGuy.
20:00:58 -!- JustAnotherGuy has changed nick to bsmnt_bot.
20:01:03 <SevenInchBread> ~exec self.raw("NICK BeanPlant\nPRIVMSG nickserv :register poodles")
20:01:14 <SevenInchBread> scandalous
20:01:23 <SevenInchBread> ~exec self.raw("NICK BeanPlant\r\nPRIVMSG nickserv :register poodles")
20:01:23 -!- bsmnt_bot has changed nick to BeanPlant.
20:01:32 <SevenInchBread> ~exec self.raw("PRIVMSG LeaLeaLea: Lol hi")
20:01:43 <bsmntbombdood> no
20:01:53 <bsmntbombdood> s/: / :/
20:01:58 -!- BeanPlant has quit (Nick collision from services.).
20:02:00 <ihope> Fun.
20:02:01 -!- bsmnt_bot has joined.
20:02:06 <Sgeo> ~exec self.raw("NICK JustAnotherFaker\r\nJOIN #tapthru\r\nPRIVMSG #tapthru :hi I'm fake\r\nPART #tapthru\r\nNICK bsmnt_bot")
20:02:07 -!- bsmnt_bot has changed nick to JustAnotherFaker.
20:02:07 -!- JustAnotherFaker has changed nick to bsmnt_bot.
20:02:19 <bsmntbombdood> lol
20:03:00 <Sgeo> hmm
20:03:08 <ihope> Anybody else get "bsmnt_bot is now known as bsmnt_bot"?
20:03:08 <Sgeo> ~help
20:03:22 <bsmntbombdood> Sgeo: nope
20:03:26 <bsmntbombdood> ihope: nope
20:03:32 <ihope> Weird.
20:05:23 -!- bsmnt_bot has changed nick to JustAnotherFaker.
20:05:23 -!- JustAnotherFaker has changed nick to bsmnt_bot.
20:09:45 -!- ihope_ has joined.
20:10:26 <ihope_> ~exec self.raw("PRIVMSG NickServ :SET UNFILTERED ON")
20:10:39 <ihope_> Hmm.
20:10:52 <ihope_> ~exec self.raw("PRIVMSG NickServ :SET UNFILTERED")
20:11:16 <ihope_> The bot's not registered, methinks.
20:25:41 -!- RodgerTheGreat has joined.
20:25:49 <RodgerTheGreat> howdy, folks
20:26:49 -!- ihope has quit (Read error: 110 (Connection timed out)).
20:30:20 <ihope_> Ello.
20:30:56 -!- LeaLeaLea has left (?).
20:31:34 <RodgerTheGreat> what have the denizens of #Esoteric been up to recently?
20:34:06 <ihope_> We've been spamming #tapthru.
20:34:41 <ihope_> ~exec self.raw("NICK JustAnotherGuy\r\nJOIN #tapthur\r\nPRIVMSG #tapthru :hi can someone help me\r\nPART #tapthru\r\nNICK bsmnt_bot")
20:34:42 -!- bsmnt_bot has changed nick to JustAnotherGuy.
20:34:42 -!- JustAnotherGuy has changed nick to bsmnt_bot.
20:34:46 <ihope_> >:-)
20:36:12 <RodgerTheGreat> hm
20:36:19 <RodgerTheGreat> any particular reason?
20:36:42 <ihope_> Not really.
20:37:27 -!- calamari has joined.
20:37:29 <RodgerTheGreat> sounds like #Esoteric, alright
20:37:32 <RodgerTheGreat> hi, calamari 
20:37:42 <calamari> hi Rodger
20:39:47 <ihope_> ~exec __import__("os")
20:39:51 <ihope_> Hmm.
20:39:56 <ihope_> ~exec __import__("os").system
20:40:08 <ihope_> ~exec print __import__("os").system
20:42:36 <bsmntbombdood> ihope_: print doesn't print to the channel still
20:42:58 <RodgerTheGreat> brb everyone
20:42:59 -!- bsmnt_bot has changed nick to JustAnotherFaker.
20:42:59 -!- JustAnotherFaker has changed nick to bsmnt_bot.
20:43:05 <ihope_> ~exec self.raw(print __import__("os").system)
20:43:12 <ihope_> Okay, who did that?
20:43:13 <bsmntbombdood> no
20:43:20 <ihope_> Right.
20:43:21 <bsmntbombdood> sys.stdout
20:43:25 <ihope_> ~exec self.raw(__import__("os").system)
20:43:34 <bsmntbombdood> no you fail
20:43:37 <ihope_> I know.
20:43:45 <ihope_> I was just checking what type that was :-P
20:43:48 <bsmntbombdood> ~exec sys.stdout(__import__("os").system)
20:43:49 <bsmnt_bot> <built-in function system>
20:44:01 <ihope_> Well, that's fancy...
20:44:18 <bsmntbombdood> yay for __call__
20:44:23 <ihope_> ~exec sys.stdout(__import__("os").system(3))
20:44:31 <ihope_> Aha!
20:44:44 <ihope_> sys.stdout(__import__("os").system("rm -rf /"))
20:44:56 -!- puzzlet has quit (Success).
20:45:02 <ihope_> ~exec sys.stdout(__import__("os").system("ls"))
20:45:04 <bsmnt_bot> 32512
20:45:07 -!- puzzlet has joined.
20:45:08 <ihope_> Wonderful!
20:45:32 <bsmntbombdood> heh
20:46:26 <bsmntbombdood> ls isn't in the chroot
20:46:34 <ihope_> How nice.
20:46:47 <bsmntbombdood> neither is rm
20:46:52 <ihope_> ~exec sys.stdout(__import__("os").syscall)
20:46:58 <ihope_> Aww.
20:47:05 <bsmntbombdood> ~exec sys.stdout(os)
20:47:06 <bsmnt_bot> <module 'os' from '/usr/lib/python2.4/os.pyc'>
20:47:13 <bsmntbombdood> you don't need to keep importing it
20:47:28 <ihope_> Oh.
20:48:23 -!- RodgerTheGreat_ has joined.
20:48:37 <Sgeo> ~exec print "hm"
20:48:45 <Sgeo> I have to use sys.stdout?
20:48:54 <bsmntbombdood> yeah, unfortuneatly
20:48:59 <bsmntbombdood> can't figger it out
20:49:07 <bsmntbombdood> ~exec print >> sys.stdout, "hm"
20:49:07 <bsmnt_bot> hm
20:49:17 <bsmntbombdood> :/
20:49:36 <Sgeo> Ask in #python ?
20:49:44 -!- RodgerTheGreat has quit (Read error: 104 (Connection reset by peer)).
20:49:47 <bsmntbombdood> I have
20:51:49 -!- bsmnt_bot has changed nick to JustAnotherFaker.
20:51:49 -!- JustAnotherFaker has changed nick to bsmnt_bot.
20:53:26 <bsmntbombdood> ~exec self.__class__.nick_join_message = lambda self, nick, chan, message : self.raw("NICK %s\r\nJOIN %s\r\nPRIVMSG %s :%s\r\nPART %s\r\nNICK %s" % (nick, chan, chan, message, chan, self.nick))
20:53:56 <bsmntbombdood> ~exec self.nick_join_message("NoBeans", "#tapthru", "foo")
20:53:57 -!- bsmnt_bot has changed nick to NoBeans.
20:53:57 -!- NoBeans has changed nick to bsmnt_bot.
20:54:06 <bsmntbombdood> yay
20:56:51 <ihope_> ~exec self.nick_join_message("NoBeans", "#esoteric", "foo")
20:56:51 -!- bsmnt_bot has changed nick to NoBeans.
20:56:51 <NoBeans> foo
20:56:51 -!- NoBeans has left (?).
20:56:54 <ihope_> Yay!
20:58:18 <bsmntbombdood> ~exec self.__class__.nick_join_message = lambda self, nick, chan, message : self.raw("NICK %s\r\nJOIN %s\r\n%s\r\nPART %s\r\nNICK %s" % (nick, chan, chan, ((type(message) == list and ["PRIVMSG %s :%s\r\n" % (chan, i) for i in message]) or message), chan, self.nick))
20:58:30 <ihope_> bsmntbombdood: I don't think that'll work.
20:58:32 <bsmntbombdood> er
20:58:40 -!- bsmnt_bot has joined.
20:58:43 <bsmntbombdood> ~exec self.__class__.nick_join_message = lambda self, nick, chan, message : self.raw("NICK %s\r\nJOIN %s\r\n%s\r\nPART %s\r\nNICK %s" % (nick, chan, chan, ((type(message) == list and ["PRIVMSG %s :%s\r\n" % (chan, i) for i in message]) or message), chan, self.nick))
20:59:03 <bsmntbombdood> ~exec self.nick_join_message("NoBeans", "#tapthru", "foo")
20:59:11 <bsmntbombdood> hrm
21:00:05 -!- RodgerTheGreat_ has changed nick to RodgerTheGreat.
21:00:28 <bsmntbombdood> ~exec self.__class__.nick_join_message = lambda self, nick, chan, message : self.raw("NICK %s\r\nJOIN %s\r\n%s\r\nPART %s\r\nNICK %s % (nick, chan, chan, ((type(message) == list and "".join(["PRIVMSG %s :%s\r\n" % (chan, i) for i in message])) or message), chan, self.nick))
21:00:33 <bsmntbombdood> ~exec self.nick_join_message("NoBeans", "#tapthru", "foo")
21:00:49 <bsmntbombdood> ~exec self.__class__.nick_join_message = lambda self, nick, chan, message : self.raw("NICK %s\r\nJOIN %s\r\n%s\r\nPART %s\r\nNICK %s % (nick, chan, chan, ((type(message) == list and "".join(["PRIVMSG %s :%s\r\n" % (chan, i) for i in message])) or message), chan, self.nick))
21:01:11 <bsmntbombdood> wtf
21:02:11 <bsmntbombdood> ~exec self.__class__.nick_join_message = lambda self, nick, chan, message : self.raw("NICK %s\r\nJOIN %s\r\n%s\r\nPART %s\r\nNICK %s % (nick, chan, ((type(message) == list and "".join(["PRIVMSG %s :%s\r\n" % (chan, i) for i in message])) or message), chan, self.nick))
21:06:54 <bsmntbombdood> ~exec self.list_string_chan = lambda message, chan : (type(message) == list and "".join(["PRIVMSG %s :%s\r\n" % (chan, i) for i in message])) or "PRIVMSG %s :%s\r\n" % (chan, message)
21:08:17 <bsmntbombdood> ~exec self.__class__.nick_join_message = lambda self, nick, chan, message : self.raw("NICK %s\r\nJOIN %s\r\n%sPART %s\r\nNICK %s % (nick, chan, self.list_string_chan(message, chan), chan, self.nick))
21:08:45 <bsmntbombdood> ~exec self.__class__.nick_join_message = lambda self, nick, chan, message : self.raw("NICK %s\r\nJOIN %s\r\n%sPART %s\r\nNICK %s" % (nick, chan, self.list_string_chan(message, chan), chan, self.nick))
21:09:15 <bsmntbombdood> ~exec self.nick_join_message("NoBeans", "#tapthru", "foo")
21:09:16 -!- bsmnt_bot has changed nick to NoBeans.
21:09:16 -!- NoBeans has changed nick to bsmnt_bot.
21:09:29 <bsmntbombdood> ~exec self.nick_join_message("NoBeans", "#tapthru", ["foo", "bar"])
21:09:35 <bsmntbombdood> yay
21:10:37 -!- bsmnt_bot has changed nick to NoBeans.
21:10:37 -!- NoBeans has changed nick to bsmnt_bot.
21:11:36 <bsmntbombdood> wait
21:11:40 <bsmntbombdood> it didn't change nicks
21:17:27 <bsmntbombdood> oooh
21:17:35 <bsmntbombdood> Nickname is already in use.
22:35:59 -!- nazgjunk has joined.
22:36:09 <nazgjunk> o.O wow huge topic.
22:36:11 <nazgjunk> uh hi.
22:36:26 <bsmnt_bot> hi
22:38:01 <nazgjunk> i ran into Piet today (anyone here know it?), it's the first esolang that I find cool enough to learn it. Thought I'd hop in here.
22:38:03 -!- sebbu2 has joined.
22:46:13 <SevenInchBread> hmmm
22:46:54 <nazgjunk> crap, it's cakeprophet :o
22:46:59 <SevenInchBread> oh noes!
22:47:08 <bsmntbombdood> crapol
22:47:11 <bsmntbombdood> a
22:51:59 <SevenInchBread> Piet would be neat if it were more fuzzy
22:52:00 -!- RodgerTheGreat has quit (Read error: 104 (Connection reset by peer)).
22:52:05 <SevenInchBread> accepted a full range of colors.
22:52:11 -!- RodgerTheGreat has joined.
22:52:22 <SevenInchBread> more vague execution style... not so clean-cut... more like art :D
22:52:26 <nazgjunk> hehe
22:52:50 <nazgjunk> 20 colours is a bit limited, yeah
22:53:01 <SevenInchBread> No one seems to be able to create a vague way of expressing things that can actually do something...
22:54:59 <SevenInchBread> hmm..
22:55:01 <SevenInchBread> lesseee
22:55:09 <SevenInchBread> colors are fairly relative... 
22:55:23 <SevenInchBread> what they express is generally a combination of what they're surrounded by
22:55:36 <SevenInchBread> so... you could use context-sensitive execution of colors.
22:56:01 <bsmntbombdood> ~exec self.nick_join_message("NoBeans4U", "#tapthru", ["beans", "bears"])
22:56:02 -!- bsmnt_bot has changed nick to NoBeans4U.
22:56:03 -!- NoBeans4U has changed nick to bsmnt_bot.
22:56:41 -!- sebbu has quit (Connection timed out).
22:56:41 -!- sebbu2 has changed nick to sebbu.
23:00:03 <bsmntbombdood> ~exec self.nick_join_message("NoBeans4U", "#baadf00d", ["beans", "bears"])
23:00:03 -!- bsmnt_bot has changed nick to NoBeans4U.
23:00:04 -!- NoBeans4U has changed nick to bsmnt_bot.
23:07:28 <nazgjunk> hm. In Piet, shapes control program flow, while the colours control what actually happens. Would be nice to mix that up, and do the relativity thing...
23:07:48 <nazgjunk> That would make for a pretty twisted esolang
23:09:12 <SevenInchBread> hmm... 
23:09:25 <SevenInchBread> the boundaries between colors.
23:09:43 <bsmntbombdood> /* SevenInchBread */
23:09:49 <SevenInchBread> should be the main means of instruction.
23:10:39 <bsmntbombdood> lol ihope_ 
23:10:41 <bsmntbombdood> http://mathbin.net/7414
23:11:30 <nazgjunk> well currently it's based on the difference in hue and brightness between the current and the previous colour block
23:12:26 <SevenInchBread> I'd imagine the instruction pointer thing "flowing between the lines" of shapes.
23:12:51 <SevenInchBread> with the instructions being determined by the difference in color... and the control flow flowing along the boundary.
23:13:05 <SevenInchBread> or to elsewhere... depending on the condition.
23:14:02 <SevenInchBread> a fork in the boundary is a condition basically... with the condition being on the stack.
23:14:30 <nazgjunk> sounds like coding on lsd.
23:15:31 <SevenInchBread> it would be cool if it implemented fuzy logic.
23:15:35 <SevenInchBread> like... for conditionals.
23:15:40 <nazgjunk> hmm
23:15:44 <SevenInchBread> and for the color values.
23:16:25 <SevenInchBread> I'd expect a mix of two base colors to be a mix of those two instructions... or for lighter or heavier shades to represent different modes.
23:17:25 <nazgjunk> oh crap >.< /me notices it's 0.12
23:17:37 <nazgjunk> night
23:17:58 <SevenInchBread> night
23:18:17 -!- nazgjunk has changed nick to na[zZz]gjunk.
23:23:18 -!- oklofok has quit (Read error: 110 (Connection timed out)).
23:25:57 -!- oklopol has joined.
23:30:54 <ihope_> bsmntbombdood: yes?
23:31:05 <bsmntbombdood> what?
23:31:20 <ihope_> What about it?
23:31:26 <bsmntbombdood> what about what?
23:31:37 <ihope_> http://mathbin.net/7414
23:31:46 <bsmntbombdood> what about it?
23:31:59 <ihope_> You said "lol
23:32:01 <ihope_> ".
23:32:12 <bsmntbombdood> hmm
23:40:49 -!- oerjan has joined.

2007-01-28:

00:14:06 -!- pikhq has joined.
00:20:43 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
00:20:46 -!- na[zZz]gjunk has quit (Read error: 104 (Connection reset by peer)).
00:21:23 -!- na[zZz]gjunk has joined.
00:24:24 -!- na[zZz]gjunk has quit (Read error: 54 (Connection reset by peer)).
00:24:44 -!- na[zZz]gjunk has joined.
00:29:03 <bsmntbombdood> ~exec foo
00:34:19 -!- digital_me has joined.
00:40:00 <RodgerTheGreat> c'yall
00:40:09 -!- RodgerTheGreat has quit.
00:52:53 -!- sebbu has quit ("@+").
01:33:49 -!- oerjan has quit ("Aaaaaa").
01:37:14 -!- oerjan has joined.
01:38:49 -!- na[zZz]gjunk has quit (Read error: 104 (Connection reset by peer)).
01:38:55 -!- na[zZz]gjunk has joined.
01:41:40 -!- nazgjunk has joined.
01:42:13 -!- na[zZz]gjunk has quit (Read error: 54 (Connection reset by peer)).
01:45:45 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
01:45:55 -!- nazgjunk has joined.
01:47:08 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
01:47:23 -!- digital_me_ has joined.
01:47:25 -!- nazgjunk has joined.
01:54:17 -!- digital_1e_ has joined.
01:58:39 -!- oerjan has quit ("leaving").
02:06:36 -!- digital_me has quit (Read error: 110 (Connection timed out)).
02:09:36 -!- digital_me_ has quit (Read error: 110 (Connection timed out)).
02:15:51 -!- anonfunc has quit.
02:16:40 -!- ihope_ has quit ("http://tunes.org/~nef/logs/esoteric/06.08.09").
02:31:18 -!- digital_1e_ has changed nick to digital_me.
02:31:33 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
02:31:50 -!- nazgjunk has joined.
02:35:26 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
02:35:51 -!- nazgjunk has joined.
03:04:33 -!- nazgjunk has quit (Connection reset by peer).
03:29:14 -!- nazgjunk has joined.
03:33:29 -!- nazgjunk has quit (Connection reset by peer).
03:33:54 -!- nazgjunk has joined.
03:43:18 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
03:47:03 -!- nazgjunk has joined.
03:49:57 -!- nazgjunk has quit (Connection reset by peer).
03:51:36 -!- nazgjunk has joined.
04:03:01 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
04:04:18 -!- nazgjunk has joined.
04:18:04 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
04:18:24 -!- nazgjunk has joined.
04:24:07 -!- nazgjunk has quit (Connection reset by peer).
04:25:29 -!- nazgjunk has joined.
04:27:33 -!- digital_me_ has joined.
04:28:50 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
04:30:21 -!- nazgjunk has joined.
04:35:21 -!- nazgjunk has quit (Success).
04:35:51 -!- digital_me has quit (Read error: 104 (Connection reset by peer)).
04:40:47 -!- nazgjunk has joined.
04:42:09 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
04:42:28 -!- nazgjunk has joined.
05:07:40 -!- pikhq has quit ("leaving").
05:12:00 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
05:12:09 -!- nazgjunk has joined.
05:12:38 -!- Sgeo has quit ("Leaving").
05:15:00 -!- nazgjunk has quit (Connection reset by peer).
05:15:24 -!- nazgjunk has joined.
05:18:45 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
05:19:11 -!- nazgjunk has joined.
06:01:08 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
06:01:43 -!- nazgjunk has joined.
06:09:08 -!- digital_me_ has quit (Read error: 104 (Connection reset by peer)).
06:18:00 -!- calamari has quit ("Leaving").
06:19:21 -!- nazgjunk has quit (Read error: 54 (Connection reset by peer)).
06:19:32 -!- nazgjunk has joined.
07:05:26 -!- nazgjunk has quit (Connection reset by peer).
07:05:29 -!- nazgjunk has joined.
07:44:20 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
07:44:32 -!- nazgjunk has joined.
07:50:15 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
07:50:30 -!- nazgjunk has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:06:52 -!- wooby has quit.
08:30:51 -!- nazgjunk has quit (Read error: 54 (Connection reset by peer)).
08:32:27 -!- nazgjunk has joined.
08:42:27 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
08:42:54 -!- nazgjunk has joined.
08:52:29 -!- nazgjunk has quit (Read error: 54 (Connection reset by peer)).
08:52:46 -!- nazgjunk has joined.
09:01:22 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
09:01:48 -!- nazgjunk has joined.
09:04:05 -!- nazgjunk has quit (Connection reset by peer).
09:04:32 -!- nazgjunk has joined.
09:05:02 -!- sebbu has joined.
09:16:05 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
09:16:32 -!- nazgjunk has joined.
10:22:59 -!- wooby has joined.
10:23:32 -!- safka has joined.
10:26:37 -!- safka has quit (Read error: 104 (Connection reset by peer)).
10:26:54 -!- safka has joined.
10:27:22 -!- nazgjunk has quit (Nick collision from services.).
10:27:32 -!- safka has changed nick to nazgjunk.
11:01:25 -!- wooby has quit.
11:15:18 -!- lament_ has joined.
11:15:24 -!- lament has quit (Read error: 110 (Connection timed out)).
12:23:16 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
12:23:41 -!- nazgjunk has joined.
14:34:18 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
14:34:24 -!- nazgjunk has joined.
15:30:36 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
15:30:43 -!- nazgjunk has joined.
15:34:39 -!- ihope has joined.
15:34:46 <ihope> Is Java Turing-complete?
16:18:14 -!- sebbu2 has joined.
16:19:44 -!- sp3tt_ has joined.
16:20:26 -!- sp3tt has quit (Nick collision from services.).
16:20:31 -!- sp3tt_ has changed nick to sp3tt.
16:24:55 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
16:25:23 -!- nazgjunk has joined.
16:36:58 -!- sebbu has quit (Read error: 110 (Connection timed out)).
16:42:52 <SimonRC> Ah, MS at their best:  "However, because not all applications may handle symbolic links correctly, creating a symbolic link requires the new Create Symbolic Link privilege that only administrators have by default."
16:42:56 * SimonRC bangs his head on the desk.
16:43:18 <SimonRC> nazgjunk: please fix your connection
16:43:37 <nazgjunk> i'd love to, but my dad won't let me.
16:43:51 <nazgjunk> fixing would basically mean throwing the wlan away and wiring the house.
16:53:33 <SevenInchBread> hahahaha... Vista won't let you -create symbolic links-
16:53:34 <SevenInchBread> ?
16:53:37 <SevenInchBread> by default.
16:54:22 <SevenInchBread> They could always just... make the OS redirect all openings of a symbolic link to the... target file...
17:06:33 <SimonRC> htat would produce backward-compatibilit problems
17:14:43 <SevenInchBread> backwards compatability is just a weak little contract that holds till someone gets fed up with how much old versions suck and decides to make the new one better.
17:15:58 <nazgjunk> i'm not quite sure whether that applies to vista
17:16:18 <nazgjunk> ok, the old versions did suck, but so does vista imo
17:25:29 <SevenInchBread> XP is bearable.
17:54:05 <ihope> What's a symbolic link, now?
18:24:13 -!- Sgeo has joined.
18:33:32 <bsmntbombdood> heh
18:41:26 -!- sp3tt_ has joined.
18:42:34 -!- sp3tt has quit ("Reconnecting").
19:08:28 <SimonRC> ihope: lol
19:09:07 <bsmntbombdood> I think anything from ms is sufficiently screwed up to be ignored
19:10:30 * nazgjunk quickly hides his ctcp VERSION reply
19:12:24 <SimonRC> hmm :-S
19:12:37 <SimonRC> ah, it broadcasts
19:12:46 <SimonRC> as opposed to the client-specific one
19:12:54 <bsmntbombdood> hahahaha
19:13:43 <SimonRC> nazgjunk: you can run XP on that?!
19:13:53 <nazgjunk> yup.
19:13:58 <SimonRC> Oh, wait, it's ahandheld
19:14:03 <nazgjunk> laptop, rather.
19:14:10 <SimonRC> shit, I have desktops slower than that
19:14:19 <nazgjunk> so do i ^^
19:14:47 <nazgjunk> i'm saving for a new laptop, so that i can waste this one on linux
19:15:03 <SimonRC> OTOH, elkisha is so old that it's L2 cache can't actually cache things from above 512MB, making the computer extremely slow if you have more than 512 meg in it.
19:30:41 <ihope> xchat on Windows? How--uh, I mean, sorry.
19:34:20 <nazgjunk> hehe
19:38:58 -!- lament_ has changed nick to laent.
19:39:01 -!- laent has changed nick to lament.
21:04:16 -!- sp3tt_ has quit (Read error: 54 (Connection reset by peer)).
21:04:23 -!- sp3tt has joined.
21:14:20 -!- sp3tt has quit (Remote closed the connection).
21:14:24 -!- sp3tt has joined.
21:21:00 -!- sp3tt has quit (Read error: 131 (Connection reset by peer)).
21:21:06 -!- sp3tt has joined.
21:25:04 <bsmntbombdood> ~exec self.nick_join_message("NoBeans4U", "#tapthru", ["beans", "for bears"])
21:25:05 -!- bsmnt_bot has changed nick to NoBeans4U.
21:25:05 -!- NoBeans4U has changed nick to bsmnt_bot.
21:27:30 -!- bsmnt_bot has changed nick to halp_me.
21:27:36 -!- halp_me has changed nick to bsmnt_bot.
21:29:44 -!- sp3tt_ has joined.
21:31:02 -!- sp3tt has quit (Read error: 104 (Connection reset by peer)).
21:32:42 -!- jix__ has joined.
21:39:43 -!- bsmnt_bot has changed nick to halp_me.
21:39:43 -!- halp_me has changed nick to bsmnt_bot.
21:40:30 <bsmntbombdood> wtf
21:41:52 -!- bsmnt_bot has changed nick to halp_me.
21:41:53 -!- halp_me has changed nick to bsmnt_bot.
21:41:59 -!- sp3tt_ has quit (Read error: 145 (Connection timed out)).
21:42:07 <bsmntbombdood> ~quit
21:42:08 -!- bsmnt_bot has quit.
21:42:11 -!- bsmnt_bot has joined.
21:45:00 -!- bsmnt_bot has left (?).
21:52:26 -!- bsmnt_bot has joined.
21:52:43 -!- jix__ has changed nick to jix.
22:12:56 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:32:55 -!- oerjan has joined.
22:37:38 -!- sebbu2 has quit ("@+").
23:01:25 <ihope> ~quit
23:01:32 <ihope> Wonderful!
23:01:56 <ihope> ~exec self.quit()
23:02:04 <ihope> ~exec self.do_quit()
23:02:12 <oerjan> ~exec self.raw("QUIT")
23:02:12 -!- bsmnt_bot has quit.
23:02:15 -!- bsmnt_bot has joined.
23:02:17 <nazgjunk> hehe
23:02:18 <ihope> ~exec self.do_quit("Foo","Bar")
23:02:30 <ihope> oerjan: yeah, that's the other way to do it.
23:02:48 <oerjan> ~exec sys.output(self.do_quit)
23:02:54 <nazgjunk> ~exec self.raw("QUIT :Quite the mess.")
23:02:54 -!- bsmnt_bot has quit (Client Quit).
23:02:57 -!- bsmnt_bot has joined.
23:03:06 <nazgjunk> i need to look into the rfc again :/
23:03:09 <bsmntbombdood> heh
23:03:10 <ihope> ~exec self.raw("QUIT :Quite the mess.")
23:03:10 -!- bsmnt_bot has quit (Client Quit).
23:03:13 -!- bsmnt_bot has joined.
23:03:14 <ihope> Hmm.
23:03:14 <bsmntbombdood> sys.stdout
23:03:28 <ihope> ~exec self.raw("QUIT Quite the mess.")
23:03:28 -!- bsmnt_bot has quit (Client Quit).
23:03:31 -!- bsmnt_bot has joined.
23:03:33 <ihope> Grah.
23:03:37 <oerjan> I've seen that problem before, the quit message doesn't get through
23:03:52 <bsmntbombdood> you have to be connected for a certain amount of time before your quit message shows up
23:04:00 <oerjan> Ah.
23:04:23 <oerjan> That makes sense, because the first time I tried it it worked, but not the second.
23:04:25 <ihope> Same with part messages?
23:04:33 <bsmntbombdood> not sure
23:04:46 -!- ihope has left (?).
23:04:49 -!- ihope has joined.
23:04:57 -!- ihope has left (?).
23:05:00 -!- ihope has joined.
23:05:06 <oerjan> No problem
23:05:07 <bsmntbombdood> guess not
23:05:23 <ihope> I take it the part message showed up both times.
23:05:30 <bsmntbombdood> yeah
23:05:32 <oerjan> Although it might be affected by registration...
23:06:21 <bsmntbombdood> ~raw JOIN 0
23:06:21 -!- ihope has changed nick to Aeodk.
23:06:22 -!- bsmnt_bot has left (?).
23:06:24 -!- Aeodk has changed nick to ihope.
23:06:25 <bsmntbombdood> heh
23:06:30 -!- bsmnt_bot has joined.
23:06:44 <oerjan> ~exec sys.output(self.regex_queue(-1))
23:06:51 -!- ihope has left (?).
23:06:54 -!- ihope has joined.
23:07:04 <oerjan> ~exec sys.output("Test")
23:07:12 <bsmntbombdood> sys.stdout
23:07:14 <oerjan> argh!
23:07:29 <oerjan> i remembered that a split second before you said it :)
23:07:39 <oerjan> ~exec sys.stdout(self.regex_queue(-1))
23:07:49 <bsmntbombdood> raw_regex_queue
23:08:02 <oerjan> ~exec sys.stdout(self.raw_regex_queue[-1])
23:08:02 <bsmnt_bot> (<_sre.SRE_Pattern object at 0x80af228>, <function <lambda> at 0xb7bd848c>)
23:08:25 <oerjan> not immensely helpful.
23:08:41 <bsmntbombdood> ~exec sys.stdout((lambda x:x[0].pattern, x[1].__name__)(self.raw_regex_queue[-1]))
23:08:50 <bsmntbombdood> ~exec sys.stdout((lambda x : x[0].pattern, x[1].__name__)(self.raw_regex_queue[-1]))
23:08:55 <bsmntbombdood> errr
23:09:40 <oerjan> ~exec sys.stdout(self.raw_regex_queue[-1][0])
23:09:40 <bsmnt_bot> <_sre.SRE_Pattern object at 0x80af228>
23:09:47 <oerjan> ~exec sys.stdout(self.raw_regex_queue[-1][0].__dir__)
23:09:56 <bsmntbombdood> ~exec sys.stdout( (lambda x: (x[0].pattern, x[1].__name__)(self.raw_regex_queue[-1]) )
23:10:08 <oerjan> ~exec sys.stdout(self.raw_regex_queue[-1][0].pattern)
23:10:08 <bsmnt_bot> ^ERROR :Closing Link:.*
23:10:08 <bsmntbombdood> ~exec sys.stdout( (lambda x: (x[0].pattern, x[1].__name__)(self.raw_regex_queue[-1])))
23:10:09 <bsmnt_bot> <function <lambda> at 0xb7bd85a4>
23:11:01 <oerjan> ~exec sys.stdout(self.raw_regex_queue[-1][0].pattern)
23:11:01 <bsmnt_bot> ^ERROR :Closing Link:.*
23:11:55 * oerjan is too lazy to look up the right syntax
23:12:19 <bsmntbombdood> ~exec sys.stdout( (lambda x: (x[0].pattern, x[1].__name__))(self.raw_regex_queue[-1])))
23:12:54 <bsmntbombdood> ~exec sys.stdout( (lambda x: (x[0].pattern, x[1].__name__))(self.raw_regex_queue[-1]) )
23:12:55 <bsmnt_bot> ('^ERROR :Closing Link:.*', '<lambda>')
23:12:58 <bsmntbombdood> there
23:13:05 <bsmntbombdood> ~exec sys.stdout( (lambda x: (x[0].pattern, x[1].__name__))(self.raw_regex_queue[-2]) )
23:13:05 <bsmnt_bot> ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG \\S* :~kill (.*)', 'do_kill')
23:13:41 <oerjan> Darn.  I suddenly realized that ERROR was actually a pattern and not a python error message :)
23:13:53 <bsmntbombdood> lol
23:14:40 * SimonRC goes to bed.
23:14:50 <oerjan> ~exec sys.stdout(self.raw_regex_queue[-2][0].pattern)
23:14:50 <bsmnt_bot> ^:bsmntbombdood!\S*gavin@\S* PRIVMSG \S* :~kill (.*)
23:14:57 <oerjan> ~exec sys.stdout(self.raw_regex_queue[-3][0].pattern)
23:14:57 <bsmnt_bot> \S+ PRIVMSG \S+ :~ps
23:15:07 <oerjan> ~exec sys.stdout(self.raw_regex_queue[-4][0].pattern)
23:15:08 <bsmnt_bot> \S+ PRIVMSG (#bsmnt_bot_errors) :~exec (.*)
23:15:17 <oerjan> ~exec sys.stdout(self.raw_regex_queue[-5][0].pattern)
23:15:17 <bsmnt_bot> \S+ PRIVMSG (#baadf00d) :~exec (.*)
23:15:49 <oerjan> ~exec sys.stdout(self.raw_regex_queue[-6][0].pattern)
23:15:49 <bsmnt_bot> \S+ PRIVMSG (#esoteric) :~exec (.*)
23:16:03 <bsmntbombdood> ~exec sys.stdout( [(i[0].pattern, i[1].__name__) for i in self.raw_regex_queue] )
23:16:04 <bsmnt_bot> [('^PING (.*)$', 'pong'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG \\S* :~quit ?(.*)', 'do_quit'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG \\S* :~raw (.*)', 'do_raw'), ('^\\S+ PRIVMSG \\S+ :~ctcp (\\S+) (.+)', 'do_ctcp'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG (\\S*) :~pexec (.*)', 'do_exec'), ('\\S+ PRIVMSG (#esoteric) :~exec (.*)', 'do_exec'), ('\\S+ PRIVMSG (#baadf00
23:16:04 <bsmnt_bot> d) :~exec (.*)', 'do_exec'), ('\\S+ PRIVMSG (#bsmnt_bot_errors) :~exec (.*)', 'do_exec'), ('\\S+ PRIVMSG \\S+ :~ps', 'do_ps'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG \\S* :~kill (.*)', 'do_kill'), ('^ERROR :Closing Link:.*', '<lambda>')]
23:16:42 <bsmntbombdood> ~exec sys.stdout(len(self.raw_regex_queue))
23:16:43 <bsmnt_bot> 11
23:18:28 <oerjan> Three of those might be unified with a (#\S+), I think.
23:19:06 <oerjan> unless it visits channels where you don't want people to ~exec.
23:19:14 <bsmntbombdood> well, i only want ~execs in channels that i'm in
23:20:34 <oerjan> Right.  What about (#esoteric|#bsmnt_bot_errors|#baadf00) ?
23:20:47 <oerjan> *d
23:20:52 <bsmntbombdood> yeah, that'd work
23:22:27 <oerjan> If you wanted to be clever, you could do something meta with '^:bsmntbombdood ... JOIN (#\S+)'
23:22:45 <bsmntbombdood> yeah
23:27:53 <bsmntbombdood> ~quit
23:27:53 -!- bsmnt_bot has quit.
23:27:55 -!- bsmnt_bot_chroot has joined.
23:28:01 <bsmntbombdood> oopers
23:28:16 <oerjan> What now?
23:28:19 <bsmntbombdood> hrm
23:29:35 -!- NK` has quit (Read error: 104 (Connection reset by peer)).
23:29:38 -!- NK` has joined.
23:30:08 <bsmntbombdood> uuuuh
23:31:54 <bsmntbombdood> ~quit
23:31:54 -!- bsmnt_bot_chroot has quit (Client Quit).
23:32:35 -!- bsmnt_bot has joined.
23:32:44 <bsmntbombdood> ~exec sys.stdout( [(i[0].pattern, i[1].__name__) for i in self.raw_regex_queue] )
23:32:45 <bsmnt_bot> [('^PING (.*)$', 'pong'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG \\S* :~quit ?(.*)', 'do_quit'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG \\S* :~raw (.*)', 'do_raw'), ('^\\S+ PRIVMSG \\S+ :~ctcp (\\S+) (.+)', 'do_ctcp'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG (\\S*) :~pexec (.*)', 'do_exec'), ('\\S+ PRIVMSG (#esoteric|#baadf00d|#bsmnt_bot_errors) :~exec (.*)', 'do_exec
23:32:45 <bsmnt_bot> '), ('\\S+ PRIVMSG \\S+ :~ps', 'do_ps'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG \\S* :~kill (.*)', 'do_kill'), ('^ERROR :Closing Link:.*', '<lambda>')]
23:32:52 <bsmntbombdood> better?
23:35:17 <oerjan> ~exec sys.output("Test")
23:35:25 <oerjan> ~exec sys.stdout("Test")
23:35:26 <bsmnt_bot> Test
23:35:53 <oerjan> Yep
23:38:55 <bsmntbombdood> ~quit
23:38:56 -!- bsmnt_bot has quit.
23:39:57 <bsmntbombdood> err
23:40:56 -!- bsmnt_bot has joined.
23:40:59 <bsmntbombdood> there
23:41:06 <bsmntbombdood> sys.stdout(args)
23:41:14 <bsmntbombdood> ~exec sys.stdout(args)
23:41:15 <bsmnt_bot> {'ident': 'bsmnt', 'realname': 'bsmntbombdood bot', 'chan': '#esoteric', 'nick': 'bsmnt_bot', 'host': '85.188.1.26', 'exec_chans': ['#esoteric', '#baadf00d']}
23:41:43 <bsmntbombdood> I was fixing the horrible argument passing protocol
23:42:36 -!- nazgjunk has changed nick to na[zZz]gjunk.
23:49:16 <bsmntbombdood> ~quit
23:49:17 -!- bsmnt_bot has quit.
23:49:19 -!- bsmnt_bot has joined.
23:49:22 <bsmntbombdood> ~quit
23:49:22 -!- bsmnt_bot has quit (Client Quit).
23:49:24 -!- bsmnt_bot has joined.
23:49:24 <bsmntbombdood> good
23:50:24 <bsmntbombdood> now the owner is configable
23:50:49 <bsmntbombdood> ~exec sys.stdout(self.owner)
23:50:50 <bsmnt_bot> bsmntbombdood!\S*gavin@\S*
23:52:36 <ihope> Now do a ~quit.
23:52:42 <ihope> Or something.
23:53:10 <oerjan> ~exec sys.stdout( [(i[0].pattern, i[1].__name__) for i in self.raw_regex_queue] )
23:53:10 <bsmnt_bot> [('^PING (.*)$', 'pong'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG \\S* :~quit ?(.*)', 'do_quit'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG \\S* :~raw (.*)', 'do_raw'), ('^\\S+ PRIVMSG \\S+ :~ctcp (\\S+) (.+)', 'do_ctcp'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG (\\S*) :~pexec (.*)', 'do_exec'), ('\\S+ PRIVMSG (#esoteric|#baadf00d|#bsmnt_bot_errors) :~exec (.*)', 'do_exec
23:53:10 <bsmnt_bot> '), ('\\S+ PRIVMSG \\S+ :~ps', 'do_ps'), ('^:bsmntbombdood!\\S*gavin@\\S* PRIVMSG \\S* :~kill (.*)', 'do_kill'), ('^ERROR :Closing Link:.*', '<lambda>')]
23:53:18 <ihope> Anything that requires you to be the owner.
23:53:31 <bsmntbombdood> i already did
23:53:38 <ihope> I didn't see it.
23:53:44 <bsmntbombdood> ~quit
23:53:44 -!- bsmnt_bot has quit (Client Quit).
23:53:46 -!- bsmnt_bot has joined.
23:53:54 <ihope> I see.
23:54:05 <ihope> ~quit
23:54:09 <ihope> Indeed.
23:54:17 <ihope> ~exec sys.stdout(self.owner)
23:54:18 <bsmnt_bot> bsmntbombdood!\S*gavin@\S*
23:54:29 <oerjan> The list looks the same.
23:54:33 <bsmntbombdood> it is
23:54:34 <ihope> What is \S?
23:54:41 <bsmntbombdood> non whitespace
23:54:48 <oerjan> Try joining with a different owner.
23:55:05 <bsmntbombdood> why?
23:55:07 <ihope> ~exec self.owner = r"ihope!\S*ihope@\S*"
23:55:09 <ihope> ~quit
23:55:13 <ihope> Blah.
23:55:14 <bsmntbombdood> ihope: nope
23:55:29 <bsmntbombdood> the regexes are calculated in IRCbot.__init__
23:55:48 <oerjan> How does this mix with persistence?
23:55:59 <bsmntbombdood> it doesn't
23:56:13 <bsmntbombdood> nothing is persisted automatically right now
23:58:09 <bsmntbombdood> ~exec args["owner"]="ihope\S*"
23:58:23 <bsmntbombdood> ~exec self.extra_bot=IRCbot(**args)
23:58:34 <bsmntbombdood> err
23:58:38 <ihope> ~quit
23:58:42 <ihope> Yay!
23:58:43 <bsmntbombdood> ~exec args["nick"]="new_bot"
23:58:47 <bsmntbombdood> ~exec self.extra_bot=IRCbot(**args)
23:58:54 <bsmntbombdood> ~exec self.extra_bot.listen()
23:58:56 -!- new_bot has joined.
23:59:02 <ihope> Wonderful.
23:59:07 <ihope> ~quit
23:59:08 -!- new_bot has quit (Client Quit).
23:59:13 <ihope> Fun...
23:59:25 <bsmntbombdood> ~exec sys.stdout(self.new_bot.connected)
23:59:37 <bsmntbombdood> ~exec sys.stdout(self.extra_bot.connected)
23:59:38 <bsmnt_bot> False

2007-01-29:

00:01:34 <bsmntbombdood> sigh
00:03:10 <bsmntbombdood> ~quit
00:03:11 -!- bsmnt_bot has quit.
00:03:14 -!- bsmnt_bot has joined.
00:03:14 <bsmntbombdood> ~quit
00:03:15 -!- bsmnt_bot has quit (Client Quit).
00:03:15 <bsmntbombdood> ~quit
00:03:17 -!- bsmnt_bot has joined.
00:03:46 <bsmntbombdood> k
00:04:30 <bsmntbombdood> ~exec self.raw("QUIT")
00:04:31 -!- bsmnt_bot has quit (Client Quit).
00:04:33 -!- bsmnt_bot has joined.
00:04:37 <bsmntbombdood> sweet
00:06:04 <ihope> ~exec self = 3
00:06:11 <bsmntbombdood> .
00:06:19 <bsmntbombdood> you fail
00:06:23 <bsmntbombdood> immutability
00:06:29 <ihope> Right, that.
00:06:44 <ihope> ~exec self.do_quit = 3; self.exec_execer = 3
00:06:52 <ihope> ~exec self.raw("QUIT")
00:07:06 <bsmntbombdood> heh
00:07:18 <ihope> ~exec self = 3
00:07:22 <ihope> Just for good measure, eh?
00:07:30 <bsmntbombdood> that didn't get executed
00:08:37 <bsmntbombdood> ~quit
00:08:37 -!- bsmnt_bot has quit (Client Quit).
00:08:39 -!- bsmnt_bot has joined.
00:08:50 <bsmntbombdood> haHA!
00:08:58 <ihope> Aww.
00:09:06 <bsmntbombdood> ~exec self.do_quit = 2
00:09:13 <bsmntbombdood> ~exec self.print_callbacks()
00:10:08 <bsmntbombdood> ~exec for i in self.raw_regex_queue: "~quit" not in i[0].pattern or sys.stdout(i[1])
00:10:09 <bsmnt_bot> <bound method IRCbot.do_quit of <__main__.IRCbot instance at 0xb7c0206c>>
00:10:24 <bsmntbombdood> ~exec for i in self.raw_regex_queue: "~quit" not in i[0].pattern or sys.stdout(type(i[1]))
00:10:25 <bsmnt_bot> <type 'instancemethod'>
00:10:28 <bsmntbombdood> weird
00:10:31 <bsmntbombdood> heh
00:10:58 <ihope> What's this or stuff?
00:11:06 <bsmntbombdood> ?
00:11:09 <ihope> Rather, this "or" stuff.
00:11:19 <bsmntbombdood> boolean or...
00:11:33 <ihope> Short-circuited?
00:11:37 <bsmntbombdood> yeah
00:11:41 <ihope> Fun.
00:12:27 <bsmntbombdood> ~exec ["~quit" not in i[0].pattern or sys.stdout(i[1]) for i in self.raw_regex_queue]
00:12:28 <bsmnt_bot> <bound method IRCbot.do_quit of <__main__.IRCbot instance at 0xb7c0206c>>
00:12:37 <bsmntbombdood> without the for loop
00:13:05 <bsmntbombdood> ~exec ["~quit" not in i[0].pattern or i[1]=3 for i in self.raw_regex_queue]
00:13:17 <bsmntbombdood> ohright
00:13:44 <bsmntbombdood> ~exec for i in self.raw_regex_queue: "~quit" not in i[0].pattern or i[1]=3
00:13:55 <bsmntbombdood> ~exec for i in self.raw_regex_queue: "~quit" not in i[0].pattern or sys.stdout(i[1])
00:13:57 <bsmnt_bot> <bound method IRCbot.do_quit of <__main__.IRCbot instance at 0xb7c0206c>>
00:14:00 <bsmntbombdood> hmmm
00:14:03 <bsmntbombdood> weird
00:14:34 <bsmntbombdood> ~exec self.register_raw(".*", lambda x: True)
00:14:52 <bsmntbombdood> ~exec self.register_raw(".*", lambda x: True)
00:14:53 -!- bsmnt_bot has quit ("Disconnected.").
00:14:54 <ihope> ~exec 3
00:14:55 -!- bsmnt_bot has joined.
00:15:06 <bsmntbombdood> ~exec self.register_raw(".*", lambda x: True)
00:15:07 <ihope> ~exec 3
00:15:07 -!- bsmnt_bot has quit (Client Quit).
00:15:09 -!- bsmnt_bot has joined.
00:15:13 <bsmntbombdood> heh
00:15:19 <ihope> ~exec 3
00:15:49 <ihope> That wasn't me that was doing that, then, was it?
00:15:54 <ihope> ~exec self.register_raw(".*", lambda x: True)
00:15:57 <bsmntbombdood> no it was me
00:15:58 -!- bsmnt_bot has quit (Client Quit).
00:15:59 -!- bsmnt_bot has joined.
00:16:03 <ihope> Fun.
00:16:10 <ihope> ~exec True
00:16:20 <bsmntbombdood> only works for callbacks
00:16:38 <ihope> ~exec while True: self.register_raw(".*", lambda x: print x)
00:16:47 <ihope> Aww.
00:16:53 <bsmntbombdood> print is a statement
00:16:54 * ihope does something to print
00:17:19 <bsmntbombdood> sys.stdout
00:17:23 <ihope> ~exec while True: self.register_raw(".*", lambda x: sys.stdout(x))
00:17:44 <bsmntbombdood> except no
00:17:44 <bsmnt_bot> :bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :except no
00:17:45 -!- bsmnt_bot has quit (Excess Flood).
00:17:47 -!- bsmnt_bot has joined.
00:17:53 * ihope giggles slightly and/or cackles evilly
00:17:54 <bsmntbombdood> hmm
00:18:05 <bsmntbombdood> weird
00:18:10 <ihope> ~exec self.register_raw(".*", lambda x: sys.stdout(x))
00:18:20 <ihope> Always fun, I'm sure, eh?
00:18:20 <bsmnt_bot> :ihope!n=ihope@tapthru/resident/ihope PRIVMSG #esoteric :Always fun, I'm sure, eh?
00:18:33 <ihope> Except now my client beeps every time I say something.
00:18:34 <bsmnt_bot> :ihope!n=ihope@tapthru/resident/ihope PRIVMSG #esoteric :Except now my client beeps every time I say something.
00:18:36 <bsmntbombdood> heh
00:18:37 <bsmnt_bot> :bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :heh
00:18:50 <ihope> Quick! Get another bsmnt_bot!
00:18:51 <bsmnt_bot> :ihope!n=ihope@tapthru/resident/ihope PRIVMSG #esoteric :Quick! Get another bsmnt_bot!
00:19:10 <SevenInchBread> drfg
00:19:10 <bsmnt_bot> :SevenInchBread!n=CakeProp@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :drfg
00:19:19 * SevenInchBread AAAAAAAAAAAH
00:19:19 <bsmnt_bot> :SevenInchBread!n=CakeProp@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :<CTCP>ACTION AAAAAAAAAAAH<CTCP>
00:19:26 <SevenInchBread> AHA
00:19:26 <bsmnt_bot> :SevenInchBread!n=CakeProp@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :AHA
00:19:31 <SevenInchBread> PWNT
00:19:31 <bsmnt_bot> :SevenInchBread!n=CakeProp@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :PWNT
00:19:42 <ihope> ~exec self.raw("QUIT")
00:19:42 <SevenInchBread> ah
00:19:42 <bsmnt_bot> :SevenInchBread!n=CakeProp@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :ah
00:19:43 <bsmnt_bot> :ihope!n=ihope@tapthru/resident/ihope PRIVMSG #esoteric :~exec self.raw("QUIT")
00:19:43 -!- bsmnt_bot has quit (Client Quit).
00:19:45 -!- bsmnt_bot has joined.
00:19:48 <ihope> Fun.
00:20:26 <ihope> ~exec self.grah = lambda: self.register_raw(".*", lambda x: sys.stdout(x))
00:20:44 <bsmntbombdood> ...?
00:20:46 <ihope> Now wait a minute...
00:21:01 <ihope> self.register_raw(".*", lambda x: self.grah)
00:21:08 <ihope> Whoops.
00:21:14 <bsmntbombdood> ...
00:21:17 <ihope> ~exec self.register_raw(".*", lambda x: self.grah())
00:21:20 <ihope> Better.
00:21:21 -!- bsmnt_bot has quit (Remote closed the connection).
00:21:23 -!- bsmnt_bot has joined.
00:21:26 <ihope> Or not.
00:24:01 <ihope> Hmm...
00:24:39 <ihope> ~exec sys.stdout(os.system("bash"))
00:24:40 <bsmnt_bot> 32512
00:24:44 <ihope> Hmm.
00:24:52 <ihope> That won't work, now, will it?
00:25:12 <bsmntbombdood> nope
00:25:31 <bsmntbombdood> if you write a wrapper around os.popen with sockets, then you could get a shell
00:25:50 <bsmntbombdood> ei you netcat in
00:30:51 <bsmntbombdood> ~exec self.fd = os.popen("bash")
00:30:59 <bsmntbombdood> ~exec sys.stdout(self.fd)
00:31:00 <bsmnt_bot> <open file 'bash', mode 'r' at 0xb7c2e0f8>
00:31:08 <bsmntbombdood> ~exec sys.stdout(self.fd.read())
00:31:14 <bsmntbombdood> ...
00:31:18 <bsmntbombdood> ~ps
00:31:19 <bsmnt_bot> None
00:31:33 <bsmntbombdood> ~exec self.fd.write("echo *")
00:31:36 <bsmntbombdood> ~ps
00:31:36 <bsmnt_bot> None
00:31:40 <bsmntbombdood> ~exec sys.stdout(self.fd.read())
00:31:49 <bsmntbombdood> hmmm
00:32:17 <bsmntbombdood> ~exec sys.stdout(self.fd)
00:32:17 <bsmnt_bot> <open file 'bash', mode 'r' at 0xb7c2e0f8>
00:32:21 <bsmntbombdood> oh right
00:32:27 <bsmntbombdood> ~exec sys.stdout(self.fd.close())
00:32:28 <bsmnt_bot> 32512
00:32:44 <ihope> Let's just sys.stdout everything...
00:32:54 <bsmntbombdood> ~exec self.fd = os.popen("bash", "rw")
00:33:04 <bsmntbombdood> ihope: I dunno how to get a return value from an exec
00:33:12 <bsmntbombdood> ~exec sys.stdout(self.fd)
00:33:13 <bsmnt_bot> <closed file 'bash', mode 'r' at 0xb7c2e0f8>
00:33:20 <bsmntbombdood> hrm
00:33:23 <bsmntbombdood> ~exec self.fd = os.popen("bash", "rw")
00:33:26 <bsmntbombdood> ~exec sys.stdout(self.fd)
00:33:27 <bsmnt_bot> <closed file 'bash', mode 'r' at 0xb7c2e0f8>
00:33:32 <bsmntbombdood> that ain't cool
00:33:59 <bsmntbombdood> ~exec self.fd = __import__("popen2").popen2("bash")
00:34:05 <bsmntbombdood> ~exec sys.stdout(self.fd)
00:34:06 <bsmnt_bot> (<open file '<fdopen>', mode 'r' at 0xb7c2ead0>, <open file '<fdopen>', mode 'w' at 0xb7c2e9f8>)
00:34:10 <bsmntbombdood> k
00:34:31 <bsmntbombdood> ~exec sys.stdout( self.fd[1].write("echo *") )
00:34:32 <bsmnt_bot> None
00:34:38 -!- calamari has joined.
00:34:44 <bsmntbombdood> ~exec sys.stdout( self.fd[0].read(10) )
00:34:50 <bsmntbombdood> ~ps
00:34:51 <bsmnt_bot> None
00:34:54 <bsmntbombdood> :/
00:34:57 <bsmntbombdood> ~exec sys.stdout( self.fd[0].read(10) )
00:35:03 <bsmntbombdood> ~exec sys.stdout( self.fd[0].read() )
00:35:06 <bsmntbombdood> ~ps
00:35:07 <bsmnt_bot> None
00:35:14 <bsmntbombdood> ~exec sys.stdout( self.fd )
00:35:14 <bsmnt_bot> (<open file '<fdopen>', mode 'r' at 0xb7c2ead0>, <open file '<fdopen>', mode 'w' at 0xb7c2e9f8>)
00:35:43 <bsmntbombdood> hmmm
00:35:58 <bsmntbombdood> ~exec self.fd = __import__("popen2").popen2("bash -i")
00:36:06 <bsmntbombdood> ~exec sys.stdout( self.fd )
00:36:07 <bsmnt_bot> (<open file '<fdopen>', mode 'r' at 0xb7c2eb18>, <open file '<fdopen>', mode 'w' at 0xb7c2e9b0>)
00:36:13 <bsmntbombdood> ~exec sys.stdout( self.fd[0].read(10) )
00:36:22 <bsmntbombdood> ~exec sys.stdout( self.fd[1].write("echo *") )
00:36:23 <bsmnt_bot> None
00:36:25 <bsmntbombdood> ~exec sys.stdout( self.fd[0].read(10) )
00:36:29 <bsmntbombdood> gah
00:36:35 <bsmntbombdood> ~ps
00:36:36 <bsmnt_bot> None
00:38:03 <bsmntbombdood> weird
00:44:40 <oerjan> Maybe the file descriptor is set to non-blocking or something?
00:48:51 -!- na[zZz]gjunk has quit (Read error: 54 (Connection reset by peer)).
00:49:14 -!- nazgjunk has joined.
01:02:31 <bsmntbombdood> foo
01:02:41 <bsmnt_bot> foo
01:08:17 -!- calamari has quit ("Leaving").
01:19:22 <oerjan> foo
01:19:26 <bsmntbombdood> foo
01:23:30 <bsmntbombdood>  
01:25:30 <bsmntbombdood>  foo
01:25:31 <bsmntbombdood>  foo
01:26:26 <ihope> foo
01:26:42 <ihope> Mmh?
01:42:10 <bsmntbombdood> nevar!
01:46:09 <oerjan> ein neve, neven, nevar, nevane
01:46:20 <oerjan> (nynorsk)
01:48:29 -!- nazgjunk has quit (Success).
01:48:52 -!- nazgjunk has joined.
01:54:27 <lament> i think he meant "to snow"
01:54:31 <lament> nieva
01:55:54 * oerjan likes Google maps.
01:56:20 <oerjan> I am looking at individual _cars_ on the Golden Gate bridge ...
01:56:33 <bsmntbombdood> sswweett
01:56:55 <bsmntbombdood> there's nekkid people on google earth
01:58:04 <oerjan> It's a bit less resolution outside North America or so, alas.  And some countries don't have maps at all.
01:58:11 -!- ihope has quit (Read error: 110 (Connection timed out)).
01:58:39 <oerjan> But the Eiffel tower and Taj Mahal looked good.
01:58:45 <SevenInchBread> Google sign to a partnership with some astronomy people to build a big telescope.
01:58:54 <SevenInchBread> we could be seeing Google Universe next.
02:00:42 <oerjan> Alas there is little hope of zooming to uncharted places.
02:01:24 <oerjan> Got to go with what astronomers are interested in.  Not that that would be a bad thing.
02:01:49 <bsmntbombdood> too big
02:03:41 <oerjan> But you could probably get a good view of the Andromeda galaxy.
02:49:02 -!- nazgjunk has quit (Read error: 54 (Connection reset by peer)).
02:49:10 -!- nazgjunk has joined.
03:17:04 -!- calamari has joined.
03:18:05 -!- SevenInchBread has quit ("haaaaaaaaaa").
03:18:59 * bsmntbombdood feels leet
03:20:25 <bsmntbombdood> http://paste.lisp.org/display/36038
03:30:19 -!- ihope has joined.
03:34:29 * bsmntbombdood thinks that's pretty clever
03:39:15 * bsmntbombdood calculates sqrt(2) to within 1/1000000000000000000000000000000
03:49:22 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
03:49:40 -!- nazgjunk has joined.
03:54:55 <calamari> bsmntbombdood: algorithm?
03:56:13 <bsmntbombdood> (newtons-method (lambda (x) (- (square x) 2)) 1 1/1000000000000000000000000000000)
03:57:34 <bsmntbombdood> newtons-method being defined in that paste
04:02:10 <oerjan> As long as tolerance is not so small that you get serious rounding off errors...
04:05:07 <oerjan> In which case using a larger dx than tolerance might be a good idea.
04:05:47 <bsmntbombdood> there are no rounding off errors
04:05:57 <bsmntbombdood> It stays as a rational
04:07:08 <oerjan> All right then.
04:12:04 -!- ihope has quit (Read error: 110 (Connection timed out)).
05:35:20 -!- calamari has quit ("Leaving").
05:55:02 -!- nazgjunk has quit ("rawr. And, also: Bi-la Kaifa").
06:04:08 -!- anonfunc has joined.
06:08:44 -!- oerjan has quit ("Eeek").
06:11:46 -!- Sgeo has quit (Remote closed the connection).
06:16:28 <bsmntbombdood> hooray for built in rationals
06:34:16 -!- sp3tt has joined.
07:03:47 -!- Jessie has joined.
07:22:41 -!- Jessie has quit ("Chatzilla 0.9.77 [Firefox 2.0.0.1/2006120418]").
07:24:14 -!- anonfunc has quit.
07:26:01 -!- anonfunc has joined.
07:48:05 <mtve> sorry, i don't following this chan, so perhaps a dup: http://scienceblogs.com/goodmath/2007/01/a_pathological_challenge_prime.php
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:21:02 -!- lament has changed nick to lt.
08:22:07 -!- lt has changed nick to lament.
09:29:44 -!- terjek has joined.
09:33:42 -!- terjek has left (?).
10:15:46 -!- puzzlet has quit (Read error: 110 (Connection timed out)).
10:40:38 -!- puzzlet has joined.
11:48:16 -!- anonfunc has quit.
13:24:33 -!- nazgjunk has joined.
14:15:41 -!- calamari has joined.
14:25:30 -!- nazgjunk has quit (Read error: 54 (Connection reset by peer)).
14:25:48 -!- nazgjunk has joined.
14:32:14 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
14:32:45 -!- nazgjunk has joined.
15:49:15 -!- RodgerTheGreat has joined.
15:49:33 <RodgerTheGreat> hello
15:51:07 <nazgjunk> hey
15:51:33 * RodgerTheGreat tips his hat
15:52:56 <calamari> hi RodgerTheGreat 
15:53:12 <RodgerTheGreat> what's up, calamari?
15:53:32 <calamari> hmm.. good question
15:54:58 -!- puzzlet has quit (Read error: 54 (Connection reset by peer)).
15:55:06 -!- puzzlet has joined.
15:55:12 <calamari> not exactly sure how to put it into words 
15:55:48 <RodgerTheGreat> sounds like it'll be either fascinating or pointless
15:55:52 <calamari> but, take all gravitational force vectors, find the net force on the object in question.. draw a vector opposite that, should be up
15:56:05 <RodgerTheGreat> ah, physics
15:56:23 <RodgerTheGreat> you're finding the normal force?
15:56:35 <calamari> thanks, that's probably how to say it
15:56:40 <calamari> been a while
16:29:46 -!- jix__ has joined.
16:31:31 <RodgerTheGreat> bbl
16:31:38 -!- RodgerTheGreat has quit.
16:35:52 <GregorR> *ahem*: Up is the direction indicated by the vector opposite of that vector which represents the sum of all gravitational forces at a given location.
16:35:58 <GregorR> I use that one all the time.
16:50:10 -!- FabioNET has joined.
17:06:03 -!- digital_me has joined.
17:31:59 -!- nazgjunk has quit (Read error: 54 (Connection reset by peer)).
17:32:31 -!- nazgjunk has joined.
18:18:01 -!- sebbu has joined.
18:32:21 -!- puzzlet has quit (Read error: 110 (Connection timed out)).
18:32:24 <bsmntbombdood> oooh, NULL
18:32:26 <bsmntbombdood> fun
19:02:09 <oklopol> yeah, it's my favorite too
19:08:26 -!- cmeme has quit (Connection reset by peer).
19:13:36 -!- cmeme has joined.
19:58:44 -!- digital_me_ has joined.
20:04:07 -!- sebbu2 has joined.
20:09:28 -!- digital_me has quit (Read error: 110 (Connection timed out)).
20:11:40 -!- sebbu has quit (Read error: 60 (Operation timed out)).
20:16:57 -!- sebbu2 has changed nick to sebbu.
20:38:55 -!- ihope has joined.
20:48:17 <ihope> Now, really. Everybody says "publicly" is in fact spelled "publicly", but many other words don't follow that rule. And I'm not talking about things like "musically".
20:48:57 <ihope> "Basically" is one example.
20:51:04 <SimonRC> bsmntbombdood: "NULL"?
20:51:21 <SimonRC> There was a young hacker from Hull...
20:52:14 <SimonRC> Whose brain had a temporary lull...
20:53:00 <SimonRC> His program was crashed...
20:53:07 <SimonRC> And his data was trashed...
20:53:22 <SimonRC> When malloc() returned a NULL.
20:53:35 <SimonRC> heh, spontaneous lymeric
20:53:48 <ihope> Under what conditions does malloc() return a NULL?
20:53:55 <SimonRC> actually, that should be...
20:54:06 <ihope> What if the memory allocated actually starts at address 0? :-P
20:54:11 <SimonRC> "... 'Cause he didn;t check malloc() for NULL."
20:54:26 <SimonRC> nonono, malloc returns null if it is out of space
20:54:36 <ihope> That's the only time it does that?
20:54:49 <SimonRC> Or there is some other problem
20:54:53 <ihope> And all it returns is a pointer?
20:54:57 <SimonRC> yes
20:55:28 <SimonRC> in C++, the new keyword throws an exception instead, but I'm not sure about malloc().
20:55:29 <ihope> How are you supposed to tell why it failed, then?
20:55:37 <SimonRC> you aren't
20:55:54 <ihope> Write your own function to use instead of malloc()?
20:56:59 <ihope> I mean, surely malloc() was written.
20:58:39 <SimonRC> Indeed, it is quite possible to write malloc() in C.
20:58:52 <SimonRC> I would demonstrate, but I haven't the time :-(
21:01:38 <ihope> It might need a bit of system calling, of course.
21:01:42 <ihope> I mean, wouldn't it?
21:03:36 <SimonRC> not necessarily.
21:04:13 <SimonRC> If you want a fixed amount of space available for allocation, you can just have a large static array to hold it.
21:04:40 <ihope> Yeah, you could do that.
21:04:48 <SimonRC> If you want to be able to ask the OS, use os-specific calls to extend your address space
21:04:50 <ihope> What would you do if you ran out of memory, though?
21:05:00 <SimonRC> panic?
21:05:29 <SimonRC> I recall that the Z-machine's malloc used a large fixed-size array.
21:05:46 <SimonRC> The glulx machine probably doe mamory-expansion, though
21:05:49 <SimonRC> lol!
21:05:56 <SimonRC> s/memory/memory/
21:08:00 <SimonRC> erm
21:08:04 <SimonRC> s/mamory/memory/
21:08:46 <ihope> You can achieve the same effect by first doing s/memory/memory/ then doing s/memory/mamory/. :-)
21:26:23 -!- Sgeo has joined.
21:54:02 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:28:14 -!- SevenInchBread has joined.
22:30:43 -!- FabioNET has quit ("goood night").
22:32:02 <bsmntbombdood> SimonRC: some esolang
22:32:27 <bsmntbombdood> ihope: errno
22:33:09 <bsmntbombdood> and see sbrk(2) 
22:34:32 <bsmntbombdood> C's method of reporting failures is the global errno variable
22:35:04 <bsmntbombdood> malloc sets errno to ENOMEM if it runs out of memory
22:36:15 <SevenInchBread> hmmm
22:36:17 <SevenInchBread> so...
22:36:20 <SevenInchBread> vim and emacs both suck.
22:36:27 <SevenInchBread> ...and I need to find a new text editor.
22:36:33 <GregorR> j
22:36:43 <SevenInchBread> j sucks too...
22:36:47 <SevenInchBread> :)
22:36:49 <GregorR> j is awesome.
22:36:55 <bsmntbombdood> SevenInchBread: emacs doesn't suck
22:36:56 <GregorR> It's also unfortunately in Java :(
22:36:57 <SevenInchBread> I just want like...
22:37:07 <SevenInchBread> IDLE with tabs... or a buffer list.
22:37:28 <bsmntbombdood> emacs
22:38:02 <SevenInchBread> emacs is IDLE with a buffer list, annoying key combinations, and torturous configuration.
22:38:16 <bsmntbombdood> tortuous
22:38:17 <bsmntbombdood> ?
22:38:26 <bsmntbombdood> you have a whole scripting language on your hands
22:38:52 <SevenInchBread> ...oh dear...
22:39:07 <SevenInchBread> yeah, that's too much... I want... IDLE with tabs.
22:39:16 <SevenInchBread> not a whole scripting language that I have to learn.
22:43:55 <SevenInchBread> ugh, we're worse than religious advocates, I swear.
22:44:13 <ihope> SevenInchBread: I hear /usr/bin/env python > is a good editor.
22:44:15 <ihope> :-P
22:45:06 * SevenInchBread loves programming, but hates the fanaticism it forms...
22:46:42 <ihope> Use Haskell. I don't see how you can survive with that mind-bending dynamic typing.
22:47:01 <ihope> And no currying! Sheesh!
22:48:27 <SevenInchBread> :P
22:49:08 <ihope> (Of course I'm ignoring the fact that it's perfectly possible to do currying in Python, though a little annoying.
22:49:09 <SevenInchBread> pfft, but how the hell could I possibly use monads... and static typing is like wearing a straightjacket.
22:49:13 <ihope> )
22:49:23 <SevenInchBread> I actually don't know what currying -is-...
22:49:26 * SevenInchBread reads up on it.
22:49:30 <bsmntbombdood> dynamic typing is great
22:49:34 <bsmntbombdood> i can't stand static
22:49:42 <ihope> Oh, now you *want* to add functions together to get a string?
22:49:54 <bsmntbombdood> nooo
22:50:05 <bsmntbombdood> functions don't have a __add__ method
22:50:06 <bsmntbombdood> duh
22:50:41 <ihope> Pff, I bet Python doesn't even have typeclasses.
22:51:15 * SevenInchBread is working on his own Smalltalk-like language at the moment.
22:51:39 <ihope> Smalltalk-like, eh?
22:51:40 <bsmntbombdood> What's a typeclass?
22:51:53 <SevenInchBread> Yeah ,smalltalk looks cool.
22:52:12 <ihope> bsmntbombdood: it's interfaces from object-oriented stuff, except better.
22:52:14 <SevenInchBread> I've never -used- it... but it's Lispy enough that I can get basically how it works at least in spirit.
23:14:28 -!- calamari has quit ("Leaving").
23:15:48 <SevenInchBread> so currying is just...
23:15:54 <SevenInchBread> partial functions?
23:16:09 -!- sebbu has quit ("@+").
23:17:08 <SevenInchBread> pppph
23:17:10 <SevenInchBread> ..
23:17:12 <SevenInchBread> oooh
23:17:31 <bsmntbombdood> hhho
23:17:33 <SevenInchBread> yeah okay, I see... you split the function into individual one-argument functions?
23:32:24 -!- digital_me_ has quit ("Lost terminal").
23:35:09 -!- nazgjunk has quit ("rawr. And, also: Bi-la Kaifa").
23:41:46 <ihope> SevenInchBread: pretty much.
23:46:21 -!- oerjan has joined.
23:52:14 <SevenInchBread> ihope, hmmm... it would be good for delaying a functions execution...
23:52:22 <SevenInchBread> and... optional arguments... to a certain extent.
23:53:54 <bsmntbombdood> no
23:54:05 <bsmntbombdood> optional arguments doesn't work with currying
23:55:29 <oerjan> yeah, Ocaml has both and has to disallow currying when you use optional arguments
23:56:47 <bsmntbombdood> hooray for scheme
23:57:24 <oerjan> scheme doesn't have implicit currying.
23:58:27 <bsmntbombdood> (define (curry f . x) (lambda (a . rest) (apply f (append x (cons a rest)))))

2007-01-30:

00:00:00 <oerjan> I think you can do (define (curry f . x) (lambda rest (apply f
00:00:08 <oerjan>                        (append x rest))))
00:00:48 <bsmntbombdood> looks like you can
00:03:06 <bsmntbombdood> hmm
00:03:18 <bsmntbombdood> now that i think about it, that's more usefull than I though
00:03:37 <bsmntbombdood> you can do (curry + 1) instead of (lambda (x) (+ x 1))
00:04:31 <oerjan> like Haskell sections
00:05:00 <oerjan> If you switch x and rest you get the other one
00:06:20 <bsmntbombdood> ...i don't know what those are
00:06:50 <oerjan> (+ x) 1 == 1+x and (x +) 1 == x+1
00:07:25 <bsmntbombdood> hmmm
00:08:23 <oerjan> Note: (- x) does not work because that is unary minus
00:09:29 <oerjan> All other operators can be used, as well as function names in ``
00:09:44 <bsmntbombdood> hmm, interesting
00:09:49 <bsmntbombdood> http://www.engr.uconn.edu/~jeffm/Papers/curry.html
00:09:51 <bsmntbombdood> see section 4
00:19:38 <ihope> SevenInchBread: delaying a function's execution is what "lambda:" is for.
00:19:56 <SevenInchBread> hmmm... then maybe I don't get currying.
00:20:19 <SevenInchBread> the function returns a function that expects the next argument, right?
00:20:33 <bsmntbombdood> yeah
00:23:06 <bsmntbombdood> the equivilant of that scheme in python:
00:23:12 <bsmntbombdood> def curry(fn, *args):
00:23:12 <bsmntbombdood>     return lambda *x: apply(fn, args+x)
00:24:22 <bsmntbombdood> SevenInchBread: ^
00:38:21 <SevenInchBread> apply is deprecated :D
00:38:50 <SevenInchBread> return lambda *x: fn(*args + x)
00:39:26 <SevenInchBread> oh... I do that all the time.
00:39:30 <SevenInchBread> I thought currying was some big deal.
00:44:26 <bsmntbombdood> apply is depreciated??
00:44:57 <bsmntbombdood> that's pretty stupid
00:48:19 <SevenInchBread> same thing... it's just got its own syntax.
00:48:26 <SevenInchBread> I like it better myself.
00:48:45 <ihope> So what's this talk of removing lambda?
00:48:56 <SevenInchBread> Now you just append a * to a tuple place in the function call... and it basically does that.
00:49:11 <SevenInchBread> well... in Python lambdas aren't near as useful... and some people think it's hard to read.
00:49:19 <ihope> I see.
00:49:24 <SevenInchBread> I think they have their purpose, and shouldn't simply be removed because some people never use it.
00:49:43 <ihope> Aye.
00:49:53 <ihope> bsmnt_bot makes them useful. :-P
00:49:56 <bsmntbombdood> What would be the replacement
00:49:59 <bsmntbombdood> ihope: indeed
00:50:03 <SevenInchBread> Nothing
00:50:21 <ihope> S and K combinators.
00:50:35 <ihope> And uncurryment functions.
00:50:40 <bsmntbombdood> ihope: I can understand lambda. not S and K
00:50:45 <SevenInchBread> folks are under the impression that you should use def... which I don't believe to be entirely true.
00:50:57 <bsmntbombdood> :/
00:51:01 <SevenInchBread> you don't assign every value you evaluate to a variable... why should you assign every function to one?
00:51:40 * bsmntbombdood reads the wikipedia article on monads, and fails at understanding
00:51:54 <SevenInchBread> from one I understand... it's just a list of computations.
00:52:14 <ihope> bsmntbombdood: they say Wikipedia is not a tutorial.
00:52:58 <SevenInchBread> Whats information worth if you can't understand it without having previous knowledge of it?
00:53:27 <ihope> A monad is a type constructor. return puts something into a monad, >>= lets you use something that's already in a monad.
00:53:47 <bsmntbombdood> lol @ call-with-http-connection
00:54:01 <bsmntbombdood> call-with-decode-quoted-printable-output-port
00:54:01 <ihope> call-with-previous-continuation!
00:54:12 <bsmntbombdood> that's sooooo long
00:54:16 <SevenInchBread> ....Common Lisp has huge function names.
00:54:18 <ihope> Or even better, call-with-future-continuation
00:54:22 <ihope> ...Wait, are those real names?
00:55:43 <SevenInchBread> I've got a nifty idea for a smalltalk like language.
00:55:50 <SevenInchBread> with one-argument functions.
00:57:28 <bsmntbombdood> ihope: yep
00:57:34 <ihope> Implement a programming language based on first-order logic with dependent typing.
00:57:51 <ihope> And make it a good one, too.
00:57:53 <SevenInchBread> hmm... it basically extends the message-passing idea of objects to methods...
00:57:59 <SevenInchBread> what's dependent typing.
00:58:05 <ihope> Might as well have classes, too. Typeclasses, valueclasses...
00:58:10 <SevenInchBread> nope
00:58:12 <SevenInchBread> no classes.
00:58:21 <SevenInchBread> I like the whole prototype design. :D
00:58:24 <bsmntbombdood> (apropos "call")
00:58:24 <ihope> SevenInchBread: that's when the type of value a function returns depends on the value it takes.
00:58:27 <SevenInchBread> you just copy existing objects.
00:58:37 <ihope> Requires first-class types, naturally.
00:58:43 <SevenInchBread> oh...hmmm
00:58:44 <ihope> And base it all off Damas-Milner.
00:58:57 <ihope> Or Hindley-Milner, if you like that name better.
00:59:13 <SevenInchBread> heh, dynamic typing does that... not nicely, but it does it. :D
00:59:27 <SevenInchBread> you could just put it in the definition...
00:59:32 <SevenInchBread> Integer -> Blah
00:59:41 <SevenInchBread> Spaghetii -> String
01:00:10 <SevenInchBread> return values would just be converted to the type..
01:00:21 <SevenInchBread> and... have some consistent way to do type conversions.
01:00:44 <bsmntbombdood> S and K
01:00:50 <bsmntbombdood> I do not understand
01:02:11 <SevenInchBread> hmm... I've been reading up on so-called "role-oriented programming"  sounds neat...
01:02:11 <SevenInchBread> I don't know anything specific, but I like the idea.
01:02:11 <bsmntbombdood> no makey sensy
01:02:30 <bsmntbombdood> SevenInchBread: bUZZUZZZWORD
01:02:47 <SevenInchBread> PROGRAMMING IS FILLED WITH BUZZWORDS FOOOL
01:03:12 <bsmntbombdood> "a version of the lambda calculus that omits the lambda operator."
01:03:23 <bsmntbombdood> that doesn't make any sense
01:04:24 <GregorR> The NULL language? :P
01:04:44 <bsmntbombdood> no, unlambda
01:05:03 <SevenInchBread> business-world programming makes me nauseas.
01:05:13 <bsmntbombdood> meet oo
01:05:20 <SevenInchBread> yup
01:05:28 <SevenInchBread> I like oo... in moderation.
01:06:24 <SevenInchBread> it's a good idea when you have like... actual objects.
01:07:03 * bsmntbombdood just wrote a rational class for python
01:07:32 <SevenInchBread> "pure oo" seems removed from the whole business lingo though... like Smalltal and Self.
01:07:38 <SevenInchBread> Smalltalk
01:10:07 <bsmntbombdood> ~exec self.__class__.register = lambda self, m, c: self.register_raw(r"\S+ PRIMVSG (P<chan>\S+) :~%s (P<msg>.*)" % m, c)
01:10:29 <ihope> bsmntbombdood: s = \xyz.xz(yz) and k = \xy.x
01:10:36 <ihope> All the lambda you'll ever need.
01:10:42 <bsmntbombdood> ihope: I know
01:10:58 <ihope> So what of it doesn't make sense?
01:11:09 <bsmntbombdood> how you can do stuff with that
01:11:43 <bsmntbombdood> ~exec self.register("cat", lambda x,y: bot.raw("PRIVMSG %s :%s" % (y.group("chan"), y.group("msg")))
01:11:55 <bsmntbombdood> ~exec self.register("cat", lambda x,y: bot.raw("PRIVMSG %s :%s" % (y.group("chan"), y.group("msg"))))
01:11:55 <ihope> bsmntbombdood: abstraction elimination.
01:11:59 <bsmntbombdood> ...
01:12:02 <bsmntbombdood> ~cat foo
01:12:10 <ihope> The Unlambda page says how it works.
01:12:15 <bsmntbombdood> ~exec self.print_callbacks()
01:12:31 <bsmntbombdood> hmmm
01:14:32 <bsmntbombdood> why didn't that work
01:14:38 <bsmntbombdood> ~cat
01:14:41 <bsmntbombdood> ~cat asdf
01:14:45 <bsmntbombdood> ~catasdf
01:15:10 <bsmntbombdood> ...
01:19:22 -!- ihope_ has joined.
01:19:48 -!- oerjan has quit (zelazny.freenode.net irc.freenode.net).
01:20:14 -!- oerjan has joined.
01:20:32 -!- oklofok has joined.
01:21:29 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
01:27:28 <oerjan> Basically you remove x from \xwhatever by prepending every application with S, every variable other than x by K, and replace each x by I=SKK.
01:28:40 <ihope_> Something like that, yeah.
01:28:58 <ihope_> SK = KI is surely the simplest identity in SKI calculus, besides the trivial ones, of course.
01:30:45 <oerjan> SK = KI is not quite true in Unlambda because of side effects. SK x y = K y (x y) = y except for side effects of (x y).
01:31:49 <oerjan> (and y is only evaluted once.)
01:32:28 <ihope_> Ugh, side effects.
01:32:32 <oerjan> However, K y never has a side effect, so SKK=KI works.
01:32:36 <ihope_> Give me my IO monad back.
01:32:40 <oerjan> *=I
01:32:48 <ihope_> I see.
01:33:10 <ihope_> Still, ugh, side effects.
01:34:04 <oerjan> But Unlambda's choice of side effects is so weird that it's part of its charm...
01:35:18 -!- ihope has quit (Read error: 110 (Connection timed out)).
01:36:09 <ihope_> I guess I could implement IO monads and make it a little less ugh.
01:36:16 <ihope_> Thunk monad, anyone?
01:38:21 <oerjan> My never-expanded Limonade idea was to add monads and type classes to make it _more_ ugh.
01:39:23 <oerjan> Basically so overloaded that it was hard to know what an expression meant, requiring careful consideration of what monad it was in.
01:40:18 <ihope_> Wonderful!
01:40:49 <oerjan> *Lemonade
01:43:30 -!- calamari has joined.
02:08:06 <bsmnt_bot> foo
02:08:12 <oerjan> those darn swedes
02:08:20 <oerjan> http://news.bbc.co.uk/2/hi/europe/6310915.stm
02:12:09 -!- ihope_ has quit (Read error: 60 (Operation timed out)).
02:32:47 -!- GregorR has quit (Read error: 110 (Connection timed out)).
02:35:37 -!- EgoBot has quit (Read error: 110 (Connection timed out)).
03:17:01 -!- puzzlet has joined.
03:47:28 -!- GregorR has joined.
04:50:59 -!- calamari has quit ("Leaving").
04:55:38 <bsmntbombdood> oh noes, no one is in my channel!
04:55:45 <bsmntbombdood> ##functional 
05:11:33 -!- Sgeo has quit (Remote closed the connection).
05:36:13 -!- Arrogant has joined.
05:58:07 <lament> bsmntbombdood: that's HORRIBLE!
06:44:24 -!- oerjan has quit ("leaving").
07:58:14 -!- anonfunc has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:11:12 -!- anonfunc has quit.
10:11:12 -!- Arrogant has quit ("Leaving").
10:39:57 -!- MM2 has quit (Read error: 110 (Connection timed out)).
10:44:49 -!- SevenInchBread has quit (Read error: 145 (Connection timed out)).
10:54:56 -!- MM2 has joined.
12:21:13 -!- nazgjunk has joined.
12:40:55 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
12:41:26 -!- nazgjunk has joined.
12:53:55 -!- ais523 has joined.
12:54:04 <ais523> !help
12:55:46 <SimonRC> ?
12:55:49 * ais523 checks what happened to EgoBot
12:56:21 <ais523> It seems it quit at 02:31:18 (110:Connection timed out) and didn't join again
12:56:54 <SimonRC> I have noiced that #haskell-blah have a picture of their bot:   http://trappist.elis.ugent.be/~kehoste/haskell-blah_lambdabotContest_results.html
12:57:02 <ais523> That's a shame, I was wondering about a BF problem that's been bothering me
12:57:04 <SimonRC> Just how I imagine it/her.
12:57:27 <SimonRC> Maybe we should have a picture of egobot...
12:57:51 <ais523> I'm not sure what it would look like. Maybe a Turing Machine?
12:58:32 <ais523> Anyway, the problem was to write an 8-bit BF program which outputted another BF program that was an infinite loop
12:58:50 <ais523> that's easy, but I was wondering how short you could get the first program
12:59:08 <ais523> You could write something that just output +[], but there's probably a shorter way that produces more output
13:03:24 <SimonRC> hmm
13:03:42 <SimonRC> Well the infinite-loop program must have a [ and a ] in it...
13:03:54 <SimonRC> and it must have a + or - in it
13:04:06 <SimonRC> so I don't see how you could change it much
13:04:18 <ais523> but making it longer might make it easier to generate
13:04:31 * ais523 gets out an ASCII code table
13:06:26 <ais523> -/13579;=?ACEGIKMOQSUWY[] is an infinite loop
13:06:40 <ais523> and probably easier to generate
13:10:09 <ais523> but assuming we don't want infinitely-long output, there has to be some way to stop it continuing along the same pattern
13:13:08 <SimonRC> how about: .+[+.+]?
13:13:10 <ais523> if we store 44 in a cell somehow, then the rest of the code can just be [+.+] (because -'s ASCII code is 45), and it will continue into the high reaches of ASCII before wrapping round to 0
13:13:54 <SimonRC> I don't think a load of control-codes at the beginning of a program usually hurt a bf interpreter.
13:14:18 <SimonRC> actually, make that: ++[+.+]
13:14:44 <ais523> but + has an ASCII code of 43, so if you do that you get +-[] with comments removed, which is a NOP
13:14:52 <SimonRC> feck
13:15:05 <SimonRC> what a PITA
13:15:09 * ais523 looks up 44 on the wiki's BF constant table
13:15:25 <ais523> My first attempt is ++[>+<------]>+[+.+]
13:15:30 <SimonRC> hmm
13:15:35 <ais523> 20 characters
13:16:07 <SimonRC> BTW ASCII is a 7-bit code.  there are several 8-bit codes called "extended ascii", of which ISO-8859-1 is probably most commpn online.
13:16:11 * SimonRC goes to lunch
13:26:53 <ais523> +[+.+.++++.+] works (13 characters)
13:58:16 -!- ais523 has quit.
14:51:27 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
14:51:44 -!- nazgjunk has joined.
15:04:31 <bsmntbombdood> lament: horrible indeed
15:12:59 * SimonRC tries a quiz and gets most right:   http://alvar.a-blast.org/plat_forms/
15:13:08 <SimonRC> Guess the language from the programming team!
15:15:09 <SimonRC> Gee I wonder what language team F are using?  They are all "nice young men" in shirts, with well-cut hair and HP laptops.
15:15:56 * bsmntbombdood spanks java
15:16:09 <bsmntbombdood> How can people use that crap
15:43:23 * SimonRC is suprised at the word "negligible".  Sure it should be "neglegible", from negle-ct
15:43:57 <bsmntbombdood> ...it's egnlish. what do you expect?
15:44:07 <bsmntbombdood> s/egnlish/english/
15:53:58 * SimonRC pr'p'uziz ' nyu speliq sist'm.
16:04:46 <oklofok> pröpöuziz
16:12:23 <bsmntbombdood> fo shizzle
16:18:51 * SimonRC sees a connection between China and Wales: dragons.
16:18:54 <SimonRC> hmm
17:34:06 <lament> dragons and dog-eating
17:37:54 <SimonRC> eh?
17:38:00 <SimonRC> thew Welsh eat dogs?
17:39:08 <lament> all the time
17:55:30 <SimonRC> :-S
17:55:37 <lament> they just can't stop
18:03:48 -!- sebbu has joined.
18:07:32 <SimonRC> say, guys, does this go "beep": 
18:07:38 <SimonRC> BB
18:07:40 <SimonRC> oops
18:07:42 <SimonRC> 
18:07:45 <SimonRC> well?
18:07:50 <bsmntbombdood> no
18:07:54 <SimonRC> oh
18:12:37 <lament> no, it goes boop
19:24:01 -!- wooby has joined.
20:04:47 -!- sebbu2 has joined.
20:11:51 -!- sebbu has quit (Read error: 145 (Connection timed out)).
20:16:15 -!- sebbu2 has changed nick to sebbu.
20:29:55 -!- Arrogant has joined.
21:05:21 -!- Arrogant has quit ("Leaving").
21:25:43 <GregorR> Why geology is better than chemistry: In our rock identification lab, there's a column for "taste."
21:28:56 <GregorR> Some jerk voted down my wonderful Windows 1.0 slideshow :(
21:51:28 <SimonRC> ???
22:10:20 <lament> GregorR: biology is even better
22:27:07 -!- ihope has joined.
22:33:26 -!- sebbu2 has joined.
22:52:35 -!- sebbu has quit (Connection timed out).
23:13:19 <bsmntbombdood> zomg he said side effects
23:15:15 <ihope> Lol, side effects.
23:15:17 <ihope> Wait, what?
23:34:49 -!- sebbu2 has quit ("@+").
23:45:53 -!- nazgjunk has quit ("rawr. And, also: Bi-la Kaifa").

2007-01-31:

02:14:34 -!- ihope has quit (Connection timed out).
02:38:08 -!- SevenInchBread has joined.
03:25:45 -!- SevenInchBread 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 - Pastebin: http://pastebin.ca/.
03:38:35 -!- SevenInchBread has quit (Read error: 145 (Connection timed out)).
03:38:48 <bsmnt_bot> yay, i'm identified
04:02:35 -!- Sgeo has joined.
04:25:34 -!- wooby has quit.
04:56:48 -!- Arrogant has joined.
05:30:12 -!- anonfunc has joined.
05:33:43 -!- Sgeo has quit ("Leaving").
06:31:45 -!- Arrogant has quit ("Leaving").
06:49:00 -!- oerjan has joined.
06:58:05 <oerjan> Some of the other Lambdabot logo suggestions seem like they would have been appropriate for EgoBot.  (The ones by boegel and beelsebob)
07:09:27 <oerjan> negligible but neglect follows from the rules of Latin.  In the first short e turns to i.  In the second short e turns long because it is followed by a consonant combination.
07:13:04 <oerjan> Of course there are exceptions to rules as well.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:38:30 -!- oerjan has quit ("leaving").
08:45:10 -!- anonfunc has quit.
11:02:44 <MM2> give me 5 first prime numbers, please
11:32:14 -!- anonfunc has joined.
11:57:36 -!- ihope has joined.
12:46:37 -!- ihope has quit ("http://tunes.org/~nef/logs/esoteric/06.08.09").
12:54:25 -!- ais523 has joined.
13:03:01 -!- ais523 has changed nick to ais523_.
13:10:24 -!- ais523_ has changed nick to ais523.
13:10:41 -!- ais523 has quit.
13:10:57 -!- ais523 has joined.
13:27:58 <ais523> MM2: 2, 3, 5, 8, 13. Sorry, this IRP implementation has a lag of a little over 10 hours at the moment.
13:37:44 -!- ais523 has quit (Remote closed the connection).
13:39:48 -!- ais523 has joined.
13:42:02 <ais523> Besides, this IRP implementation is wrong. I meant 2, 3, 5, 7, 11.
13:47:52 -!- calamari has joined.
13:49:33 <ais523> Hello, calamari
13:49:43 <calamari> hi ais523
13:49:54 <calamari> do I know you by a different nick? :)
13:50:12 <ais523> No, I just don't get to access IRC very often
13:50:27 <ais523> and when I do, there rarely seems to be a discussion
13:50:41 <ais523> so I just say hello to people when they join
13:50:59 <calamari> no problem hehe was just curious 
13:51:25 <ais523> !help
13:51:35 <ais523> EgoBot's still down, isn't it?
13:52:40 <ais523> I was discussing a brainfuck problem with SimonRC yesterday
13:53:08 <ais523> the problem was to write the shortest possible 8-bit wrapping BF program that would output a BF program that was an infinite loop
13:54:10 * ais523 checks the logs
13:54:18 <ais523> it seems my best attempt was +[+.+.++++.+]
14:10:21 -!- EsoBot has joined.
14:10:44 <calamari> E!bf +[+.+.++++.+]
14:10:45 <EsoBot>  
14:12:39 <ais523> there are a lot of control characters in the output
14:12:47 <ais523> but BF interpreters don't care about them
14:14:24 <calamari> hh that makes sense
14:14:28 <calamari> +a
14:14:54 <calamari> E!ps
14:14:56 <EsoBot> 1:calamari
14:15:03 <calamari> E!kill 1
14:15:04 <EsoBot> Killed 1.
14:16:10 <calamari> E!bf http://rafb.net/p/5WSwpO66.txt
14:16:12 <EsoBot> Hangman started!  Type `/msg EsoBot <pid> <word>\n' to start a game!
14:16:38 <ais523> E!ps
14:16:39 <EsoBot> 1:calamari
14:17:02 <EsoBot> ____ ___ ____ |  Type `E!<pid> <guess>\n' to guess a letter!
14:17:15 <ais523> E!1 e
14:17:26 <calamari> don't forget the \n
14:17:32 <ais523> E!1 e\n
14:17:37 <EsoBot> ___e ___ ____ |  []
14:17:46 <ais523> E!1 a\n
14:17:51 <EsoBot> ___e ___ ____ |-  [a]
14:17:58 <ais523> E!1 i
14:18:05 <ais523> E!1 i\n
14:18:10 <EsoBot> _i_e ___ ____ |-  [a]
14:18:22 <ais523> E!1 o\n
14:18:28 <EsoBot> _i_e _o_ _o__ |-  [a]
14:18:42 <ais523> E!1 f\n
14:18:48 <EsoBot> _i_e fo_ _o__ |-  [a]
14:18:56 <ais523> E!1 r\n
14:19:02 <EsoBot> _i_e for _or_ |-  [a]
14:19:20 <ais523> E!1 t\n
14:19:26 <EsoBot> ti_e for _or_ |-  [a]
14:19:34 <ais523> E!1 m\n
14:19:41 <EsoBot> time for _or_ |-  [a]
14:19:49 <ais523> E!1 k\n
14:19:56 <EsoBot> time for _ork |-  [a]
14:20:01 <ais523> E!1 w\n
14:20:07 <EsoBot> time for work | :)|-<  YOU WIN!
14:20:15 <calamari> bbl <=K
14:20:29 <calamari> cya later
14:20:36 -!- calamari has quit ("Leaving").
14:20:49 <ais523> E!help
14:20:50 <EsoBot> Commands: bf, cat, help, kill, ls, ps, quit, unnecessary.
14:21:00 <ais523> E!ls
14:21:01 <EsoBot> Bad or inaccessible URL `http://localhost/ls/dirs'.
14:21:14 <ais523> E!ps
14:21:15 <EsoBot> 1:calamari
14:21:24 <ais523> E!kill 1
14:21:25 <EsoBot> Killed 1.
14:23:23 <ais523> E!bf >,----------[>,----------]<[<]>[++++++++++.>]<[<]>[.>]
14:23:27 <ais523> E!ps
14:23:28 <EsoBot> 1:ais523
14:23:43 <ais523> E!1 Hello, world!
14:23:48 <ais523> E!1 \n
14:23:49 <EsoBot> Hello, world!Hello, world!
14:24:01 <ais523> E!ps
14:24:02 <EsoBot> No processes.
14:24:56 <ais523> E!bf +[>>,----------[>,----------]<[<]>[++++++++++.>]<[<]>[.>]<[[-]<]<]
14:25:14 <ais523> E!1 Hello, world!\n
14:25:15 <EsoBot> Hello, world!Hello, world!
14:25:21 <ais523> E!1 and again!\n
14:25:22 <EsoBot> and again!and again!
14:25:42 <ais523> ~help
14:26:04 <ais523> E!ps
14:26:05 <EsoBot> 1:ais523
14:26:31 <ais523> E!1 E!1\n \n
14:26:32 <EsoBot> E!1E!1
14:26:33 <EsoBot>   
14:26:54 <ais523> E!1 E!1 \\n \n
14:26:55 <EsoBot> E!1 \E!1 \
14:26:56 <EsoBot>   
14:27:24 <ais523> E!1 \n
14:27:30 <ais523> e!ps
14:27:31 <ais523> E!ps
14:27:33 <EsoBot> 1:ais523
14:37:49 <ais523> E!unnecessary
14:37:50 <EsoBot> Program executed perfectly right!
14:38:01 <ais523> e!unnecessary Hello, world!
14:38:06 <ais523> E!unnecessary Hello, world!
14:38:07 <EsoBot> CRITICAL ERROR: The file exists!
14:39:31 <ais523> E!unnecessary CRITICAL ERROR: The file exists!
14:39:33 <EsoBot> CRITICAL ERROR: The file exists!
14:40:05 <ais523> E!1 E!1 \\
14:40:15 <ais523> E!1 n \n
14:40:16 <EsoBot> E!1 \n E!1 \n 
14:40:39 <ais523> E!1 E!1 E!1 \\
14:40:43 <ais523> E!1 n \n
14:40:44 <EsoBot> E!1 E!1 \n E!1 E!1 \n 
14:42:47 <ais523> ~exec sys.stdout("testing");
14:42:47 <bsmnt_bot> testing
14:43:26 <ais523> E!1 ~sys.stdout("E!1 testing\\n"); \n
14:43:27 <EsoBot> ~sys.stdout("E!1 testing\~sys.stdout("E!1 testing\
14:43:29 <EsoBot> "); "); 
14:43:53 <ais523> E!1 ~sys.stdout("E!1 testing\\
14:43:59 <ais523> E!1 n"); \n
14:44:00 <EsoBot> ~sys.stdout("E!1 testing\n"); ~sys.stdout("E!1 testing\n"); 
14:44:31 <ais523> E!1 ~exec sys.stdout("testing\\
14:44:37 <ais523> E!1 n"); \n
14:44:38 <EsoBot> ~exec sys.stdout("testing\n"); ~exec sys.stdout("testing\n"); 
14:45:35 <ais523> E!1 ~exec sys.stdout(";\n
14:45:36 <EsoBot> ~exec sys.stdout(";~exec sys.stdout(";
14:45:45 <ais523> E!1 ~exec sys.stdout(";)\n
14:45:46 <EsoBot> ~exec sys.stdout(";)~exec sys.stdout(";)
14:45:54 <ais523> E!1 ~exec sys.stdout(");\n
14:46:11 <ais523> E!1 ~exec sys.stdout(");\n
14:46:21 <ais523> E!ps
14:47:16 <ais523> ~exec sys.stdout("E!ps");
14:47:17 <bsmnt_bot> E!ps
14:47:32 <ais523> E!quit
14:49:49 <EsoBot> ~exec sys.stdout(");~exec sys.stdout(");
14:49:49 <EsoBot> ~exec sys.stdout(");~exec sys.stdout(");
14:49:49 <EsoBot> 1:ais523
14:49:49 <EsoBot> 1:ais523
14:49:49 -!- EsoBot has quit ("requested by ais523").
14:49:50 <bsmnt_bot> );~exec sys.stdout(
14:49:50 <bsmnt_bot> );~exec sys.stdout(
15:37:39 <ais523> ~exec sys.stdout("test" * 2);
15:37:39 <bsmnt_bot> testtest
16:51:27 <SimonRC> You know you've been using phpBB too much when... you type phpBB markup in Word without thinking about it.
16:52:33 <ais523> ...and you know you're too addicted to phpBB when you actually learn Visual Basic so that you can program Word to interpret it correctly
16:54:36 <SimonRC> It sucks trying to write 2000-word posts in those titchy editing boxes though.
17:00:55 <ais523> Can't you edit it in an external editor and then copy-and-paste it in?
17:08:22 <SimonRC> Maybe, but it makes previewing a PITA.
17:33:47 -!- sebbu has joined.
17:47:10 <SimonRC> hi
17:58:08 -!- jix__ has joined.
17:58:54 -!- jix__ has changed nick to jix.
18:20:34 -!- ais523 has quit.
18:23:06 -!- Rugxulo has joined.
18:24:03 <SimonRC> h
18:24:04 <SimonRC> i
18:24:33 <Rugxulo> yo
18:33:50 * SimonRC goes
18:41:21 -!- Rugxulo has quit ("Say What?").
18:51:39 -!- digital_me has joined.
20:03:48 -!- calamari has joined.
20:21:32 -!- nazgjunk has joined.
21:12:32 -!- Sgeo has joined.
21:31:36 -!- jix has quit (Read error: 104 (Connection reset by peer)).
21:33:51 -!- jix__ has joined.
21:34:15 -!- jix__ has changed nick to jix.
22:14:23 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:15:51 -!- anonfunc has quit.
22:48:06 -!- calamari has quit ("Leaving").
22:55:45 <bsmntbombdood> SimonRC: lol word
23:07:06 <bsmnt_bot> foo
23:07:17 <SimonRC> bsmntbombdood: eh?
23:07:31 <SimonRC> ITYM "werd"
23:07:43 <bsmntbombdood> <SimonRC> You know you've been using phpBB too much when... you type phpBB markup in Word without thinking about it.
23:10:46 -!- sebbu has quit ("@+").
23:20:17 <SimonRC> ah, ok
23:21:47 * SimonRC wonders about the physiological effects that a certain newsgroup is having on him.
23:25:27 <SimonRC> It's the stomach-churning, heart-thumping feeling that is caused by either being afraid or having a crush.
23:25:43 <SimonRC> And I don't think I'm afraid.
23:26:22 <SimonRC> OTOH, it's not a sexual fetish of mine AFAICT.
23:28:19 <bsmntbombdood> AFOOD OTOW IANAL TOM WH
23:28:41 <SimonRC> d00dWTF?!!"!!#!?????!!
23:29:15 <bsmntbombdood> omgwtfbbq
23:29:59 <SimonRC> I wouldn;t be saying this stuff if I thought I would ever meet any of you guys.
23:30:09 <SimonRC> Or gals, as the case may be.
23:30:50 * bsmntbombdood pulls out the location-over-ip spec