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