2007-01-05 - freenode:#esoteric

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-04 2007-01-05 2007-01-06→ ↑2007 ↑all