00:14:33 -!- bsmnt_bot_chroot has joined.
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:44 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:16:47 -!- bsmnt_bot_chroot has joined.
00:17:03 <ihope> ~exec self.raw("PRIVMSG #esoteric :Foobar")
00:17:35 -!- bsmnt_bot has quit (Remote closed the connection).
00:17:43 <ihope> ~exec while 1: __import__("os").fork()
00:18:02 <ihope> I take it that didn't work.
00:18:14 <bsmntbombdood> OSError: [Errno 11] Resource temporarily unavailable
00:18:28 <ihope> ~exec (lambda x: x(x))(lambda x: x(x))
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:31 -!- bsmnt_bot_chroot has joined.
00:20:09 <ihope> ~exec while 1: (lambda x: x(x))(lambda x: x(x))
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: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: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:46 <bsmntbombdood> TypeError: cannot concatenate 'str' and 'NoneType' objects
00:24:27 <oklopol> ~exec self.raw((lambda x:x%x)("~exec self.raw(((lambda x:x%%x)(%r)))"))
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: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: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 <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:27:25 <ihope> YOU KILLED IT, GregorR
00:27:26 -!- bsmnt_bot_chroot has joined.
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: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:29:01 <ihope> GregorR: I take it that's the probability of a randomly chosen bot interpreting its own output.
00:29:09 <ihope> The actual number of bots is likely to be bigger.
00:29:30 <GregorR> Really, it's (1/A_LOT)*NUMBER_OF_BOTS
00:29:43 <ihope> So NUMBER_OF_BOTS/A_LOT?
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: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: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: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 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:33:44 -!- bsmnt_bot_chroot has joined.
00:33:52 <ihope> I take it that doesn't mean anything.
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:26 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s"% os.getgid())
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:34 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:34:55 -!- bsmnt_bot_chroot has joined.
00:35:26 <oklopol> isn't the python part separate from the bit?
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:39 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:35:53 -!- bsmnt_bot_chroot has joined.
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:42 <ihope> ~exec x = 3; self.raw("PRIVMSG #esoteric :%d" % x")
00:38:46 <GregorR> bsmntbombdood: /dev still exists in a chroot.
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:40:03 <ihope> Well, it setuid'd.
00:40:07 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % os.listdir("/dev/"))
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:51 <ihope> ~exec x = 3; self.raw("PRIVMSG #esoteric :ANYTHING")
00:40:59 <fizzie> ~exec self.raw("PRIVMSG #esoteric :%s" % os.listdir("/"))
00:41:06 <fizzie> "No such file or directory: '/'"? :p
00:41:21 <ihope> ~exec self.raw("PRIVMSG #esoteric :%s" % os.listdir("/"))
00:41:44 <ihope> ~exec x := 3; self.raw("PRIVMSG #esoteric :%d" % x")
00:42:06 <ihope> ~exec x = 3; self.raw("PRIVMSG #esoteric :%d" % x)
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:44:13 <ihope> Is . pretty much an operator in Python?
00:44:24 <ihope> That is, could I do something like foo.(bar.baz)?
00:44:37 <GregorR> That makes my head swim :P
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: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:47:13 <ihope> How would I import bar from a different module using __import__ in that case?
00:47:26 <ihope> ~exec self.raw("")
00:47:40 <GregorR> ~exec self.raw("PRIVMSG #esoteric :FOOBARF")
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: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: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: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: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:58 <GregorR> ~exec self.raw("PRIVMSG NickServ :REGISTER foobork")
00:51:02 -!- bsmnt_bot_chroot has quit (Nick collision from services.).
00:51:12 -!- bsmnt_bot_chroot has joined.
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:47 -!- bsmnt_bot_chroot has quit (Nick collision from services.).
00:51:57 -!- GregorR has joined.
00:52:26 -!- bsmnt_bot_chroot has joined.
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:58:35 <ihope> ~exec self.raw("PRIVMSG #esoteric :foo")
00:58:36 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:58:38 -!- bsmnt_bot_chroot has joined.
00:59:03 <ihope> ~exec self.raw("PRIVMSG #esoteric :foo")
00:59:13 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
00:59:15 -!- bsmnt_bot_chroot has joined.
01:00:18 <ihope> ~exec self.raw("PRIVMSG #esoteric :%f" % random())
01:00:47 <ihope> ~exec self.raw("PRIVMSG #esoteric :%f" % __import__("random").random())
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: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:34 <ihope> Comment out the first line?
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:21 <ihope> Well, no, that wouldn't work.
01:05:31 <ihope> What about changing the first one to ignore #esoteric?
01:07:08 <ihope> ([^#]\S*|#[^e]\S*)
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: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: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: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:21:48 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
01:21:50 -!- bsmnt_bot_chroot has joined.
01:22:09 <ihope> ~pexec self.raw("PRIVMSG #esoteric :%f" % __import__("random").random())
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 <ihope> Yep, sounds a good way to do it.
01:22:31 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%f" % __import__("random").random())
01:26:25 <oklopol> there was a nice and easy way to make a string into an array in python, right?
01:27:15 <oklopol> you told me that before i think
01:29:49 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % os.listdir("."))
01:29:59 <bsmntbombdood> ~exec self.raw("PRIVMSG #esoteric :%s" % os.listdir("/bot"))
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:31:13 -!- Rugxulo has joined.
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: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:41 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
01:31:43 -!- bsmnt_bot_chroot has joined.
01:35:17 <oklopol> stupid non-turing complete regexps
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:37:14 <oklopol> are '{' and '}' used in regexps?
01:37:23 <oklopol> i mean, i used them for the calcs if not
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: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: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:47:05 <oklopol> "(.*){if !(collect(_==0,(_%__)(([2...int(asabs(\1))-1],[2...int(asabs(\1))-1])))}"
01:47:37 <oklopol> sorry, "([0-9]*){if !(collect(_==0,(_%__)(([2...int(asabs(\1))-1],[2...int(asabs(\1))-1])))}"
01:48:05 <oklopol> but the syntax can be used better, i'm just too tiredz
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:38 <oklopol> "([0-9]*){if !(collect(_==0,(_%__)((int(asabs(\1)),[2...int(asabs(\1))-1])))}" i think would work
01:55:59 -!- Rugxulo has left (?).
01:56:07 <oklopol> lulz was just testing primes for fun :)
01:57:06 <oklopol> pasted by accident, me so good
01:58:42 <oklopol> tabs come out real nice :)
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:47 <fizzie> Conditional jumps, labels, the works.
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:03:43 <fizzie> http://zem.fi/~fis/fib.sed.txt computes Fibonacci numbers recursively, using decimal addition.
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: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: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 very much longer line.
02:07:42 <fizzie> A line so long it no longer makes sense! Exaggerating? Who, me?
02:07:50 <oklopol> in mine fibonacci numbers would take a line
02:07:50 <fizzie> Last two lines are the output.
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:11:05 <ihope> I'm guessing that's 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:31 <oklopol> ihope, did you see my primes? :D
02:11:45 <ihope> oklopol: no, not really.
02:12:16 <ihope> ~pexec self.raw_regex_queue.pop()
02:12:22 <oklopol> "([0-9]*){if !(collect(_==0,(_%__)((int(asabs(\1)),[2...int(asabs(\1))-1])))}"
02:12:23 <ihope> ~pexec self.raw_regex_queue.pop()
02:13:24 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
02:13:27 -!- bsmnt_bot_chroot has joined.
02:20:20 <ihope> There was a ~pexec in there.
02:20:45 <ihope> ~pexec while 1: self.raw("PRIVMSG #esoteric :Tick!"); __import__("time").sleep(10)
02:21:01 <bsmnt_bot_chroot> 1: 'while 1: self.raw("PRIVMSG #esoteric :Tick!"); __import__("time").sleep(10)', 15.42 seconds
02:21:55 <ihope> Just a second, lemme do another GregorR...
02:22:18 <ihope> ~pexec self.raw("PRIVMSG NickServ :REGISTER foobork")
02:22:48 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
02:22:50 -!- bsmnt_bot_chroot has joined.
02:25:04 <ihope> Is it not available with a chroot jail?
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: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: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: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: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:20:59 <bsmntbombdood> pthread_kill would work too, but python doesn't expose that either
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:55 <fizzie> Uh, sys.settrace, I mean.
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:45:35 <bsmntbombdood> The bot can function regularly while an ~exec is running
04:08:56 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:08:59 -!- bsmnt_bot_chroot has joined.
04:09:47 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:10:11 -!- bsmnt_bot_chroot has joined.
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:12:04 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:12:28 -!- bsmnt_bot_chroot has joined.
04:13:03 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:13:58 -!- bsmnt_bot_chroot has joined.
04:15:24 <CakeProphet> Did you rig it up so that stdout is the "current" channel?
04:16:03 <bsmntbombdood> It is suppose to give me a message that it knows the we are ~exec in somethine
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: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:43 <bsmntbombdood> Then I wouldn't be able to do all the cool stuff I do with ~exec now
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: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:36 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:25:42 -!- bsmnt_bot_chroot has joined.
04:26:04 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:27:48 -!- bsmnt_bot_chroot has joined.
04:28:07 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:28:12 -!- bsmnt_bot_chroot has joined.
04:28:40 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:31:04 -!- bsmnt_bot_chroot has joined.
04:31:20 <oklopol> will you make the stdout thingie?
04:32:04 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:32:09 -!- bsmnt_bot_chroot has joined.
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: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:36:22 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:36:27 -!- bsmnt_bot_chroot has joined.
04:36:41 <CakeProphet> socket.write = lambda self, x: self.send("PRIVMSG #esoteric :%s" % x
04:37:25 <oklopol> socket.write = lambda self, x: self.raw("PRIVMSG #esoteric :%s" % x)
04:37:57 <CakeProphet> Anything you give to stdout that has a write method counts as a
04:38:47 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:38:50 -!- bsmnt_bot_chroot has joined.
04:39:42 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:39:44 -!- bsmnt_bot_chroot has joined.
04:40:31 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:40:36 -!- bsmnt_bot_chroot has joined.
04:44:29 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:44:34 -!- bsmnt_bot_chroot has joined.
04:46:52 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:46:59 -!- bsmnt_bot_chroot has joined.
04:50:29 <CakeProphet> the traceback? or is "trace function" some terminology I've never heard of?
04:51:25 <bsmntbombdood> http://www.python.org/doc/current/lib/debugger-hooks.html#debugger-hooks
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:57:49 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
04:57:52 -!- bsmnt_bot_chroot has joined.
04:59:59 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
05:00:01 -!- bsmnt_bot_chroot has joined.
05:00:21 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
05:00:24 -!- bsmnt_bot_chroot has joined.
05:02:10 <bsmntbombdood> ~exec __import__("time").sleep(10); self.raw("PRIVMSG #esoteric :no")
05:02:16 <bsmnt_bot_chroot> 1: '__import__("time").sleep(10); self.raw("PRIVMSG #esoteric :no")', 5.25 seconds
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: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: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 <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: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: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: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: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: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 <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: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: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:27 <bsmnt_bot_chroot> 0: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number zero")', 1.40 seconds
05:13:37 <bsmnt_bot_chroot> 0: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number zero")', 12.04 seconds, killed
05:14:06 <bsmnt_bot_chroot> 0: '__import__("time").sleep(50); self.raw("PRIVMSG #esoteric :number zero")', 41.06 seconds, killed
05:22:20 <CakeProphet> ~exec import time self.raw("PRIVMSG #esoteric: " + time.asctime())
05:22:34 <CakeProphet> ~pexec import time; self.raw("PRIVMSG #esoteric: " + time.asctime())
05:23:26 <CakeProphet> ~pexec import time; self.raw("PRIVMSG #esoteric : " + time.asctime())
05:25:14 <CakeProphet> forking a process with a global dictionary would be so much easier :P
05:25:54 <CakeProphet> I can't even comprehend how thread management could be considered simply than using subprocesses.
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 <bsmnt_bot_chroot> 0: '__import__("time").sleep(25); self.raw("PRIVMSG #esoteric :oops")', 0.99 seconds
05:28:09 <bsmnt_bot_chroot> 0: '__import__("time").sleep(25); self.raw("PRIVMSG #esoteric :oops")', 6.84 seconds, killed
05:29:03 <bsmntbombdood> It can't be killed until the current statement finishes executing
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: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: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:34:18 <CakeProphet> threading isn't fun programming... it's painful
05:34:42 <CakeProphet> I just think... most of the time there's an easier solution.
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:38:39 <bsmntbombdood> or even use pthread_kill(threads[pid], SIGTERM); and let the thread use its own signal handler
05:39:38 <CakeProphet> All of Python's threading stuff usually has a "thread object" of some sort.
05:42:57 <CakeProphet> If you can only kill a thread between statements... that sorta defeats the purpose of threading really...
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: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:59 <CakeProphet> I find the benefits outweigh the drawbacks usually.
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:53:08 -!- Sgeo has quit (Remote closed the connection).
06:05:42 -!- RodgerTheGreat has quit.
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: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: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: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:18 <bsmnt_bot_chroot> 0: '__import__("time").sleep(100);self.raw("PRIVMSG #esoteric :100")', 67.62 seconds
06:40:50 -!- violot has left (?).
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:34 <bsmnt_bot_chroot> 0: '__import__("time").sleep(10);self.raw("PRIVMSG #esoteric :10")', 4.14 seconds, killed
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.
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: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:52:25 <oklopol> i always insert comments afterwards
14:59:34 -!- tgwizard has quit (Read error: 110 (Connection timed out)).
15:19:00 <ihope> Come back, bsmnt_bot!
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: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:27:08 <ihope> Let's try Xanth magic.
15:27:11 <ihope> What's your talent?
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:37:11 -!- ihope_ has joined.
15:39:53 <ihope_> Okay. Do you know the "turn undead" spell?
15:42:59 <ihope_> And I don't have any spellbooks. Do you?
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:49:42 <ihope_> Does a quit message count as a corpse?
15:54:05 -!- ihope has quit (Connection timed out).
15:56:34 -!- RodgerTheGreat has joined.
16:02:12 <ihope_> Wake up, bsmntbombdood! It's 10 AM!
16:44:19 <fizzie> 6 PM here. (Half-past, now.)
17:05:34 -!- oerjan has joined.
17:38:18 -!- Sgeo has joined.
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: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:48:02 <oerjan> Everybody wants their own bot nowadays :)
17:49:28 <oerjan> At this rate, it would probably be easier using sockets.
17:50:23 <ihope_> Maybe my operating system will have an IRC bot built in.
17:50:56 <ihope_> I downloaded a bot, and I'm trying to get it working.
17:51:33 <ihope_> C or C++ or something.\
17:51:42 <ihope_> I'll compromise and say it's written in C+.
17:52:44 -!- oklobot2 has joined.
17:52:45 <ihope_> I'm trying to get it going under Linux.
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:49 <oerjan> just sits and meditates.
17:55:50 <kotrin> ihope_ do you not know any scripting language or programming language?
17:56:06 <oklopol> !exec "I"" do " " a few things."AddAddPrntNl
17:56:44 -!- ihope_bot has quit (Remote closed the connection).
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: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:49 <kotrin> then have another bot in here the interprets it
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:53 -!- oklobot2 has joined.
18:06:05 <oklopol> a bf bot could auto-interpret all data it gets :)
18:06:52 <SimonRC> bsmntbombdood: Maybe you kill python threads by forcing them to throw an uncatchable exception?
18:07:03 <oklopol> don't break it, please :) it's very fragile
18:07:44 <ihope_> !daemon exec bf +[,[-]+]
18:08:47 <oklopol> 65[DblChrPrntNlDrp1AddDbl80Les]
18:09:06 <oklopol> !exec 65[DblChrPrntNlDrp1AddDbl80Les]
18:10:00 <ihope_> Can arbitrary strings be printed?
18:10:04 <SimonRC> oklopol: what lang is that?
18:10:13 <oklopol> i don't have a name for it
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:45 <oklopol> i should make one... maybe now
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:13:01 <SimonRC> see The Repositor Of All Huma Knowlage for more details
18:16:35 <ihope_> Can you print newlines and carriage returns that way?
18:18:08 <oklobot2> 3PRIVMSG #esoteric :3PRIVMSG #esoteric :3PRIVMSG #esoteric :3
18:19:04 <kotrin> !exec "$_"65ChrAddPrintNl
18:20:56 <CakeProphet> !exec 343534534545345PrintPrintPrintPrintPrintPrintPrintPrintPrintNl
18:22:08 <CakeProphet> !exec 343534534545345PrntPrntPrntPrntPrntPrntPrntPrntPrntPrntPrntNl
18:22:08 -!- oklobot2 has quit (Read error: 104 (Connection reset by peer)).
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: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:24:15 <oklopol> just eval, which i did in the summer in 2 hours
18:24:34 -!- oklobot2 has joined.
18:24:35 <ihope_> Guys, it won't work without the bot.
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:54 <CakeProphet> !daemon glassf glass {M[m(_o)O!(_i)I!(_e)(BF)!/<1>(_i)i.?(_e)(BF).?\]}
18:26:55 <CakeProphet> !daemon glassf glass {M[m(_o)O!(_i)I!(_e)(BF)!/<1>(_i)i.?(_e)(BF).?(_o)o.?\]}
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:28:02 <kotrin> !eval *2148 13985632964986718967296872098672069872506987256098247690824673459086376392045873490847649580674
18:28:05 <oklobot2> *2148 13985632964986718967296872098672069872506987256098247690824673459086376392045873490847649580674=785619656
18:28:39 <CakeProphet> !daemon glassf glass {M[m(_o)O!(_i)I!(_e)(BF)!/<1>(_i)i.?(_e)(bf).?\]}
18:28:43 <kotrin> !eval *********************************************************************
18:28:46 <oklobot2> *********************************************************************=
18:29:23 <CakeProphet> !daemon glassf glass {M[m(_o)O!(_i)I!(_e)(BF)!\<1>(_i)i.?(_e)(bf).?/]}
18:29:31 <oklopol> okay, i'm not complaining if i've done that without realizing it
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:27 <oklopol> kotrin, i wasn't referring to a lang called whitespace
18:32:47 <oklopol> if that's what confused you
18:33:01 <kotrin> oklopol>well, yeah, i always use python for converting words to hex or smth
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: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: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: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:44 <oklopol> K has the smallest sudoku solver by far
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: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:34 <Sgeo> http://esoteric.voxelperfect.net/wiki/BF-RLE
18:37:57 * Sgeo came up with it
18:40:23 -!- sp3tt has quit ("leaving").
18:40:39 <kotrin> so just replace any occurs < 3 to [operator][occurence-3] ?
18:41:05 <kotrin> what's the point of that?
18:41:12 -!- sp3tt has joined.
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: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:56 <oklopol> well, +03 is better that >++++++++[<++++++++>-]<+.
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:46 <oerjan> !exec "!exec ""34ChrDupRotAddDupAddRotRotAddDupAddSwapAddPrntLn"34ChrDupRotAddDupAddRotRotAddDupAddSwapAddPrntLn
18:43:47 <kotrin> how is +13 == >++++++++[<++++++++>-]<+.
18:45:03 <Sgeo> !bf >++++++++[<++++++++>-]<+.
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:46:06 <oklobot2> "PRIVMSG #esoteric :"PRIVMSG #esoteric :"
18:46:11 <kotrin> !bf >++++++++[<++++++++>-]<+.
18:46:28 <oerjan> !exec "!exec ""34ChrDupRotAddDupAddRotRotAddDupAddSwapAddPrntNl"34ChrDupRotAddDupAddRotRotAddDupAddSwapAddPrntNl
18:47:08 <Sgeo> I guess IRP#esoteric is an illegal language now?
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: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:49:45 <kotrin> are loops/output/input the same as bf?
18:50:30 <Sgeo> It's just done textually actually
18:50:46 <Sgeo> Although an interpreter could optomize for it probably
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: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:35 <kotrin> i might make a bf -> bf-rle
19:05:26 -!- sp3tt has joined.
19:09:59 <oklopol> can i do "0"<"5" in python?=
19:19:43 <ihope_> bsmntbombdood's away message is still "sleep", and it's past 1 PM/
19:20:14 <ihope_> oklopol: how do you manage to do that?
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: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: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:16 <ihope_> === CTCP time reply ``Sun Jan 7 13:13:29 2007'' from bsmntbombdood
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:25:58 <oklopol> can't i use a var of the parent function in a subfunction?
19:27:35 <bsmntbombdood> SimonRC: You kill a python thread by raising SystemExit exception
19:28:47 <bsmntbombdood> <ihope>~pexec self.register_raw('(.*)', lambda x: self.raw("PRIVMSG #esoteric %s" % x))
19:29:21 <oklopol> i def new functions in functions
19:29:29 <ihope_> ~pexec self.register_raw('(.*)', lambda x: (self.raw("PRIVMSG #esoteric %s" % x)))
19:29:38 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
19:29:47 -!- bsmnt_bot_chroot has joined.
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:30:00 <bsmnt_bot_chroot> oklopol!i=okokokok@194.251.102.88 PRIVMSG #esoteric :generally
19:30:04 <bsmnt_bot_chroot> ihope_!n=foo@c-71-205-100-59.hsd1.mi.comcast.net PRIVMSG #esoteric :Yay!
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 <bsmnt_bot_chroot> bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :~exec self.raw_regex_queue.pop()
19:31:17 <kotrin> Sgeo: http://pastie.caboo.se/31705
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:39 <Sgeo> Does it handle [[[[]]]]?
19:33:01 <kotrin> just add another element to the operators array
19:33:28 <Sgeo> Oh, and it's supposed to strip all comments out
19:33:33 <Sgeo> (non operaters)
19:34:04 <oklopol> bsmntbombdood, this is illegal, how do i go around it?
19:34:47 <ihope_> ~pexec self.raw("PRIVMSG #esoteric :" + foo)
19:34:59 <ihope_> ~pexec self.foo = "foo"
19:35:04 <ihope_> ~pexec self.raw("PRIVMSG #esoteric :" + self.foo)
19:35:39 <oklopol> bsmntbombdood, please tell me :-|
19:35:50 <bsmntbombdood> ~pexec while 1: self.raw("PRIVMSG #esoteric :tick"); __import__("time").sleep(2)
19:35:55 <bsmnt_bot_chroot> 0: 'while 1: self.raw("PRIVMSG #esoteric :tick"); __import__("time").sleep(2)', 4.50 seconds
19:36:14 -!- oerjan has quit ("leaving").
19:37:21 <oklopol> or you mean that's legal code as it is?
19:37:42 <oklopol> Traceback (most recent call last):
19:37:43 <oklopol> File "<pyshell#16>", line 1, in ?
19:37:43 <oklopol> File "<pyshell#15>", line 4, in oso
19:37:43 <oklopol> File "<pyshell#15>", line 3, in poso
19:37:46 <oklopol> UnboundLocalError: local variable 'a' referenced before assignment
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:43:09 <CakeProphet> a += 1 wouldn't work if a was never defined before that.
19:44:42 <oklopol> but, same result if it's created in the function
19:45:05 <kotrin> sgeo: http://pastie.caboo.se/31707
19:46:13 <CakeProphet> yeah... that should work thanks to closures.
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: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: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:40 <oklopol> CakeProphet, do you have a solution?
19:54:17 <ihope_> ~pexec self.pop_register_raw()
19:54:31 <ihope_> Well, that sure didn't work.
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:26 <kotrin> does python have an irc library?
19:55:55 <oklopol> CakeProphet, i have 3 vars i need to change in a subfunction
19:56:37 <ihope_> ~pexec self.raw("JOIN ##quantum")
19:56:41 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
19:57:00 -!- EgoBot has joined.
19:57:04 <oklopol> bsmntbombdood, easier this way
19:57:27 -!- bsmnt_bot_chroot has quit.
19:57:40 -!- bsmnt_bot_chroot has joined.
19:58:11 <oklopol> k how should i remove side-effects? i want a function that does a single brainfuck operation
19:58:22 <oklopol> done on my current stack and pointers
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:06 <CakeProphet> oklopol it should just simply work like you expect it to.
19:59:16 -!- bsmnt_bot_chroot has joined.
19:59:31 <oklopol> you mean this should work?
19:59:31 -!- bsmnt_bot_chroot has quit (Client Quit).
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.
20:00:01 <ihope_> Rather tricky to so a ~pexec after PARTing it.
20:00:34 -!- bsmnt_bot_chroot has left (?).
20:00:48 -!- bsmnt_bot_chroot has joined.
20:01:31 <bsmntbombdood> ~exec self.register_raw(":\S+ PART #esoteric :.*", lambda x : bot.raw("JOIN #esoteric"))
20:01:39 -!- bsmnt_bot_chroot has left (?).
20:01:39 -!- bsmnt_bot_chroot has joined.
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:15 <oklopol> CakeProphet, well it doesn't
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:46 -!- digital_me has joined.
20:02:57 <bsmntbombdood> TypeError: do_exec() takes exactly 3 arguments (2 given)
20:03:17 -!- digital_me has quit (Client Quit).
20:03:30 -!- digital_me has joined.
20:04:03 <ihope_> I gave it... like, one?
20:04:49 <ihope_> ~pexec self.register_raw("(:\S* )PRIVMSG \S* :~emerg(.*)", lambda x,y: bot.do_exec(y,r))
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: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:56 <bsmntbombdood> ~pexec self.register_raw(":\S* PRIVMSG \S* :~emerg (.*)", lambda x,y: bot.do_exec(x,y))
20:07:26 <CakeProphet> ~pexec self.raw("PRIVMSG #esoteric :" + (lambda x: (lambda closure: x)("Doop"))("Hello, World!"))
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: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:12:13 <CakeProphet> ~pexec self.register_raw(":\S* PRIVMSG \S* :~emerg (.*)", bot.do_exec)
20:15:02 <ihope_> Does it require root access or anything?
20:15:45 <bsmntbombdood> as you can see it drops root if it has it on line 256
20:16:13 <ihope_> It drops root if it has it... what if it has something else?
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:20:02 <ihope_> Does it do any sandboxing of itself besides root-dropping?
20:21:30 <CakeProphet> bsmnt You could pickle the raw_regex_queue between executions.
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:23:25 <ihope_> ...is editable mid-game?
20:23:41 <CakeProphet> as in... the game has facilities for programming itself.
20:24:35 <CakeProphet> After the initial bootstrap... most of the "physical" sourec files are no longer needed...
20:25:39 <ihope_> Note to self: don't chmod u_
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:45 <ihope_> I chmod u+x'd that Python file and ran it.
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: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.
21:07:29 -!- ShadowHntr has joined.
21:15:11 <ihope_> Now tell me what that does.
21:20:46 <ihope_> ~exec self.raw("PRIVMSG #esoteric" + pass)
21:20:55 <ihope_> ~exec self.raw("PRIVMSG #esoteric :" + pass)
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:57 <ihope_> ~pexec self.raw("PRIVMSG #esoteric :" + pass)
21:28:28 <ihope_> ~pexec self.raw("PRIVMSG #esoteric :foo")
21:28:51 <ihope_> ~pexec self.raw("PRIVMSG #esoteric :foo")
21:29:08 <ihope_> ~pexec self.raw("PRIVMSG #esoteric :foo")
21:29:57 <ihope_> Curse Python or Haskell.
21:30:45 <ihope_> ~emerg self.raw("PRIVMSG #esoteric :foo")
21:31:23 <ihope_> ~emerg self.raw("PRIVMSG #esoteric :foo")
21:33:15 <ihope_> ~pexec self.do_callbacks(":bsmntbombdood!n=gavin@about/copyleft/user/bsmntbombdood PRIVMSG #esoteric :~exec self.raw('PRIVMSG #esoteric :foo')")
21:34:23 <bsmntbombdood> ~exec for i in range(4): self.raw_regex_queue.pop()
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: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:38:09 <ihope_> ~pexec self.esoteric = lambda x: self.raw("PRIVMSG #esoteric :%s" % x)
21:38:14 <ihope_> ~pexec self.esoteric(3)
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:07 <ihope_> ~pexec self.esoteric(3)
21:40:06 <bsmntbombdood> ~pexec self.esoteric = lambda x: bot.raw("PRIVMSG #esoteric :%s" % x)
21:41:30 <ihope_> ~exec self.esoteric(self.esoteric)
21:42:06 -!- Sgeo has quit (Remote closed the connection).
21:42:34 * ihope_ slaps GregorR, too, just because
21:43:32 <ihope_> ~pexec self.esoteric(1/0)
21:43:56 <ihope_> Did that give an error?
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:46:48 <ihope_> Can I declare a lambda that takes no arguments?
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:48:34 <ihope_> How do I declare a function that can take a variable number of arguments?
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:53:03 <ihope_> There the arguments are the remaining elements of the list?
21:53:53 <ihope_> If the elements are foo, bar, and baz, will that call foo(bar,baz)?
21:54:05 <ihope_> ~pexec self.apply_thunk = lambda *x: lambda: x[0](x[1:])
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: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: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: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: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: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:55 <ihope_> ~pexec self.esoteric(self.apply_thunk(lambda x,y: x+y, 3, 5))
22:01:11 <bsmntbombdood> ~pexec print self.apply_thunk(lambda x,y: x+y, 3, 5)()
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: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: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: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:40 <ihope_> ~pexec self.esoteric(lambda: 3)
22:11:49 <ihope_> self.esoteric is still working, at least.
22:17:40 <bsmntbombdood> ZeroDivisionError: integer division or modulo by zero
22:18:16 <ihope_> The SyntaxError's for the try/except thing up there?
22:19:33 -!- bsmnt_bot_chroot has quit.
22:19:35 -!- bsmnt_bot_chroot has joined.
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 <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: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: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:23:04 -!- kotrin has left (?).
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:25:04 <ihope_> ~pexec thread.start_new_thread(self.exec_execer, ("self.raw('PRIVMSG #esoteric :I win')", (globals(), locals())))
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: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: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:27 <bsmntbombdood> ~pexec self.exec_string("bot.raw('PRIVMSG #esoteric :Wonderful.')")
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:59 <ihope_> ~pexec self.exec_string("self.raw('PRIVMSG #esoteric :Wonderful.')")
22:31:19 <ihope_> ~pexec self.exec_string("bot.raw('PRIVMSG #esoteric :Wonderful.')")
22:31:27 <ihope_> ~pexec self.exec_string = lambda x: thread.start_new_thread(bot.exec_execer, (x, (globals(), locals())))
22:34:31 <ihope_> Executing multiple lines of stuff.
22:35:51 <ihope_> So not at all like "oof"?
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: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:31 <ihope_> Oh well. It still works.
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:46:07 -!- oerjan has joined.
22:47:31 <bsmntbombdood> sys.stdout.write = lambda x : self.raw("PRIVMSG #bsmnt_bot :%s" % x)
22:47:45 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:47:48 -!- bsmnt_bot_chroot has joined.
22:48:43 <bsmntbombdood> Unhandled exception in thread started by <bound method IRCbot.exec_execer of <__main__.IRCbot instance at 0xb7cbcb2c>>
22:49:19 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:49:23 -!- bsmnt_bot_chroot has joined.
22:49:44 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:49:47 -!- bsmnt_bot_chroot has joined.
22:52:42 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:52:45 -!- bsmnt_bot_chroot has joined.
22:54:05 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:54:06 -!- bsmnt_bot_chroot has joined.
22:54:27 <bsmntbombdood> AttributeError: 'file' object attribute 'write' is read-only
22:55:25 -!- ivan` has joined.
22:55:54 -!- dantekgeek has joined.
22:56:00 -!- zedrdave has joined.
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: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:46 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
22:57:48 -!- bsmnt_bot_chroot has joined.
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:46 <oklopol> is it okay i put your codes in oklobots reference?
22:59:06 -!- ivan` has left (?).
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:17 <ihope_> bsmnt_bot_chroot: you missed it!
23:00:37 <ihope_> It's a little bit spammy.
23:01:00 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:01:01 -!- bsmnt_bot_chroot has joined.
23:02:11 -!- zedrdave has left (?).
23:04:21 <oerjan> may i recommend kill -9 ? :)
23:05:13 -!- bsmnt_bot_chroot has quit (Read error: 131 (Connection reset by peer)).
23:05:17 -!- bsmnt_bot_chroot has joined.
23:06:00 <oerjan> still a bit spammy for a response to a single line
23:06:02 -!- pikhq has joined.
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:08:51 <ihope_> Don't print blank lines.
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: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: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:17:23 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:17:25 -!- bsmnt_bot_chroot has joined.
23:17:52 <bsmntbombdood> ok, #bsmnt_bot_chroot_errors has stderr and stdout redirected to it
23:22:23 <bsmntbombdood> hmm I need to change the interface for exec_execer then
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:28:52 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:28:55 -!- bsmnt_bot_chroot has joined.
23:31:09 <ihope_> When's the last time you registered a command?
23:33:07 <ihope_> ~pexec self.register_raw('(.*)', lambda x,y: print x)
23:34:55 <CakeProphet> ~pexec self.register_raw('(.*)', lambda x,y: sys.write(x + "\n")))
23:35:15 <ihope_> ~pexec self.register_raw('(.*)', lambda x,y: self.raw("PRIVMSG #bsmnt_bot_chroot_errors :%s" % x))
23:35:23 -!- bsmnt_bot_chroot has quit (Remote closed the connection).
23:35:24 -!- bsmnt_bot_chroot has joined.
23:35:34 <ihope_> That clearly didn't work.
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: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 -!- 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:07 <CakeProphet> ~pexec self.register_raw('(.*)', lambda x,y: self.raw("PRIVMSG CakeProphet :%s" % x))
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:42:21 -!- anonfunc_ has joined.
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:55 <bsmntbombdood> ~exec self.register_raw("\S+ PRIVMSG #esoteric :(~quine.*)", lambda x, y : bot.raw("PRIVMSG #esoteric :%s" % y.group(1)))
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:54:45 -!- puzzlet has joined.
23:57:23 -!- anonfunc has quit (Connection timed out).