←2007-01-06 2007-01-07 2007-01-08→ ↑2007 ↑all
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-06 2007-01-07 2007-01-08→ ↑2007 ↑all