00:00:09 <graue> that doesn't seem to work either (adding exports there)
00:00:57 <graue> ah, .bashrc worked
00:03:04 <graue> here is the sokoban program I was thinking of: http://esoteric.sange.fi/archive/2001-q2-2
00:03:30 -!- graue has quit (Remote closed the connection).
00:05:02 <GregorR-L> G!{M[moO!"You suck GregorR!"oo.?]}
00:08:37 <calamari> I see that you noticed my little _o -> o trick hehe
00:08:55 <GregorR-L> Actually it uncovered a memory leak :P
00:09:10 <GregorR-L> M doesn't delete its class variables :P
00:11:06 <GregorR-L> A memory leak ... that I haven't fixed 8-D
00:26:35 <GregorR-L> BTW, I'm considering making a competitor to EsoBot, since the idea is far better than GlassBot's.
00:27:44 <kipple> ooh. many bots here now :)
00:28:00 <kipple> what does the esobot do?
00:28:02 <GregorR-L> If calamari would keep EsoBot on 24/7, I could disable BFBot.
00:28:20 <GregorR-L> kipple: Several languages, any implemented in Java could be made to be done in EsoBot.
00:29:11 <kipple> if calamari can't keep it on 24/7 I'd be happy to host it
00:29:34 <GregorR-L> Not as soon as EgoBot comes out and is better ;)
00:30:56 <kipple> hmm. I could write a small bot that just pipes the program a regular interpreter and return the output. That way I could easily interpret all languages I have interpreter for :)
00:32:56 <GregorR-L> The best part of EsoBot is that it has no problem with infinite loops, since it can multiprocess.
00:34:07 <marcan> just another guy who thinks esoteric languages are fun :)
00:34:38 <calamari> kipple: thanks for the hosting offer :)
00:34:52 <marcan> I've got an UML server by the way
00:34:57 <marcan> so if hosting is needed, I've got some
00:35:25 <calamari> kipple: I'd run it on my shell, but they specifically disallow irc bots
00:36:03 <marcan> my other hosting provider used to disallow IRC bots too
00:36:06 <kipple> my host is just an old 187MHz debian box under my bed, but at least its on 24/7
00:36:13 <marcan> but my current one allows anything, basically (as long as it is legal)
00:36:27 <marcan> they don't like excessive CPU usage though, but I can throttle that
00:37:05 <marcan> nice thing about UML is you get your own virtual distro
00:37:09 <marcan> so you have full privileges
00:37:49 <kipple> what's UML (not the markup language)
00:38:14 <marcan> basically, they run linux as a process under linux
00:38:20 <marcan> so you effectively have your own kernel and userland
00:38:28 <marcan> (you get a virtual hard disk partition)
00:38:36 -!- graue has joined.
00:39:15 <graue> what are some of the more "practical" esolangs, like ones I could write a CGI script in?
00:39:30 <graue> Glass would work for that?
00:39:34 <graue> I should try it then
00:39:38 <marcan> I guess Funge would work too, but it would be interesting to code in
00:40:00 <graue> can you parse text in those languages, without, like, using 90 screenfuls of junk to do it?
00:40:04 <marcan> oops, kipple was faster on that one :)
00:40:29 <GregorR-L> In Glass you could make a nice parser class and then never type it again :)
00:40:32 <graue> I mean I'm not really gonna be able to parse headers with brainfuck, for instance
00:40:48 <marcan> I guess you could parse text decently with befunge or Glass
00:40:59 <GregorR-L> Though I need to finish the input class before any of this would be useful ;)
00:41:16 <marcan> for CGI you'd need environment variables too
00:42:15 <graue> just need to write a little wrapper that provides all the environment variables on stdin, followed by a blank line
00:42:28 <graue> GregorR-L, CGI uses environment variables e.g. $HTTP_CONTENT_LENGTH etc
00:42:46 <GregorR-L> OH, I'm underspecifying mentally :P
00:43:40 <marcan> I'd really love to see something complex implemented on a layered Brainfuck :)
00:43:50 <marcan> like, implement a simple opcode language on top of brainfuck
00:43:56 <marcan> the something more complex on top of that
00:43:59 <marcan> then write a game on it
00:44:04 <marcan> would be slow as hell, though
00:46:28 <graue> I've been thinking of a Brainfuck with procedures
00:46:35 <graue> it would be compiled into ordinary Brainfuck
00:46:57 <graue> by inlining recursively (procedures in this language could not make recursive calls)
00:47:23 <graue> someone already made BFM, Brainfuck with macros, but I remember not liking that language (or its implementation) for some reason
00:47:48 -!- CXI has quit (Read error: 104 (Connection reset by peer)).
00:48:21 -!- CXI has joined.
00:49:01 <kipple> graue: seen this? http://esolangs.org/wiki/Pbrain
00:49:55 <graue> kipple: ah, interesting
00:50:00 <graue> kipple: I was thinking proper names though
00:50:25 <graue> like (add) (brainfuck code for adding goes here)
00:50:52 <kipple> I like the pbrain approach as it is a bit more bf-like than others I've seen
00:53:42 <graue> having procedures at all isn't bf-like
00:54:16 <kipple> true. I said _more bf.like_ though
00:54:31 <kipple> it doesn't pollute the source code with user-friendly keywords
01:11:55 <graue> with my version, the only place letters would be significant is inside parentheses
01:16:44 <graue> doesn't the numbering limit Pbrain to 256 procedures?
01:16:55 <kipple> yes (if you use 8-bit cells)
01:18:26 <graue> never mind, I see how it doesn't
01:19:23 <graue> er, in a way, because you can make a procedure 0 add its version of procedures 2-255, and procedure 1 add its version of those procedures, for a total of 510 procedures
01:19:55 <graue> then calling procedure 2-14 becomes [-]++:++++++++++++:
01:20:44 <graue> this would be pretty hard to compile into regular brainfuck
01:25:51 <graue> we ought to start using the ESOLANG mailing list again
01:26:11 <graue> much of the chatter on the wiki really doesn't belong on wiki talk pages at all, since it's about the languages themselves
01:26:25 <graue> and it keeps going into indentation overdrive and running off the right side of the page, too
01:26:40 <kipple> yeah, but not everyone wants to be on the mailing list :(
01:26:47 <graue> kipple: really? who doesn't?
01:27:20 <kipple> don't know specifically, but in general I feel there are always some who don't want to bother with subscribing to mailing list
01:27:36 <kipple> that is of course mostly their problem
01:29:56 <marcan> has anyone written a Tetris game in brainfuck?
01:30:03 <marcan> that would be an interesting project
01:30:18 <kipple> I don't know any games written in bf...
01:30:43 <graue> how would you do the delaying?
01:30:45 <marcan> it would need minor changes to the interpreter though
01:30:48 <graue> brainfuck can't call nanosleep
01:31:07 <marcan> well, you could just loop for a while
01:31:11 <marcan> and make a crude delay
01:31:31 <marcan> the interpreter would need to support unbuffered and nonblocking input though
01:31:34 <graue> that sounds like DOS games written in Pascal
01:32:18 <graue> unbuffered and nonblocking input would be sufficient for anything visual, using vt100 sequences or whatever
01:32:40 <graue> but I don't think you'll have any luck getting a fudged delay to work on more than one interpreter, let alone computer
01:32:59 <marcan> I guess we could add in another operator though
01:33:13 <marcan> delay current cell in ms
01:33:19 <graue> that's just what I was thinking
01:33:49 <marcan> that would be a pretty interesting BF program though
01:33:52 <graue> how about sokoban in brainfuck? make the player type "u<enter>" to move up, etc
01:34:44 <marcan> similar to tetris in essence
01:35:25 <graue> how? tetris requires delays and reflexes
01:39:20 <marcan> but you still have an array of blocks, and move around things
01:39:25 <marcan> you need some of the same principles
01:39:39 <marcan> collision detection and moving on a 2D grid (using 1D memory)
01:41:09 <marcan> http://jonripley.com/brainfuck/games/
01:43:53 <fizzie> There's bfvga, but no-one sane would write a game in it.
01:44:27 <calamari> marcan: type this: /msg EsoBot E!bf http://localhost/bf/LostKng.b
01:45:07 <EsoBot> 3:calamari, 4:marcan, 5:marcan
01:45:28 <calamari> marcan: then use E!input <process> ...
01:45:42 <marcan> impressive, given that my interpreter has yet to print out a single character
01:45:59 <marcan> time to get a faster interpreter (that I never thought I'd need)
01:46:06 <calamari> marcan: bf is my favorite esoteric language :)
01:46:48 <kipple> Lost Kingdom is not written in brainfuck though, so it doesn't really count.
01:47:00 <fizzie> (bfvga's a bf with a 64000-byte data array mapped to the 320x200x8bit-sized VGA mode display memory - http://www.pouet.net/prod.php?which=5060 )
01:47:29 <calamari> blah, whatever, it counts in my book 1) it's a cool game, 2) it would take too long to write directly
01:48:13 <graue> it does demonstrate the coolness of BFBASIC
01:48:31 <kipple> it also demonstrates what's possible with brainfuck itself
01:48:39 <graue> but I don't see at as much different, really, than distributing a binary program with no source code
01:48:44 <graue> I guess it also does that, true
01:49:09 <graue> and stress-tests interpreters...
01:49:32 <graue> that reminds me, I could never get anything nontrivial working with BFBASIC
01:49:46 <graue> the resulting BF programs were just freezing or producing garbage
01:49:58 <graue> does it make weird assumptions about the environment (e.g. 16-bit word size)?
01:50:00 <calamari> there were some serious bugs in the for/next code for a while
01:50:38 <calamari> I think it may make some assumptions
01:50:52 <calamari> I don't remember, that's really sad
01:51:25 <graue> EOF=0, 8-bit cells with wraparound, would be pretty sane assumptions, but I was using an implementation that met those
01:51:47 <calamari> I don't think there is any EOF checking
01:51:55 <calamari> since it doesn't really have any file functions
01:52:20 <graue> maybe the implementation was just broken
01:52:31 <graue> I was using some weird DOS thing that makes .com files, I think, at the time
01:52:32 <calamari> yep, depends on 8 bit cells (at least NOT does)
01:53:06 <calamari> I made a few bf -> com compilers
01:53:06 <graue> calamari: I don't think so
01:53:12 <graue> calamari: maybe though
01:53:27 <calamari> since they didn't handle cr/lf correctly
01:54:08 <graue> kipple: how's progress on the Kipple '05 spec?
01:54:30 <kipple> funny yous should ask. I'm working on it right now :)
01:54:48 <marcan> when will we get bfgl?
01:54:51 <kipple> pretty close to done I think
01:56:32 <kipple> hmm. is there a true esoteric language that at the same time is efficient enough for graphics?
01:57:13 <calamari> iirc it was similar to befunge with a huge library of functions
01:59:05 <marcan> (and my firefox just crashed on its homepage)
02:03:39 <marcan> I'm pretty sure it was the flash
02:03:52 <calamari> yeah, that's what would always crash me in 98
02:04:04 <calamari> hasn't happened in linux for me yet, tho
02:04:35 <marcan> I'm on amd64, and the official flash (which usually works) doesn't here
02:04:47 <marcan> so I used to have gplflash, which never worked and always crashed
02:04:55 <marcan> but flashblock would usually stop the flashes anyway
02:04:59 <calamari> btw are you through with the game?
02:05:05 <marcan> I'm completely killing gplflash now
02:08:32 <kipple> graue: about Kipple 05: I don't think I will finish the spec until I have it fully implemented
02:09:09 <graue> cipple will need updating too!
02:09:42 <kipple> have you read the new spec draft?
02:10:28 <kipple> unless they want to implement the optional features, updating cipple and orkipple will be rather trivial
02:12:33 <graue> well, cipple is my implementation of choice so (no offense, but) if cipple doesn't implement it I'm not going to be using it
02:12:56 <graue> and it does implement the "optional string preprocessing feature"
02:13:03 <graue> jix wanted it as close to the original interpreter as possible
02:13:18 <graue> have you written a Glainfuck?
02:15:02 <marcan> writing a BF interpreter is easier than writing a BF program in many cases, which is one of the most ironic things I like about BF
02:15:18 <kipple> graue: what cipple implements is not up to me, unfortunately ;)
02:15:52 <kipple> marcan: yeah. In almost ANY case I would say
02:16:25 <marcan> except simple stuff like [+.] or [,.[-]+] or so
02:16:45 <marcan> (add a + in front of those to actually make them do anything
02:16:54 <graue> that first one should be +[.+]
02:18:03 <marcan> My Python BF interpreter supports unlimited memory in both directions, and unlimited cell size
02:18:17 <marcan> of course, programs which assume wraparound will fail
02:19:38 <calamari> graue: .+[.+] if you want \0 too :)
02:20:18 <graue> I think someone wrote an interpreter once where printing \0 ended the program
02:20:40 <marcan> hmm... Thinking about interpreters and compilers...
02:20:50 <marcan> all that is kind of boring
02:21:22 <marcan> without an FPGA or a microcontroller?
02:22:02 <calamari> http://en.wikipedia.org/wiki/Brainfuck#Hardware
02:22:20 <graue> why isn't that information in the esolang article?
02:22:26 <marcan> one is an VHDL design for an FPGA and the other is for a PIC16F84 uC
02:22:53 <marcan> the PIC one is essentially an interpreter for an already existing CPU though
02:23:03 <marcan> and the VHDL one is an interpreter in a lower level hardware description language
02:23:26 <marcan> but It'd be cool making an interpreter out of logic gates
02:23:31 <calamari> need to make one out of transistors to be pure enough?
02:23:53 <marcan> hell, someone made a complete CPU running a multitasking OS using 74xx gates
02:23:59 <marcan> a brainfuck CPU is a piece of cake
02:24:30 <marcan> http://www.homebrewcpu.com/
02:25:11 <marcan> and connect to the computer :)
02:26:39 <marcan> http://www.magic-1.org/
02:26:43 <marcan> and there's the webserver
02:37:46 <marcan> well, brainfuck would be way easier
02:38:53 <marcan> all you need is SRAM, a pointer register (with increment/decrement), a data register for inc/dec the memory, and a serial port for , and .
02:39:03 <marcan> and some logic for [ and ], which would be the most complicated part of it
02:39:13 <marcan> (it would take just a couple counters though)
02:47:51 -!- GregorR-L has quit (Read error: 113 (No route to host)).
02:55:43 <marcan> calamari: I'm going to see if I can do it on a simulator
02:58:17 <GregorR> calamari: I'm wrong, there actually is /not/ a memory leak there :P
02:58:22 <GregorR> I was positive that there was XD
02:58:38 <GregorR> Glass, if you made a class-wide variable of the M class.
02:59:00 <calamari> you may be able to simplify [] if you don't need "pure" bf
02:59:28 <GregorR> Yeah, [] is quite different from how a real CPU would handle jumps.
02:59:50 <marcan> it can be made simple though
03:00:27 <marcan> all [ has to do is disable instruction execution (ie turn everything into a NOP) and count the number of [] until the number reaches 0, then turn it back on, if the register is 0
03:00:35 <marcan> and ] just does the opposite, reversing the memory direction
03:00:58 <calamari> I was thinking along the lines of the x86 JMP and JNZ :)
03:01:23 <marcan> well, I could make the source include more information
03:01:29 <marcan> like have [ include the address of the matching ]
03:01:35 <calamari> but then you get into multiple bytes per instruction which introduces its own complication
03:02:14 <calamari> I'd like to see one built with transistors
03:02:45 <marcan> it would basically just be the same thing as using 74xx gates, but breaking down the gates into transistors
03:02:48 <marcan> no real changes though
03:03:16 <calamari> how many transistors are in the simple 74xx's?
03:03:37 <marcan> a single nand gate is what, two FETs or so
03:03:55 <calamari> so it may not be a huge deal to go pure then :)
03:04:05 <marcan> of course, just a pain in the ass
03:04:27 <marcan> like, a single 8bit latch in 74xx is a bunch of transistors in a repeating arrangement
03:04:48 <calamari> who needs 8bit.. 1 bit should be enough for anybody .. ;)
03:04:49 <marcan> oh, and a pain to route on a PCB :)
03:06:10 <GregorR> Goooooooooo bitchanger! :)
03:06:14 <calamari> the part I have never quite been able to grasp is how the clock/crystal thing works
03:06:20 <graue> are there any logic-gate-like languages?
03:06:50 <calamari> graue: you mean like part #, wire connections?
03:07:21 <graue> I mean like nand and xor gates and stuff
03:07:22 <marcan> there are circuit description languages
03:07:24 <calamari> that'd be pretty much like a chip simulator, right?
03:07:25 <marcan> and then you can emulate them
03:07:27 <graue> no, esoteric languages
03:09:24 <GregorR> {M[(ln)(_a)1=,/(_a)<0>^\<1>][m(_i)I!(_o)O!(_t)$(_c)(_i)e.?(_t)(ln).?=/(_c)(_i)c.?(_o)o.?(_c)(_i)e.?(_t)(ln).?=\]} < cat in glass 8-D
03:10:14 <graue> very good, but can you write "dog" in glass?
03:10:35 <GregorR> G!{M[m(_o)O!"dog"(_o)o.?]}
03:10:38 <graue> the little-known dog utility, provided on some historical UNIXes, prints its output in reverse order after converting all letters to uppercase
03:11:04 <graue> is there no language based on nand gates?
03:11:07 <graue> I could have sworn there was
03:11:29 <GregorR> G!{M[m(_o)O!"^QUIT :Upgrades!"(_o)o.?]}
03:11:31 -!- GlassBot has quit ("Upgrades!").
03:11:31 <marcan> you can build any circuit out of nand gates
03:12:16 <graue> yes, I remember learning that fact in conjunction with (I thought) some sort of language or VM based on the concept
03:12:23 <calamari> marcan: there you go.. build a computer.. hehe
03:12:38 -!- GlassBot has joined.
03:13:09 <marcan> a NAND gate with both inputs tied gives you an inverter
03:13:16 <marcan> put that after another NAND, you get AND
03:13:30 <marcan> put two inverters in front of NAND, you get OR
03:13:41 <marcan> and you can build XOR out of that
03:13:47 <marcan> and flipflops, and anything you want
03:14:30 <GregorR> I prefer to think of it as EQUAL :P
03:14:48 <graue> and XOR as NEQUAL?
03:14:49 <marcan> also, is there a boolean XOR in C?
03:14:57 <marcan> I always wondered that and never bothered to look
03:14:58 <graue> we were just discussing that earlier today
03:15:06 <graue> GregorR, he means a ^^
03:15:18 <graue> we were just discussing that earlier today and we decided it doesn't exist because:
03:15:22 <graue> 1) it would look too cute
03:15:25 <graue> 2) it couldn't be short-circuited
03:15:37 <GregorR> int xor(int a, int b) { if ((a && !b) || (b && !a)) return true; return false; }
03:16:31 <graue> I want to be able to do "(a ^^ b) = 1;"
03:16:34 <graue> that would be cool
03:17:04 <graue> wait, that doesn't make any sense
03:17:23 <graue> if they're not equal then it sets them both to 1
03:17:24 <marcan> it'd make a nice esoteric instruction
03:17:28 <graue> if they're equal then it does nothing
03:17:30 <marcan> may assign the value to one bit
03:17:38 <graue> I prefer my version
03:18:20 <graue> of course "(a && b) = 1;" would set both to 1 unconditionally
03:18:50 <GregorR> if (a ^^ b) = 1; set them both to one, then it would make (a ^^ b) != 1; ...
03:19:04 <graue> and "(a || b) = 1;" would set b to 1 only if a was initially nonzero, but would always set a to 1 (after reading its initial value)
03:19:49 <marcan> someone just called me due to a virus in his PC
03:19:59 <marcan> I wonder if you could write a virus in BF or something
03:20:08 <graue> you could write a worm in l33t
03:20:09 <marcan> it has connection support, heh
03:21:13 <graue> you could not infect OpenBSD boxes with it, though
03:21:20 <graue> at least not if they were running a default install
03:21:20 <marcan> anyway, I'm off to have a look at his PC
03:24:20 <GregorR> So graue, should I start making that CGI class for Glass? ;)
03:29:03 * GregorR tries to decide whether it would be prudent to build support for environment variables into Glass ...
03:30:39 <graue> hehe, make it really bloated and include a zlib class in the standard library
03:33:20 <GregorR> Hmm, I have no way of interfacing to C, so one would have to implement zlib in Glass XD
03:34:11 <GregorR> G!{M[m(_d)(Debug)!(_d)(cl).?]}
03:34:12 <GlassBot> A Arr Arre BF Debug Emote F FE Fib I L LameQuine M Main O Rand S T Test V
03:34:20 <GregorR> G!{M[m(_o)O!"^QUIT :More upgrades!"(_o)o.?]}
03:34:22 -!- GlassBot has quit ("More upgrades!").
03:35:10 -!- GlassBot has joined.
03:35:15 <GregorR> G!{M[m(_d)(Debug)!(_d)(cl).?]}
03:35:17 <GlassBot> A Arr Arre BF Debug Emote F Fib I L LameQuine M Main O Rand S T Test V
03:35:35 <GregorR> G!{M[m(_d)(Debug)!(_d)(cl).?]}
03:35:38 <GlassBot> A Arr Arre BF Debug Emote F Fib I L LameQuine M O Rand S T V
03:35:47 <GregorR> G!{M[m(_d)(Debug)!"T"(_d)(fl).?]}
03:41:58 <calamari> G!{M[moO!"+++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++."oo.?]}
03:42:00 <GlassBot> +++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++.
03:42:08 <calamari> G!{M[moO!"E!bf +++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++."oo.?]}
03:42:08 <GlassBot> E!bf +++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++.
03:43:37 <GregorR> I just got my first Glass CGI script working :)
03:44:10 <GregorR> I'm behind a LAN which is behind a LAN.
03:44:21 <GregorR> {M[m(_o)O!"Content-type: text/plain\n\nThis is a test\n"(_o)o.?]}
03:44:41 <graue> that's trivial though; it doesn't respond to input
03:44:42 <tokigun> that's so simple... how about complex code?
03:44:44 <calamari> G!{M[moO!"F!34,E!bf +++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++.34,"oo.?]}
03:44:46 <GlassBot> F!34,E!bf +++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++.34,
03:44:46 <falsebot> Error: Argument to ! is not a function
03:45:15 <GregorR> I'm still working on it ;)
03:45:30 <tokigun> GregorR: hunt the wumpus! XD
03:45:45 <tokigun> ah, finally i'm rewriting SADOL interpreter in C++
03:46:06 <tokigun> i have old interpreter written in C, but it was... ehh... whatever.
03:46:07 <calamari> F!"G!{M[moO!"34,"E!bf +++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++."34,"oo.?]}"
03:46:07 <falsebot> G!{M[moO!"E!bf +++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++."oo.?]}
03:46:08 <GlassBot> E!bf +++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++.
03:49:27 <GregorR> OK, it will clearly need access to the environment for GET, but what about POST ...
03:50:18 <calamari> F!"G!{M[moO!"34,"BF!+++++++++++[>++++++>+++>++++>++++<<<<-]>+++.+++++++++++++++++++++++++++++.++++.+++.>-.<---.-----.++.+++++++++++++++++.-----.+++.>>++.<<----------------.>.+++++++++++..>---..>-....<...<<-------.>>+++++++++++++++++++.>....<<..>>...<.>........<<..>--..<++.<++.>>++.>.<<+.>.>.<<.>--.>...<<."34,"oo.?]}"
03:50:40 <calamari> BF!+++++++++++[>++++++>+++>++++>++++<<<<-]>+++.+++++++++++++++++++++++++++++.++++.+++.>-.<---.-----.++.+++++++++++++++++.-----.+++.>>++.<<----------------.>.+++++++++++..>---..>-....<...<<-------.>>+++++++++++++++++++.>....<<..>>...<.>........<<..>--..<++.<++.>>++.>.<<+.>.>.<<.>--.>...<<.
03:50:43 <BFBot> Ebfi factor.b +++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++.
03:50:56 <tokigun> GregorR: well, but POST method requires environment variable...
03:51:14 <calamari> BF!+++++++++++[>++++++>+++>++++>++++<<<<-]>+++.+++++++++++++++++++++++++++++.++++.+++.>-.<---.-----.++.+++++++++++++++++.-----.+++.>>++.<<----------------.>.+++++++++++..>---..>-....<...<<-------.>>+++++++++++++++++++.>....<<..>>...<.>........<<..>--..<++.<++.>>++.>.<<+.>.>.<<.>--.>...<<.
03:51:15 <BFBot> Ebfi factor.b +++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++.
03:51:23 <GregorR> tokigun: POST seems to put vars on stdin.
03:51:26 <calamari> weird.. must have copied the wrong string
03:51:48 <tokigun> GregorR: yes, but its length is given to environment variable "CONTENT_LENGTH".
03:52:10 <GregorR> OK, I'm going to have to make environment vars >_<
03:54:51 -!- graue has quit.
04:04:11 <calamari> I can't output ! without it being interpreted
04:05:54 -!- Sgep has quit.
04:06:09 <GregorR> That is, you can't: echo Hello world!
04:10:30 <GregorR> G!{M[m(_o)O!"^QUIT :Even more upgrades!"(_o)o.?]}
04:10:31 -!- GlassBot has quit ("Even more upgrades!").
04:11:16 -!- GlassBot has joined.
04:16:46 <GregorR> Hmm, will this flood or not...
04:16:47 <GregorR> G!{(Hshe)[(c__)k"a"=v<0>=n<0>=][(gk)k*][(sk)k1=,][(gv)v*][(sv)v1=,][(gn)n*][(sn)n1=,]}{(Hsh)[(c__)(_v)V!h(_v)n.?=h*(Hshe)!][(ln)(_a)1=,/(_a)<0>^\<1>][l(_a)A!(_s)S!(_v)V!(_t)$(_m)1=,ch*=(_f)c(gk).?(_m)*(_s)e.?(_t)(ln).?=/(_f)(_add)c(gn).?<0>(_a)e.?=/(_add)(_add)<0>=(_w)(_v)n.?=(_w)*(Hshe)!(_w)*c(sn).?\cc(gn).?=(_f)c(gk).?(_m)*(_s)e.?(_t)(ln).?=\][g(_t)$(_w)1=,(_w)*(_t)l.?c(gv).?][s(_t)$(_w)2=(_v)1=
04:16:50 <GregorR> ,,(_w)*(_t)l.?(_v)*c(sv).?]}
04:18:38 <GregorR> G!{(Hsh)[(c__)(_v)V!h(_v)n.?=h*(Hshe)!][(ln)(_a)1=,/(_a)<0>^\<1>][l(_a)A!(_s)S!(_v)V!(_t)$(_m)1=,ch*=(_f)c(gk).?(_m)*(_s)e.?(_t)(ln).?=/(_f)(_add)c(gn).?<0>(_a)e.?=/(_add)(_add)<0>=(_w)(_v)n.?=(_w)*(Hshe)!(_w)*c(sn).?\cc(gn).?=(_f)c(gk).?(_m)*(_s)e.?(_t)(ln).?=\][g(_t)$(_w)1=,(_w)*(_t)l.?c(gv).?][s(_t)$(_w)2=(_v)1=,,(_w)*(_t)l.?(_v)*c(sv).?]}
04:19:24 <GregorR> G!{M[m(_o)O!(_h)(Hsh)!"A""B"(_h)s.?"A"(_h)g.?(_o)o.?]}
04:20:38 -!- kipple has quit (Read error: 110 (Connection timed out)).
04:21:05 <GregorR> G!{(Hsh)[(c__)(_v)V!h(_v)n.?=h*(Hshe)!][(ln)(_a)1=,/(_a)<0>^\<1>][l(_a)A!(_s)S!(_v)V!(_t)$(_m)1=,ch*=(_f)c(gk).?(_m)*(_s)e.?(_t)(ln).?=/(_f)(_add)c(gn).?<0>(_a)e.?=/(_add)(_add)<0>=(_w)(_v)n.?=(_w)*(Hshe)!(_w)*c(sn).?\cc(gn).?=(_f)c(gk).?(_m)*(_s)e.?(_t)(ln).?=\][g(_t)$(_w)1=,(_w)*(_t)l.?c*(gv).?][s(_t)$(_w)2=(_v)1=,,(_w)*(_t)l.?(_v)*c*(sv).?]}
04:21:11 <GregorR> G!{M[m(_o)O!(_h)(Hsh)!"A""B"(_h)s.?"A"(_h)g.?(_o)o.?]}
04:21:31 <GregorR> G!{M[m(_o)O!(_h)(Hsh)!"A""B"(_h)s.?"C""D"(_h)s.?"E""F"(_h)s.?"C"(_h)g.?(_o)o.?]}
04:21:40 <GregorR> G!{M[m(_o)O!(_h)(Hsh)!"A""B"(_h)s.?"C""D"(_h)s.?"E""F"(_h)s.?"E"(_h)g.?(_o)o.?]}
04:21:44 <GregorR> G!{M[m(_o)O!(_h)(Hsh)!"A""B"(_h)s.?"C""D"(_h)s.?"E""F"(_h)s.?"A"(_h)g.?(_o)o.?]}
04:23:21 <GregorR> G!{(Hsh)[(c__)(_v)V!h(_v)n.?=h*(Hshe)!][(ln)(_a)1=,/(_a)<0>^\<1>][l(_a)A!(_s)S!(_v)V!(_t)$(_m)1=,ch*=(_f)c*(gk).?(_m)*(_s)e.?(_t)(ln).?=/(_f)(_add)c*(gn).?<0>(_a)e.?=/(_add)(_add)<0>=(_w)(_v)n.?=(_w)*(Hshe)!(_w)*c*(sn).?\cc*(gn).?=(_f)c*(gk).?(_m)*(_s)e.?(_t)(ln).?=\][g(_t)$(_w)1=,(_w)*(_t)l.?c*(gv).?][s(_t)$(_w)2=(_v)1=,,(_w)*(_t)l.?(_v)*c*(sv).?]}
04:23:28 <GregorR> G!{M[m(_o)O!(_h)(Hsh)!"A""B"(_h)s.?"C""D"(_h)s.?"E""F"(_h)s.?"A"(_h)g.?(_o)o.?]}
04:23:42 <calamari> F!"G!{M[moO!"34,"BF!++++++++++++++[>+++>+++++>+++>++>+++++++<<<<<-]>>-.>>+++++.>.++++.<-.+++++++++++...<+...>.....>-----------.<<<-------.>.........<.<+..>>.....<<...>--..>>++.>++.<<<++.<.+++.>.>.<<.>--.>...<<."34,"oo.?]}"
04:23:43 <falsebot> G!{M[moO!"BF!++++++++++++++[>+++>+++++>+++>++>+++++++<<<<<-]>>-.>>+++++.>.++++.<-.+++++++++++...<+...>.....>-----------.<<<-------.>.........<.<+..>>.....<<...>--..>>++.>++.<<<++.<.+++.>.>.<<.>--.>...<<."oo.?]}
04:23:48 <GlassBot> BF!++++++++++++++[>+++>+++++>+++>++>+++++++<<<<<-]>>-.>>+++++.>.++++.<-.+++++++++++...<+...>.....>-----------.<<<-------.>.........<.<+..>>.....<<...>--..>>++.>++.<<<++.<.+++.>.>.<<.>--.>...<<.
04:23:50 <BFBot> E!bf +++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++.
04:24:34 <GregorR> G!{M[m(_o)O!(_s)S!"A""A"(_s)e.?(_o)(on).?]}
04:25:04 <GregorR> G!{M[m(_o)O!"Hello?"(_o)o.?]}
04:25:31 <GregorR> G!{M[m(_o)O!(_s)S!"A""A"(_s)e.?" "(_o)o.?(_o)(on).?]}
04:25:44 <GregorR> G!{M[m(_o)O!(_s)S!"A""A"(_s)e.?"A"(_o)o.?(_o)(on).?]}
04:26:59 <GregorR> G!{S[l~S.l~][i~S.i~][(si)~S.si~][a~S.a~][e~S.e~][(ns)~S.ns~][(sn)~S.sn~]}
04:27:06 <GregorR> G!{M[m(_o)O!(_s)S!"A""A"(_s)e.?(_o)(on).?]}
04:27:13 <GregorR> G!{M[m(_o)O!(_h)(Hsh)!"A""B"(_h)s.?"C""D"(_h)s.?"E""F"(_h)s.?"A"(_h)g.?(_o)o.?]}
04:50:46 * calamari should learn how to make a bi-quine >=)
04:51:03 <calamari> I think I need to learn how to write a normal quine first
04:52:39 <GregorR> G!{(FE)[(fe)(_o)O!(_s)S!<34>(_s)(ns).?"F!"(_o)o.?0(_o)o.?"G!{M[m(_f)(FE)!(_f)(fe).?]}"(_o)o.?0(_o)o.?,]}
04:54:04 -!- GlassBot has quit (Read error: 104 (Connection reset by peer)).
04:55:53 -!- GlassBot has joined.
04:56:00 <calamari> G!{(FE)[(fe)(_o)O!(_s)S!<34>(_s)(ns).?"F!"(_o)o.?0(_o)o.?"G!{M[m(_f)(FE)!(_f)(fe).?]}"(_o)o.?0(_o)o.?,]}
04:56:01 <GregorR> Anyway calamari, you don't need a biquine.
04:56:15 <GregorR> That makes a class called FE (False Exploder)
04:56:18 <GregorR> You just need to call it from glass.
04:56:27 <GregorR> G!{M[m(_f)(FE)!(_f)(fe).?]}
04:56:28 <GlassBot> F!"G!{M[m(_f)(FE)!(_f)(fe).?]}"
04:56:30 <GlassBot> F!"G!{M[m(_f)(FE)!(_f)(fe).?]}"
04:56:32 <GlassBot> F!"G!{M[m(_f)(FE)!(_f)(fe).?]}"
04:56:34 <GlassBot> F!"G!{M[m(_f)(FE)!(_f)(fe).?]}"
04:56:36 <GlassBot> F!"G!{M[m(_f)(FE)!(_f)(fe).?]}"
04:56:37 <GregorR> G!{M[m(_o)O!"^PART #esoteric"(_o)o.?]}
04:56:38 -!- GlassBot has left (?).
04:56:55 -!- GlassBot has joined.
04:57:48 <calamari> F!["'[,34,$!34,'],!"]'[,34,$!34,'],!
04:57:48 <falsebot> ["'[,34,$!34,'],!"]'[,34,$!34,'],!
04:58:25 <calamari> F!"F!"["'[,34,$!34,'],!"]'[,34,$!34,'],!
04:58:25 <falsebot> F!["'[,34,$!34,'],!"]'[,34,$!34,'],!
04:58:36 <calamari> I don't really understand how quines work
04:59:27 <calamari> I don't think it'll work for falsebot.. doesn't notice it's own output there
04:59:28 <GregorR> Usually, a quine contains two segments, a "beginning" and an "end". The beginning and end are both stored in strings, so that they may be brought up without actually putting them into the file.
05:00:00 <GregorR> Therefore, you can cause it to output the beginning, a quotation mark, the beginning again, another quotation mark, etc, while only having the beginning code in the file twice.
05:00:16 <GregorR> G!{M[m(_s)S!(_o)O!<34>(_s)(ns).?"{M[m(_s)S!(_o)O!<34>(_s)(ns).?""1(_o)o.?2(_o)o.?1(_o)o.?2(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}"1(_o)o.?2(_o)o.?1(_o)o.?2(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}
05:00:18 <GlassBot> {M[m(_s)S!(_o)O!<34>(_s)(ns).?"{M[m(_s)S!(_o)O!<34>(_s)(ns).?""1(_o)o.?2(_o)o.?1(_o)o.?2(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}"1(_o)o.?2(_o)o.?1(_o)o.?2(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}
05:02:10 <calamari> G!{M[m(_s)S!(_o)O!<34>(_s)(ns).?"G!{M[m(_s)S!(_o)O!<34>(_s)(ns).?""1(_o)o.?2(_o)o.?1(_o)o.?2(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}"1(_o)o.?2(_o)o.?1(_o)o.?2(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}
05:02:12 <GlassBot> G!{M[m(_s)S!(_o)O!<34>(_s)(ns).?"G!{M[m(_s)S!(_o)O!<34>(_s)(ns).?""1(_o)o.?2(_o)o.?1(_o)o.?2(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}"1(_o)o.?2(_o)o.?1(_o)o.?2(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}
05:02:26 <GregorR> No, GlassBot does not respond to itself either ;)
05:05:25 <calamari> E!bf +++++++++++[>++++++>+++>++++>++++>++++<<<<<-]>+++.>.<+++++++++++++++++++++++++++++.++++.>-.>-.>-...>-....<...<.<+++++++++++.<-----------.-----------------------------.>.>.>..<<..>...<<.>>.<.......>>+++++++++++++++++..<++.>+++++++++++++++++++++++++++++++++.<<<.>>.+.<<.>++...>.<<--.>.>.>>.<<.
05:05:27 <EsoBot> E!bf +++++++++++++[>+++++++++>++++++++<<-]>-.>---.<-.+.
05:05:57 <calamari> hmm guess EsoBot doesn't either
05:06:25 <calamari> E!bf +++++++++++++[>+++++++++>++++++++<<-]>-.>---.<-.+.
05:09:21 <GregorR> Not that it could possibly have been helpful :P
05:10:10 <GregorR> If you knew Glass, the Glass quine would be the perfect quine-by-dissection example :P
05:10:44 <calamari> I see a little bit going on there
05:11:27 <calamari> but glass makes my eyes glaze over when looking at it.. which is a sign of a sucessful esolang ;)
05:22:20 <GregorR> World's worst C quine (just wrote it):
05:22:28 <GregorR> char(X) int main(){char a[]="#include <stdio.h> #define A(X) fputs(X stdout) #define B(X) pu char(X) int main(){char a[]=",b[]=";a[18]=10;a[39]=10;a[63]=10;A(a);a[18]=32;a[39]=32;a[63]=32;B(34);A(a);B(34);B(44);B(98);B(91);B(93);B(61);B(34);A(b);B(34);A(b);}";a[18]=10;a[39]=10;a[63]=10;A(a);a[18]=32;a[39]=32;a[63]=32;B(34);A(a);B(34);B(44);B(98);B(91);B(93);B(61);B(34);A(b);B(34);A(b);}
05:22:37 <GregorR> Woah, that didn't paste right.
05:23:15 <GregorR> #define A(X) fputs(X,stdout)
05:23:20 <GregorR> int main(){char a[]="#include <stdio.h> #define A(X) fputs(X,stdout) #define B(X) putchar(X) int main(){char a[]=",b[]=";a[18]=10;a[47]=10;a[71]=10;A(a);a[18]=32;a[47]=32;a[71]=32;B(34);A(a);B(34);B(44);B(98);B(91);B(93);B(61);B(34);A(b);B(34);A(b);}";a[18]=10;a[47]=10;a[71]=10;A(a);a[18]=32;a[47]=32;a[71]=32;B(34);A(a);B(34);B(44);B(98);B(91);B(93);B(61);B(34);A(b);B(34);A(b);}
05:47:43 -!- Robdgreat has left (?).
05:47:58 -!- Robdgreat has joined.
05:49:50 <GregorR> I know, being out of #esoteric is scary.
06:00:02 <GregorR> G!{(Hshe)[(c__)k"a"=v<0>=n<0>=][(gk)k*][(sk)k1=,][(gv)v*][(sv)v1=,][(gn)n*][(sn)n1=,]}
06:00:08 <GregorR> G!{(Hsh)[(c__)(_v)V!h(_v)n.?=h*(Hshe)!][(ln)(_a)1=,/(_a)<0>^\<1>][l(_a)A!(_s)S!(_o)O!(_v)V!(_t)$(_m)1=,ch*=(_f)c*(gk).?(_m)*(_s)e.?(_t)(ln).?=/(_f)(_add)c*(gn).?<0>(_a)e.?=/(_add)(_add)<0>=(_w)(_v)n.?=(_w)*(Hshe)!(_m)*(_w)*(sk).?(_w)*c*(sn).?\cc*(gn).?=(_f)c*(gk).?(_m)*(_s)e.?(_t)(ln).?=\][g(_t)$(_w)1=,(_w)*(_t)l.?c*(gv).?][s(_t)$(_w)2=(_v)1=,,(_w)*(_t)l.?(_v)*c*(sv).?]}
06:00:32 <GregorR> G!{M[m(_o)O!(_h)(Hsh)!"A""B"(_h)s.?"C""D"(_h)s.?"E""F"(_h)s.?"E"(_h)g.?(_o)o.?]}
06:01:13 <GregorR> G!{(Hsh)[(c__)(_v)V!h(_v)n.?=h*(Hshe)!][(ln)(_a)1=,/(_a)<0>^\<1>][l(_a)A!(_s)S!(_v)V!(_t)$(_m)1=,ch*=(_f)c*(gk).?(_m)*(_s)e.?(_t)(ln).?=/(_f)(_add)c*(gn).?<0>(_a)e.?=/(_add)(_add)<0>=(_w)(_v)n.?=(_w)*(Hshe)!(_m)*(_w)*(sk).?(_w)*c*(sn).?\cc*(gn).?=(_f)c*(gk).?(_m)*(_s)e.?(_t)(ln).?=\][g(_t)$(_w)1=,(_w)*(_t)l.?c*(gv).?][s(_t)$(_w)2=(_v)1=,,(_w)*(_t)l.?(_v)*c*(sv).?]}
06:01:46 -!- GlassBot has quit (Read error: 104 (Connection reset by peer)).
06:02:52 <GregorR> Forgot to do my last upgrade :P
06:03:07 -!- GlassBot has joined.
06:03:17 <GregorR> G!{(Hsh)[(c__)(_v)V!h(_v)n.?=h*(Hshe)!][(ln)(_a)1=,/(_a)<0>^\<1>][l(_a)A!(_s)S!(_v)V!(_t)$(_m)1=,ch*=(_f)c*(gk).?(_m)*(_s)e.?(_t)(ln).?=/(_f)(_add)c*(gn).?<0>(_a)e.?=/(_add)(_add)<0>=(_w)(_v)n.?=(_w)*(Hshe)!(_m)*(_w)*(sk).?(_w)*c*(sn).?\cc*(gn).?=(_f)c*(gk).?(_m)*(_s)e.?(_t)(ln).?=\][g(_t)$(_w)1=,(_w)*(_t)l.?c*(gv).?][s(_t)$(_w)2=(_v)1=,,(_w)*(_t)l.?(_v)*c*(sv).?]}
06:03:31 <GregorR> G!{M[m(_o)O!(_h)(Hsh)!"A""B"(_h)s.?"C""D"(_h)s.?"E""F"(_h)s.?"E"(_h)g.?(_o)o.?]}
06:03:37 <GregorR> G!{M[m(_o)O!(_h)(Hsh)!"A""B"(_h)s.?"C""D"(_h)s.?"E""F"(_h)s.?"A"(_h)g.?(_o)o.?]}
06:03:45 <GregorR> G!{M[m(_o)O!(_h)(Hsh)!"A""B"(_h)s.?"C""D"(_h)s.?"E""F"(_h)s.?"B"(_h)g.?(_o)o.?]}
06:03:49 <GregorR> G!{M[m(_o)O!(_h)(Hsh)!"A""B"(_h)s.?"C""D"(_h)s.?"E""F"(_h)s.?"C"(_h)g.?(_o)o.?]}
06:05:49 <GregorR> And I'm not just saying that because I wrote it ;)
06:06:01 <lament> but much too verbose :P
06:06:44 <GregorR> It's not actually very verbose, it's just that there's an overhead that goes on /EVERY/ program.
06:08:08 <GregorR> Well, that and, simple math requires the instantiation of an object :P
06:09:03 <lament> but it's still something like a = 1 + 2
06:09:24 <GregorR> Yes, but Python isn't designed to be idiotic ;)
06:09:39 <lament> are you sure of that? :)
06:09:57 <lament> i guess Glass is just better designed
06:10:25 <GregorR> It's OO, has a main stack, uses postfix notation, and extensively uses pointers - now THAT'S idiotic!
07:56:16 -!- calamari has quit ("Leaving").
07:56:41 -!- EsoBot has quit (Remote closed the connection).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:21:29 -!- marcan has quit ("Lost terminal").
08:26:37 -!- marcan has joined.
10:57:55 -!- jix has joined.
11:04:57 <CXI> esobot disappeared, I think
12:06:11 <jix> GregorR: ping
12:25:35 -!- kipple has joined.
13:05:15 <jix> i wrote a glass syntax colorer for my favorite text editor
13:06:07 <kipple> let me guess? SubEthaEdit?
13:06:22 <jix> textmate > subethaedit
13:06:45 <jix> http://macromates.com/
13:07:21 <jix> making syntax colorings for textmate is easy for subethaedit it is hard
14:04:57 <jix> there is no way to swap the top elements of the stack in glass
14:06:42 <jix> GregorR: ping!
14:08:28 <jix> missed 0-9
16:55:48 -!- kipple has quit (Read error: 104 (Connection reset by peer)).
16:56:44 -!- kipple has joined.
17:18:48 -!- klutzh has joined.
17:36:30 -!- mtve has quit (Read error: 110 (Connection timed out)).
18:47:11 <GregorR> No, there is no way to explicitly swap the two topmost elements, however, as you saw, you can raise the second.
18:47:37 <jix> a print stack debug call would be usefull
18:48:12 <GregorR> Here's a hint for writing Glass code: make every line a 0-stack-change element. The code is less efficient, but wildly more understandable.
18:48:41 <jix> i use indention to count stack items
18:48:51 <GregorR> Hmm, that's an interesting idea.
18:49:14 <GregorR> That actually makes a whole lot o' sense...
18:51:30 <jix> i'm working on a bf interpreter
18:51:44 <jix> i'm done with the tape class
18:52:26 <jix> is M.c__ called on startup?
18:54:49 <GregorR> M is funky in just about every way :P
18:55:21 <jix> i use OO! to avoid initializing O a few hundred times ;)
18:56:34 <GregorR> If you do that online I'll kill you.
18:57:36 <jix> does glassbot remember global vars?
18:57:56 <GregorR> But more importantly, it remembers classes, and you will have wiped out one ;)
18:58:21 <GregorR> It's fine to use global vars as instantiation of classes, but you shouldn't use /that/ one XD
18:58:33 <jix> hmm never thought that that wipes out the class
18:58:57 <jix> maybe you should fix glassbot to reset internals with every call
18:59:21 <GregorR> Yeah, I definitely should. I've considered it a few times, but haven't gotten off my lazy arse and done it ;)
18:59:34 <jix> G!{(TapeItem)[(c__)(hn)<1>=(hp)<1>=v<0>=t$][sv1=,][gv*][n(_t)(hn)*=/(_t)(nv)(TapeItem)!t*(nv)(sp).?(hn)<0>=(_t)<0>=\(nv)*][p(_t)(hp)*=/(_t)(pv)(TapeItem)!t*(pv)(sn).?(hp)<0>=(_t)<0>=\(pv)*][(sn)(nv)1=,(hn)<0>=][(sp)(pv)1=,(hp)<0>=]}
18:59:41 <jix> G!{(Tape)[(c__)t(TapeItem)!][nttn.?=][pttp.?=][gtg.?][sts.?]}
18:59:51 <jix> glassbot knows tape now
19:00:57 <jix> api: Tape.n => moves to next item Tape.p moves to previous item Tape.g get value Tape.s set value
19:01:26 <GregorR> G!{M[m(_d)(Debug)!(_d)(cl).?]}
19:01:29 <GlassBot> A Arr Arre BF Debug Emote F Fib Hsh Hshe I L LameQuine M O Rand S Tape TapeItem V
19:02:00 <jix> G!{M[m~Debug.cl~]}
19:02:00 <GregorR> G!{M[m(_o)O!"^QUIT :Upgrades!"(_o)o.?]}
19:02:01 <GlassBot> A Arr Arre BF Debug Emote F Fib Hsh Hshe I L LameQuine M O Rand S Tape TapeItem V
19:02:01 -!- GlassBot has quit ("Upgrades!").
19:02:13 <GregorR> lol, yes, you can cheat and use builtins like that ;)
19:02:26 <GregorR> But that's implementation-specific, not part of the spec.
19:02:45 <jix> but Debug is implementation specific too
19:03:10 -!- GlassBot has joined.
19:03:32 <GregorR> G!{M[m(_d)(Debug)!"A"<5>aM*(_d)s.?]}
19:04:21 <jix> G!{M[m"^PRIVMSG #esoteric test"~O.o~]}
19:05:01 <jix> G!{M[m~Debug.cl~]}
19:05:04 <GlassBot> A Arr Arre BF Debug Emote F Fib Hsh Hshe I L LameQuine M O Rand S Tape TapeItem V
19:05:17 <jix> it still knows Tape?
19:05:24 <GregorR> Yeah, the cache is stored on disk.
19:05:45 <GregorR> The only way you could make it forget tape is G!{(Tape)}
19:06:06 <jix> are internals frozen know?
19:06:25 <jix> G!OO!"Test"Oo.?
19:06:37 <GregorR> That won't do much outside of a class XD
19:06:41 <jix> G!{M[mOO!"Test"Oo.?]}
19:06:56 <jix> mOO! << how cool
19:07:38 <GregorR> BTW, here's my "Array" (LLL) class:
19:10:09 <jix> is the new version with stack printing online?
19:12:13 <GregorR> I just found this link: http://abstractfactory.blogspot.com/2005/10/only-debate-on-intelligent-design-that.html
19:16:16 <GregorR> Grr, I'm having upload problems >_<
19:19:23 <GregorR> OK, glass-0.10.tar.bz2 is up.
19:19:36 <CXI> this looks interesting: http://firefoxit.mozdev.org/
19:24:37 <CXI> doesn't look like it's stable yet - probably worth waiting to see if it goes anywhere
19:25:25 <GregorR> Proof that my professor is an idiot: We're making a stupid e-library, and the search page has multiple fields ("title", "author", etc). By his specification, they are OR fields.
19:25:39 <GregorR> By professor I mean teacher, I don't think he's a professor :P
19:25:55 <GregorR> And somebody emailed the mailing list saying "This makes no sense, shouldn't this be AND?"
19:26:07 <GregorR> His response: "No, OR. That way, people can find more books."
19:26:20 <CXI> that's laughably stupid
19:26:35 <GregorR> Yes. Yes it is. But when you actually have to implement the thing it just hurts.
19:28:01 <CXI> this is neat...
19:28:11 <CXI> I've been trying to find a decent way of getting a hold of random interesting programs
19:28:40 <CXI> there are a bunch of developers with stuff that they just make 'cause it's cool and throw on some webspace somewhere, and it's really hard to find
19:30:54 <CXI> http://del.icio.us/tag/software+cool
19:30:59 <CXI> this has shown up some neat stuff
19:32:17 <CXI> never really played around with del.icio.us much before
19:32:31 <CXI> the whole "web 2.0" thing strikes me as ".com bubble 2.0"
19:35:38 -!- Keymaker has joined.
19:35:40 <GregorR> I agree, it's very nothing.
19:36:46 <Keymaker> i don't know what to use, is the sceql file extension "sq" or not!!
19:37:05 <Keymaker> graue's reply at esowiki isn't very clear
19:37:21 <Keymaker> "I don't know. Maybe .sq, unless that's already used for something else."
19:37:58 <kipple> just use .sql to avoid any confusion
19:40:40 <CXI> er, one thing about sql
19:40:53 <CXI> isn't that standard for plaintext sql query files?
19:45:32 <Keymaker> mmh.. the language name is sceql.. i'm sure there can be something better than 'sq'..
19:47:24 <Keymaker> by the way, does one print '\' in by printing "\\" or something?
19:48:21 <fizzie> I'd say that in C you print \, but to write a \ in a character/string literal you need \\.
19:49:53 <fizzie> No, "\\". But it's passed as the string containing a single \ to printf.
19:50:23 <GregorR> In Glass you make a number with the ASCII value then do S.ns :)
19:50:35 <fizzie> \ ought to be the *printf escape character in printf too, that way we'd get "\\\\" more often.
19:50:48 <kipple> hehe. of course .sql is the standard for SQL scripts. but why should you let that stop you?
19:51:41 <fizzie> What I don't like is the fact that .pl is the "standard" extension for both Perl and Prolog.
19:52:30 <kipple> well the number of possible extensions with max 3 chars, is pretty limited, so some overlap is bound to happen
19:52:47 <kipple> unless people can get over this aversion to extensions with more than 3 chars
19:52:59 <fizzie> Hey, .java is four characters. :p
19:53:18 <fizzie> ".jaa" or ".jav" or ".jva" would sound: really stupid.
19:53:53 <fizzie> Was that compiled into .cls files?
19:54:13 <kipple> I considered using .kipple as the extension for Kipple, but I was lazy and .k is much faster to type ;)
19:54:27 <kipple> fizzie: not sure. perhaps .cla?
19:54:27 <GregorR> I use .glass for Glass *shrugs*
19:55:10 <fizzie> I never know what to use for C++.
19:55:25 <kipple> is there an official extension for TMMLPTEALPAITAFNFAL ? :D
19:55:31 <fizzie> There's .C, .cc, .cpp, .c++, .cc and probably even more.
19:56:35 <fizzie> How did I manage not to see the first .cc. Strange.
19:56:37 <GregorR> I use .cc. .cpp comes from VS and is therefore evil, .c++ is nice but non-portable.
19:56:43 <kipple> LOL. finally someone who's done it properly (guess what the TMMLPTEALPAITAFNFAL extension is?)
19:57:20 <kipple> yes. except it's in uppercase
19:57:37 <fizzie> Oh. It looks more silly in lowercase, imho.
20:08:19 <jix> mac os x uses many .long_extensions
20:14:00 <Keymaker> anyone up for 99 bottles of cold beer?
20:14:02 <Keymaker> http://koti.mbnet.fi/yiap/other/beer.sceql
20:20:34 <jix> G!{M[m(_s)S!"test"(_s)si.?~Debug.s]}
20:20:57 <jix> G!{M[m(_s)S!"test"(_s)si.?~Debug.s~]}
20:21:31 <jix> G!{M[m(_s)S!"test"(_s)si.?~Debug.s~]}
20:21:52 <jix> G!{M[m<1><2><3>~Debug.s~]}
20:25:39 * GregorR is a bit confused as per what you're trying to do ...
20:25:56 <GregorR> (_s)si.? makes no sense ...
20:26:18 <jix> S.si: stack[-2][stack[-1]] = stack[0], pop, pop
20:26:26 <jix> yes makes no sense
20:26:39 <jix> G!{M[m(_s)S!"test"(_s)(si).?~Debug.s~]}
20:26:49 <jix> ok but makes no sense too
20:27:09 <GregorR> G!{M[m(_s)S!"Test"<1>"f"(_s)(si).?~Debug.s~]}
20:27:24 <jix> a remove first character of a string would be cool
20:27:40 <jix> or remove the first n characters of a string
20:27:53 <jix> or split the string at position n
20:28:10 <GregorR> Hmm, I think I'll make a split, that makes sense.
20:28:23 <GregorR> You could get the effect of cutting off the first with a split.
20:28:40 * GregorR tries to decide whether that breaks his minimalism concept.
20:28:50 <jix> that's why i used OR instead of AND
20:28:52 <GregorR> I'm trying to only make builtin classes have functions that you can't do otherwise ...
20:29:33 <jix> then why did you added mul and div and mod and le and ge...
20:30:10 <GregorR> mul/div: It uses floating point, you can't do FP muls and divs simply by repeating adds.
20:30:25 <GregorR> le, ge: Figured I should complete the set :P
20:30:39 <GregorR> OK, point taken, I'll add split.
20:31:23 <GregorR> I'm calling it d as in divide.
20:31:27 <jix> G!M{[m~I.c~~Debug.s~]}
20:31:42 <jix> G!{M[m~I.c~~Debug.s~]}
20:31:59 <GregorR> Input doesn't do anything on IRC :P
20:32:07 <jix> pushes I.c a string or a number?
20:32:34 -!- mtve has joined.
20:34:57 <GregorR> G!{M[m(_o)O!"^QUIT :Upgrades!"(_o)o.?]}
20:34:58 -!- GlassBot has quit ("Upgrades!").
20:35:40 -!- GlassBot has joined.
20:35:43 <GregorR> G!{M[m(_s)S!"Hello World!"<6>(_s)d.?~Debug.s~]}
20:36:28 -!- Keymaker has left (?).
20:36:34 <GregorR> G!{M[m(_o)O!"^QUIT :Upgrades!"(_o)o.?]}
20:36:35 -!- GlassBot has quit (Client Quit).
20:37:20 -!- GlassBot has joined.
20:37:26 <GregorR> G!{M[m(_s)S!"Hello World!"<6>(_s)d.?~Debug.s~]}
20:37:46 <GregorR> G!{M[m(_s)S!"Hello World!"<6>(_s)d.?(_s)a.?~Debug.s~]}
20:37:46 <jix> hey cool (the order i need for my code)
20:37:58 <GregorR> One sec while I package it up ...
20:39:03 <jix> i extended Tape with gp and sp (get and set position) for storing the tape position (as TapeItems ;) )
20:39:19 <GregorR> Feel free to update GlassBot's.
20:39:40 <GregorR> FYI, if it's too long to paste in IRC, you can do G!Uhttp://....some.URL.goes.here/etc
20:39:40 <jix> G!{(Tape)[(c__)t(TapeItem)!][nttn.?=][pttp.?=][gtg.?][sts.?][(gp)t*][(sp)t1=,]}
20:40:28 <GregorR> OK, glass-0.11.tar.bz2 is up
20:40:54 <GregorR> What do you think of Glass btw? :)
20:41:04 <jix> G? as an alias for G!{M[m...]} would be cool too
20:41:13 <jix> GregorR: excellent esolang!
20:42:18 <GregorR> G!{M[m(_s)S!(_o)O!<34>(_s)(ns).?"{M[m(_s)S!(_o)O!<34>(_s)(ns).?""1(_o)o.?2(_o)o.?1(_o)o.?2(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}"1(_o)o.?2(_o)o.?1(_o)o.?2(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}
20:42:20 <GlassBot> {M[m(_s)S!(_o)O!<34>(_s)(ns).?"{M[m(_s)S!(_o)O!<34>(_s)(ns).?""1(_o)o.?2(_o)o.?1(_o)o.?2(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}"1(_o)o.?2(_o)o.?1(_o)o.?2(_o)o.?2(_o)o.?0(_o)o.?2(_o)o.?0(_o)o.?]}
20:43:11 <GlassBot> A Arr Arre BF Debug Emote F Fib Hsh Hshe I L LameQuine M O Rand S Tape TapeItem V
20:43:32 <GlassBot> (_a)2=(_b)1=,,/(_a)/(_b)<1>^\<0>^\<0>
20:44:13 <GregorR> G!{M[m(_o)O!"^JOIN #glassbot"(_o)o.?]}
20:44:34 * GregorR goes back to his Dvorak training.
20:44:48 <jix> i don't like dvorak
20:45:05 <jix> i'm fast enough with my de keyboard...
20:45:11 <jix> no need for dvorak
20:45:35 <GregorR> This is just what I do for my own perverse entertainment.
20:47:42 <GregorR> I'm also learning fitaly on my Tablet PC.
20:48:04 <jix> is that cool or is that cool: http://img409.imageshack.us/img409/5760/bild90uf.png
20:49:18 * GregorR bows down before jix's 31337 colorization prowess.
20:49:48 <jix> with folding!
20:51:47 <jix> http://rafb.net/paste/results/QBo5Gp24.html here is the code for anyone who uses textmate
20:52:21 -!- calamari has joined.
20:52:48 <jix> moin calamari
20:52:49 <jix> G!{M[m"LameQuine"~Debug.fl~]}
20:53:17 <jix> G!{M[ml(LameQuine)!l.(lq).?]}
20:53:26 <jix> G!{M[ml(LameQuine)!l(lq).?]}
20:53:31 <GregorR> LameQuine.lq uses debug to output the M class :P
20:53:55 <GregorR> G!{M[m"LameQuine""lq"~Debug.fc~]}
20:53:56 <GlassBot> (_d)(Debug)!(_o)O!"{M[m"(_o)o.?"M""m"(_d)(fc).?"]}"(_o)o.?
20:54:08 <jix> G!{M[ml(LameQuine)!l(lq).?"\n"]}
20:54:23 <jix> lame quine is really lame ;)
20:54:54 <GregorR> G!{M[m(_t)$(_t)b.?][b(_l)(LameQuine)!(_l)(lq).?]}
20:57:37 -!- EsoBot has joined.
20:57:51 <EsoBot> Commands: bf, cat, help, kill, ls, ps, quit, unnecessary.
20:58:04 <jix> E!unnecessary
20:58:05 <EsoBot> Program executed perfectly right!
20:58:14 <EsoBot> Bad or inaccessible URL `http://localhost/ls/dirs'.
20:58:44 <GregorR> E!unnecessary http://www.google.com/
20:58:46 <EsoBot> CRITICAL ERROR: The file exists!
20:59:13 <GregorR> E!unnecessary http://www.google.com/blerflnerfl
20:59:13 <jix> E!unnecessary http://www.google.com/blsdfsdf
20:59:14 <EsoBot> Bad or inaccessible URL `'.
20:59:15 <EsoBot> Bad or inaccessible URL `'.
20:59:15 <EsoBot> Program executed perfectly right!
20:59:16 <EsoBot> Program executed perfectly right!
20:59:52 <calamari> looks like a small output bug there
21:02:30 <jix> E!kill calamari
21:02:31 <EsoBot> No such process `calamari'.
21:02:49 <GregorR> G!{(EE)[e(_o)O!"E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++."(_o)o.?]}
21:03:00 <GregorR> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:03:03 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:03:06 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:03:09 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:03:12 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:03:15 <GregorR> G!{M[m(_o)O!"^PART #esoteric"(_o)o.?]}
21:03:15 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:03:16 -!- GlassBot has left (?).
21:03:30 -!- GlassBot has joined.
21:03:53 <calamari> G!{(EE)[e(_o)O!"E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++."(_o)o.?]}
21:04:07 <calamari> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:04:21 <calamari> G!{(EE)[e(_o)O!"E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++."(_o)o.?]}
21:04:24 <calamari> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:04:26 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:04:29 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:04:31 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:05:33 <jix> glass fireing false and eso and BOTH fire back glass => exponential!!!!!
21:05:49 -!- graue has joined.
21:05:53 <GregorR> G!{(EE)[e(_o)O!"E!bf +++++++++++++++[>++++++++>+++++>++>++++++<<<<-]>>-----.>+++.+.<+.>-.<<+++.>++++++.>>+.++++++++++++++++++.--------.<+++++++.<--------..>+.--------.>..<+++++++++++++.<------.>>--------.<<<++.>>------------."(_o)o.?]}
21:06:01 <GregorR> O good, graue gets to spectate on this disaster!
21:06:01 <calamari> but can glass output more than one line?
21:06:13 <graue> what's the disaster?
21:06:16 <jix> false can!
21:06:17 <GregorR> E!bf +++++++++++++++[>++++++++>+++++>++>++++++<<<<-]>>-----.>+++.+.<+.>-.<<+++.>++++++.>>+.++++++++++++++++++.--------.<+++++++.<--------..>+.--------.>..<+++++++++++++.<------.>>--------.<<<++.>>------------.
21:06:18 <EsoBot> F!"G!{M[me(EE)!ee.?]}"
21:06:20 <GlassBot> E!bf +++++++++++++++[>++++++++>+++++>++>++++++<<<<-]>>-----.>+++.+.<+.>-.<<+++.>++++++.>>+.++++++++++++++++++.--------.<+++++++.<--------..>+.--------.>..<+++++++++++++.<------.>>--------.<<<++.>>------------.
21:06:21 <EsoBot> F!"G!{M[me(EE)!ee.?]}"
21:06:23 <GlassBot> E!bf +++++++++++++++[>++++++++>+++++>++>++++++<<<<-]>>-----.>+++.+.<+.>-.<<+++.>++++++.>>+.++++++++++++++++++.--------.<+++++++.<--------..>+.--------.>..<+++++++++++++.<------.>>--------.<<<++.>>------------.
21:06:24 <EsoBot> F!"G!{M[me(EE)!ee.?]}"
21:06:27 <GlassBot> E!bf +++++++++++++++[>++++++++>+++++>++>++++++<<<<-]>>-----.>+++.+.<+.>-.<<+++.>++++++.>>+.++++++++++++++++++.--------.<+++++++.<--------..>+.--------.>..<+++++++++++++.<------.>>--------.<<<++.>>------------.
21:06:28 <EsoBot> F!"G!{M[me(EE)!ee.?]}"
21:06:39 <GregorR> Glass can in shell mode, but not in IRC mode.
21:07:25 <GregorR> Anybody who can actually write a true polyglot quine between the three deserves to flood the channel in an unstoppable way :P
21:07:38 <GregorR> They can enjoy that honor.
21:08:38 <graue> I read that as "They can enjoy that horror."
21:09:48 <calamari> E!bf ++++++++++++++[>+++++>++>+++++++++>+++>+++++<<<<<-]>.>+++++.+.<+.>-.>---.<<++++++.++++++++++++++.>>--------------.--------.>--.>-..<+.<<.>..>+++++.>------.<<<<++.>>++++++++++++++++++++++++.<+.
21:09:49 <EsoBot> F!"G!{M[me(EE)!ee.?]}"
21:10:00 <GregorR> Sorry calamari, I took out the Glass class :P
21:10:45 <calamari> I used textgen -t 5 I think it's a couple bytes shorter
21:10:56 <calamari> you're using textgen too, I assume?
21:11:05 <GregorR> But I just grab one of the first few, I don't wait XD
21:11:12 <GregorR> If it's short enough, it's good by me.
21:13:41 <calamari> wheee.. the 4 byte just pulled ahead again
21:14:31 <GregorR> What does that actually do?
21:14:48 <calamari> increases the number of memory cells used
21:15:10 <GregorR> And why does it think that this is good: +++++++++++[>++++++>++++++++++>>>>>>>><<<<<<<<<<-]>.>--.-----------.+++++++.
21:15:29 <GregorR> BF! +++++++++++[>++++++>++++++++++>>>>>>>><<<<<<<<<<-]>.>--.-----------.+++++++.
21:15:38 <calamari> it uses the number of cells you tell it to use
21:16:05 <graue> we should have a Great Esoteric Programming Language Shootout
21:16:06 <CXI> writing a cms for no reason
21:16:25 <GregorR> Pfft, Glass would so win ;)
21:16:31 <graue> scoring criteria could include the "compression ratio" achieved by the shortest known 99 bottles of beer program
21:16:40 <CXI> see, I have a theory about that
21:16:40 <calamari> I'd love to see an algorithmic way to produce the shortest possible bf code for a particular text
21:16:53 <CXI> I'd love to make a program like bf but with higher level constructs
21:16:59 <CXI> er, s/program/langauge/
21:17:00 <calamari> E!bf ++++++++++++++[>+++++>+++>++++++++>++>+++++>+++++++++<<<<<<-]>.>>>+++++.+.>+.<-.>>---.<++++++.++++++++++++++.<<---.--------.<--.<-..>+.>>.<..<+++++.<------.>>>>++.>++.<<+.
21:17:01 <EsoBot> F!"G!{M[me(EE)!ee.?]}"
21:17:08 <CXI> as in, one designed to give you the absolute shortest way to solve most problems
21:17:15 <CXI> (perl on steroids)
21:17:22 <graue> isn't perl already on steroids?
21:17:32 <CXI> not by comparison to what I want it to do
21:17:48 <CXI> imagine, if you will, a static dictionary file for word lookups as part of the standard library
21:17:58 <jix> F!"G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}"
21:17:59 <falsebot> G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}
21:18:00 <GlassBot> F!"G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}"
21:18:00 <falsebot> G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}
21:18:02 <GlassBot> F!"G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}"
21:18:02 <falsebot> G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}
21:18:04 <GlassBot> F!"G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}"
21:18:04 <falsebot> G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}
21:18:06 <GlassBot> F!"G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}"
21:18:06 <falsebot> G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}
21:18:07 <GlassBot> F!"G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}"
21:18:08 <falsebot> G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}
21:18:10 <GlassBot> F!"G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}"
21:18:10 <falsebot> G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}
21:18:12 <GlassBot> F!"G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}"
21:18:12 <falsebot> G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}
21:18:14 <GlassBot> F!"G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}"
21:18:15 <falsebot> G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}
21:18:15 <jix> GregorR: stop this!
21:18:16 <GlassBot> F!"G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}"
21:18:17 <falsebot> G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}
21:18:18 <GlassBot> F!"G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}"
21:18:19 <falsebot> G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}
21:18:20 <GregorR> G!{M[m(_o)O!"^PART #esoteric"(_o)o.?]}
21:18:21 <GlassBot> F!"G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}"
21:18:22 <falsebot> G!{M[m<70>~S.ns~~O.o~<33>~S.ns~~O.o~<34>~S.ns~~O.o~<71>~S.ns~~O.o~<33>~S.ns~~O.o~<123>~S.ns~~O.o~<77>~S.ns~~O.o~<91>~S.ns~~O.o~<109>~S.ns~~O.o~<77>~S.ns~<109>~S.ns~~Debug.fc~<93>~S.ns~~O.o~<125>~S.ns~~O.o~<34>~S.ns~~O.o~]}
21:18:23 -!- GlassBot has left (?).
21:18:41 <GregorR> Using the debug class is cheating ;)
21:18:54 <jix> but it is unstopable without bot admins
21:19:27 -!- GlassBot has joined.
21:20:32 <calamari> or you can implement an interpreter in bf ;)
21:23:03 -!- graue has quit.
21:23:34 <GregorR> {M[mt$oO!aA!b" bottles of beer"=w"on the wall!\n"=c<99>=/cc*o(on).?b*oo.?w*oo.?c*o(on).?b*oo.?"!"oo.?"Take one down and pass it around\n"oo.?cc*<1>as.?=c*o(on).?b*oo.?w*oo.?\]}
21:23:50 <GregorR> G!{M[mt$oO!aA!b" bottles of beer"=w"on the wall!\n"=c<99>=/cc*o(on).?b*oo.?w*oo.?c*o(on).?b*oo.?"!"oo.?"Take one down and pass it around\n"oo.?cc*<1>as.?=c*o(on).?b*oo.?w*oo.?\]}
21:23:51 <GlassBot> 99 bottles of beeron the wall! 99 bottles of beer!Take one down and pass it around 98 bottles of beeron the wall! 98 bottles of beeron the wall! 98 bottles of beer!Take one down and pass it around 97 bottles of beeron the wall! 97 bottles of beeron the wall! 97 bottles of beer!Take one down and pass it around 96 bottles of beeron the wall! 96 bottles of beeron the wall! 96 bottles of beer!T Flood!
21:23:59 <GregorR> G!{M[mt$oO!aA!b" bottles of beer"=w" on the wall!\n"=c<99>=/cc*o(on).?b*oo.?w*oo.?c*o(on).?b*oo.?"!"oo.?"Take one down and pass it around\n"oo.?cc*<1>as.?=c*o(on).?b*oo.?w*oo.?\]}
21:24:00 <GlassBot> 99 bottles of beer on the wall! 99 bottles of beer!Take one down and pass it around 98 bottles of beer on the wall! 98 bottles of beer on the wall! 98 bottles of beer!Take one down and pass it around 97 bottles of beer on the wall! 97 bottles of beer on the wall! 97 bottles of beer!Take one down and pass it around 96 bottles of beer on the wall! 96 bottles of beer on the wall! 96 bottles of Flood!
21:25:04 <EsoBot> bfi.b bottles.b factor.b helloum.b LostKng.b prime.b triangle.b
21:25:18 <jix> E!bf LostKng.b
21:25:35 <calamari> E!bf http://localhost/bf/LostKng.b
21:25:39 <EsoBot> (C) Jon Ripley 2004, 2005
21:25:40 <EsoBot> Brainfuck Edition v0.11
21:25:43 <EsoBot> To read the back-story enter '!'.
21:25:44 <EsoBot> For a list of commands enter '?'.
21:25:46 <EsoBot> Enable long room descriptions (Y/N) ?
21:26:10 <EsoBot> You are standing inside your ramshackle wooden hut. The squalor here has
21:26:11 <EsoBot> replaced the comfort and grandeur of your former royal palace. In one corner
21:26:12 <EsoBot> near the north door leading to your garden lies the pile of straw you use as
21:26:13 <EsoBot> a bed. Fixed in place by an unknown magic, next to a small table, is a wooden
21:26:14 <EsoBot> mockery of your former throne. The main door to the east leads outside to a
21:26:24 <EsoBot> a small wooden box of matches sitting on the table (2)
21:26:36 <calamari> haha yes yes will start the game over
21:26:42 <EsoBot> You scored 0 points out of a possible 100.
21:26:43 <EsoBot> You have earned the rank of Amateur.
21:26:51 <EsoBot> (C) Jon Ripley 2004, 2005
21:26:55 <EsoBot> Brainfuck Edition v0.11
21:27:25 <calamari> jix: feel free to run that via private message :)
21:28:03 <calamari> I should probably have the pids start over at 1 rather than incrementing unix style
21:32:34 -!- graue has joined.
21:33:54 <calamari> what would you think about removing "input" and just using a number and the text
21:34:14 * jix is going to create a esolang output/code size shootout page
21:34:19 <GregorR> How about PM's just counting as input :P
21:34:29 <calamari> how does it know which process tho
21:34:42 <GregorR> Well, it knows the user who started a proc, if they only have one, that's the one :P
21:34:47 <calamari> I could have it not require E!
21:35:43 <GregorR> Whatever works for you *shrugs*
21:35:45 <calamari> I think it'd be confusing if it sometimes required the pid and sometimes did not
21:36:03 <calamari> I could limit it to one process per nick
21:37:08 <EsoBot> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
21:37:10 <EsoBot> <title>Index of /ls</title>
21:37:14 <EsoBot> <pre><img src="/icons/blank.gif" alt="Icon "> <a href="?C=N;O=D">Name</a> <a href="?C=M;O=A">Last modified</a> <a href="?C=S;O=A">Size</a> <a href="?C=D;O=A">Description</a><hr><img src="/icons/back.gif" alt="[DIR]"> <a href="/">Parent Directory</a> [...]
21:37:16 <EsoBot> <img src="/icons/unknown.gif" alt="[ ]"> <a href="bf">bf</a> 22-Oct-2005 15:25 64
21:37:19 <EsoBot> <img src="/icons/unknown.gif" alt="[ ]"> <a href="dirs">dirs</a> 22-Oct-2005 15:03 4
21:37:24 <EsoBot> <address>Apache/2.0.54 (Ubuntu) mod_jk2/2.0.4 Server at localhost Port 80</address>
21:38:00 <marcan> you could have it work without E! in PM
21:38:09 <marcan> stuff like input 1 blah
21:38:13 <marcan> or better yet, abbreviate
21:38:25 <marcan> better yet, make that in -1 blah
21:38:33 <marcan> if you don't type the PID, it goes to the last one
21:38:56 <marcan> in blah would go to the last PID
21:39:03 <marcan> the - is to differentiate it from numerical input
21:39:42 <marcan> of course, but less common
21:39:52 <marcan> just come up with something unusual
21:40:11 * marcan switches to a UTF-8 console
21:40:42 <marcan> I just see a video inverted X
21:40:43 <GregorR> That's unusual all right! :P
21:40:48 <marcan> I guess my font settings are uncool
21:40:56 <jix> marcan: ack
21:41:41 <jix> that's a bio hazzard sign
21:41:44 <marcan> (but you can't see that because it isn't utf-8)
21:41:51 <lament> F![$19>[$10/$9=["ninety"]?$8=["eighty"]?$7=["seventy"]?$6=["sixty"]?$5=["fifty"]?$4=["forty"]?$3=["thirty"]?$2=["twenty"]?10*-$0=~["-"]?]?$19=["nineteen"]?$18=["eighteen"]?$17=["seventeen"]?$16=["sixteen"]?$15=["fifteen"]?$14=["fourteen"]?$13=["thirteen"]?$12=["twelve"]?$11=["eleven"]?$10=["ten"]?$9=["nine"]?$8=["eight"]?$7=["seven"]?$6=["six"]?$5=["five"]?$4=["four"]?$3=["three"]?$2=["two"]?$1=["one"]?0=["no"]?]n:
21:41:53 <marcan> I mean, lowercase y+diaeresis, not uppercase
21:42:31 <lament> it works only from 0 to 99
21:42:33 <lament> so as to fit a certain song
21:43:17 <lament> the -nine part is correct. The number does end in "-nine" :)
21:43:23 <GregorR> jix: BTW, you mentioned a page about most-output least-input? But that doesn't make any sense, I mean, what about ++++++++++[.]
21:43:46 <calamari> hehe, don't run that in esobot :P
21:44:10 <marcan> does IRC take blank lines?
21:44:24 <calamari> if they are articially padded with spaces, yep
21:44:28 <GregorR> G!{M[moO!b<1>="a"/b0oo.?\]}
21:44:36 <marcan> yeah, with spaces it does
21:44:41 <marcan> but does esobot add spaces?
21:45:37 <falsebot> Error: Argument to > is not a number
21:45:52 <jix> GregorR: there are challanges like 99bob etc.. the output is vorgeschrieben(/me is looking that word up)
21:46:27 <jix> the output has to be what the challenge says
21:48:51 <GregorR> The winning entry would be in HQ9+ :P
21:49:24 <jix> you can filter for computational class
21:49:32 <graue> I bet HQ9+ gets a low score on the prime factoring challenge
21:49:37 <graue> there will be one, right, jix?
21:50:05 <jix> graue: users can submit challenges
21:50:35 <jix> GregorR: what about the 99bob unnecessary dialect?
21:50:41 <jix> unbeatable
21:51:12 <graue> calamari: how about randomizing the pids, OpenBSD style?
21:51:39 <jix> how about using large meresenne primes as pids?
21:52:07 <GregorR> How about using a progressively increasing number of digits of pi as pids?
21:52:44 <jix> how about factorizing rsa-2024 und using the factors as pids?
21:53:49 <GregorR> How about using BF programs to output the "real" PID as the pids :P
21:55:22 <graue> I wrote a game that uses fork() as a random number generator
21:55:32 <graue> it hits a resource limit after a little while, but it works
21:57:50 <calamari> how about you guys get busy porting interpreters to Java ;) hehehe
21:57:51 <GregorR> Probably doesn't work very well on non-OpenBSD systems :P
21:58:02 <GregorR> I don't speak Java or Sanskrit.
21:58:24 <calamari> There is a rosetta stone at your local community college
21:58:29 <GregorR> I don't know Java or Ancient Egyptian.
21:58:43 <GregorR> Because then the lie is complete :P
21:59:00 <graue> calamari: I much prefer the proposal by GregorR and kipple that a bot call plain old interpreters and read their output
21:59:37 <GregorR> Because then interpreters can be written in any language, even Java.
22:00:14 <graue> if you know how to call system(), you can implement anything you can type at the shell...
22:00:19 <calamari> and can it run interactive programs?
22:00:49 <marcan> I'd code more in java, but I have a few rants about it. Like it doesn't support operator overloading :P
22:00:51 <GregorR> I can write it if I get off my ass.
22:01:35 <calamari> it sounds fine.. having a process list or something equivalent would be nice.. also the ability to run programs from webpages
22:02:01 <graue> you would want to create a new user to run all this stuff as, and set resource limits for that user, of course
22:02:07 <calamari> and rather than terminating a program with a long line, perhaps just trim the output to 33 chars.. that's what I'm doing
22:02:27 <marcan> no more than X lines / sec
22:02:51 <graue> in other words, buffer output
22:02:54 <calamari> marcan: well, that can be handled automatically.. I only print a line every so often
22:03:54 <GregorR> Again, the "get off my lazy ass" problem.
22:04:08 <calamari> can it handle using up all the memory .. i.e. +[>+]
22:04:20 <GregorR> That's interpreter depedent.
22:04:23 <calamari> or I suppose that is up to the app
22:04:42 <calamari> I dunno.. I see my system as in place and working :)
22:04:53 <lament> for an example of such a setup
22:04:55 <graue> why doesn't it support Kipple? that already has a Java interpreter
22:05:07 <lament> there's a Mathematica interpreter in #math
22:05:10 <calamari> who said it doesn't support them
22:05:16 <EsoBot> Commands: bf, cat, help, kill, ls, ps, quit, unnecessary.
22:05:17 <EsoBot> Commands: bf, cat, help, kill, ls, ps, quit, unnecessary.
22:05:23 <EsoBot> Invalid command `kipple'.
22:05:28 <calamari> it hasn't implemented, but they should be supported
22:06:26 * graue begins adding support to the Sceql interpreter for reading programs from stdin
22:06:46 <GregorR> Am I being peer pressured? :P
22:06:57 <calamari> lol, you guys will go to any length to avoid a few lines of Java..
22:07:24 <lament> java does suck quite a bit :)
22:08:30 <calamari> it is easy to program in.. that's my definition of good :)
22:08:48 <GregorR> Visual Basic is easy to program in.
22:08:57 <GregorR> Are you telling me that Visual Basic is good?
22:09:13 <calamari> you can get stuff done with it
22:09:14 <lament> GregorR: it would be, if it really were easy to program in.
22:09:15 <cpressey> http://www.sun.com/suntrademarks/index.html#J
22:09:20 <graue> but Visual Basic is not easy to program in
22:11:20 <lament> not in my humble experience, anyhow.
22:11:26 <calamari> I've written a few VB programs.. it seemed easy enough for what I was doing
22:12:36 <graue> ever tried doing binary file I/O with it?
22:12:53 <graue> that's not what I would call easy
22:13:11 <calamari> I used it to fix AVI's where the a/v weren't in sync
22:13:38 <calamari> I don't remember the i/o being a problem
22:14:04 <marcan> it's a PITA the times I've done it
22:14:22 <GregorR> NULLs are almost IMPOSSIBLE.
22:14:29 <GregorR> I have no idea why I capped that.
22:14:38 <marcan> The thing I don't like about java is it's nonacceptance of features that are deemed "unclean" or whatever
22:14:43 <marcan> Which is why I like python
22:14:44 <lament> GregorR: cause you are hysterical.
22:14:55 <calamari> GregorR: I thought you were away writing the next generation esoteric bot ;)
22:15:00 <lament> the thing i don't like about java is that very basic tasks are extremely verbose.
22:15:07 <lament> Which is why i like Python.
22:15:48 <marcan> one of the most ironic things of java is that is doesn't like operator overloading, but builds it in on the String class
22:15:52 <calamari> python is difficult to program in due to the dumb indentation thing
22:15:57 <marcan> that I consider worse than allowing it for all classes :P
22:16:04 <marcan> I like the indentation
22:16:17 <lament> calamari: obviously you never actually tried :)
22:16:19 <marcan> removes unneccesary braces
22:16:22 <calamari> marcan: makes it difficult to comment things out, in practice
22:16:32 <marcan> use an editor with a comment-out function :)
22:16:34 <lament> calamari: not when you use A Text Editor
22:16:35 <calamari> lament: obviously not, as I program in it for my job
22:16:35 <graue> makes it easy to see where things start and stop
22:16:38 <marcan> or just surround everything in """
22:16:44 <GregorR> What should EgoBot's trigger be?
22:17:03 <lament> i wish i had a job like that!
22:17:22 <calamari> if it will replace all bots, one char is enough
22:17:37 <marcan> you see, now I want to write my own bot too :P
22:17:40 <lament> only if it actually does replace all the bots :)
22:18:00 <calamari> lament: you also used EsoBot first.. sorry bout that ;)
22:18:56 -!- EsoBot has quit ("requested by calamari").
22:19:46 -!- EsoBot has joined.
22:20:08 <calamari> E!bf http://localhost/bf/factor.b
22:20:38 <graue> E!bf http://localhost/bf/factor.b
22:20:50 <EsoBot> 2832921: 3 3 3 7 13 1153
22:21:54 <graue> E!bf http://localhost/bf/factor.b
22:22:54 <calamari> testing the private message thing.. doesn't require E!
22:23:09 <graue> is it still trying to factor 2812097?
22:23:14 <calamari> didn't implement the whole single process per user thing tho
22:23:52 <calamari> what do you expect from bf, blinding speed?
22:24:21 <graue> it factors it in 0m0.003s using gbf2c and gcc :)
22:24:51 <calamari> and I suppose you'll be using that for your bot?
22:24:55 <graue> 7.33s using pbfi, my C interpreter with no optimizations
22:25:24 <calamari> I invite you to write a better bot.. until then, dude just shut up okay?
22:26:02 <graue> am I not allowed to compare speeds of bf implementations in here?
22:26:10 <graue> I was surprised by the long time it took, that's all
22:26:45 <graue> what happened to that speed comparison page someone was making?
22:27:15 <jix> i stopped making it because my test computer is broken
22:27:44 <jix> latest results: http://www.harderweb.de/jix/langs/brainfuck/result2.txt
22:27:48 <graue> maybe you could include speeds in the esoteric language shootout?
22:27:52 <jix> egobfi improved a lot after that
22:28:20 <jix> graue: i'd need a test machine
22:28:44 <jix> or is the system time independent from cpu usage?
22:29:43 <graue> jix: when I do "time <some command>" here it prints out a "real", "user", and "system" time, and I don't think "user" is affected by other tasks running on the CPU
22:47:45 <GregorR> Stupid processor overheating is spewing messages into my console.
22:49:49 <lament> i read that as stupid professor overheating.
22:51:01 <graue> why is your processor overheating?
22:52:01 <graue> is this usual and expected behavior?
22:52:26 <jix> killed "my" laptop
22:52:48 <GregorR> The Pentium 5 is based on the Pentium M, not the Pentium 4 :P
22:52:58 <GregorR> So overheating will be less of an issue.
22:53:08 <graue> I've heard those processors from that VIA company are really cool (literally)
22:53:42 <graue> maybe you could use one of those until the Pentium 5 is available
22:59:13 <GregorR> Until my computer bursts into flames, I'm fine with the P4 :P
23:00:48 <calamari> I should get a new mb.. this one has a noisy fan.. and I had to modify the heatsink to get it to fit around capacitors so I don't feel like messing around to get a quieter one
23:02:32 -!- Sgep has joined.
23:04:21 <calamari> ahh cool, the bot compiled with gcj.. trying it :)
23:04:35 -!- EsoBot has quit ("requested by calamari").
23:05:20 -!- EsoBot has joined.
23:05:36 <calamari> E!bf +[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
23:05:44 <graue> does digitalr.b (in the esoteric files archive) work for everyone else?
23:06:05 -!- EsoBot has quit (Remote closed the connection).
23:06:16 <calamari> was trying to take down my system
23:06:28 <GregorR> OK, what BF interpreter should I use?
23:07:27 -!- EsoBot has joined.
23:07:44 <calamari> E!bf +[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
23:07:56 <EsoBot> Killed 1: Out of memory.
23:08:16 <calamari> yay.. that's the way to do it.. kill it and don't freeze up my system :)
23:11:36 * jix complied the gnu time because it is > than the osx time
23:11:42 <calamari> speaking of that.. I need to figure out what happened to Kstars
23:14:21 <graue> wow, afbi is buggy
23:15:00 <graue> I ran rot13.b, typed "SHPX LBH<Enter>", it did nothing so I pressed ^D, afbi grew until it was using about 500 MB of memory, then segfaulted
23:15:25 <graue> jix: I guess afbi was "unfinished"?
23:15:49 <calamari> E!bf http://esolangs.org/files/brainfuck/src/rot13.b
23:16:39 <jix> graue: afbi?
23:16:45 <jix> ah afbi...
23:17:17 <graue> why does EsoBot print a newline after each letter there?
23:17:58 <calamari> I guess that's what the program does?
23:18:21 <jix> afbi is somewhat buggy as all my c programs except cipple which seems to run fine and fast
23:18:25 <graue> the program doesn't do that for me under pbfi, qdb, or yabfi2
23:18:50 <jix> graue: if you want really fast bf execution use bf2a
23:19:12 <EsoBot> bfi.b bottles.b factor.b helloum.b LostKng.b prime.b triangle.b
23:19:41 <calamari> E!bf http://localhost/bf/bfi.b
23:20:30 <calamari> looking at the source, he is doing an input in the final loop.. my interpreter flushes output on input
23:20:54 <calamari> that way programs will be able to print a prompt without a cr first
23:21:37 <jix> calamari: i'd flush only if there is no input byte in queue
23:22:12 <calamari> this is before it does the input
23:22:21 <calamari> so there is no input in the queue
23:22:53 <calamari> I'm probably misunderstanding you
23:23:55 <EsoBot> 1:calamari, 2:calamari
23:23:57 <graue> jix: bf2a beats gbf2c by 0.03 ms on mandelbrot
23:24:47 <calamari> E!2 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
23:25:01 <jix> graue:where do i find gbf2c?
23:26:37 <jix> bf2a does more optimizations than gbf2c
23:26:41 <graue> jix: www.esolangs.org/files/brainfuck/impl
23:26:44 <jix> and it's faster here
23:27:00 <graue> jix: bf2a version 0.2?
23:28:12 <jix> i'm retesting
23:28:16 <graue> jix: bf2a's compiled version of factor.b fails to compile in gcc here
23:28:27 <graue> syntax error on line 14
23:28:45 <graue> I don't think "lut_-1" is a legal identifier in C
23:29:10 -!- EsoBot has quit ("requested by calamari").
23:29:13 <jix> need to debug that
23:29:53 <calamari> jix: I understood what you were saying now.. let's see how it does :)
23:30:01 -!- EsoBot has joined.
23:30:11 <calamari> E!bf http://esolangs.org/files/brainfuck/src/rot13.b
23:30:44 <graue> jix: also, once I fix the syntax error in factor.c (renaming lut_-1 to something else), factor.b is faster when compiled by gbf2c than when compiled by bf2a
23:31:02 <calamari> E!bf http://localhost/bf/LostKng.b
23:31:04 <jix> graue: factor is misscompiled if there is a lut_-1
23:31:06 <EsoBot> (C) Jon Ripley 2004, 2005
23:31:07 <EsoBot> Brainfuck Edition v0.11
23:31:07 <graue> jix: 0.14s for the bf2a version, 0.03s for the gbf2c version
23:31:09 <EsoBot> To read the back-story enter '!'.
23:31:10 <EsoBot> For a list of commands enter '?'.
23:31:12 <EsoBot> Enable long room descriptions (Y/N) ?
23:31:27 <jix> graue: AND .. i use expanding memory... gbf2c not
23:31:29 <graue> jix: yeah, I just noticed it prints the wrong answer too :)
23:31:37 <EsoBot> You are in a small hut by a dirt road.
23:31:43 <graue> jix: but this isn't using 32768 cells
23:31:59 -!- EgoBot has joined.
23:32:08 <jix> graue: but i have to check every > for an overflow
23:32:17 <GregorR> !bf >+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+.
23:32:42 <GregorR> So that'll go for a while ;)
23:32:43 <graue> 2812097 is prime according to the bf2a version of factor.b
23:32:52 <calamari> !bf +[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
23:32:58 <graue> in fact, so is every number it looks like
23:33:31 <GregorR> I killed your first proc manually btw :P
23:33:37 <jix> graue: but it tries to use my complex lookup tables so if i fix it it should be faster
23:33:43 <calamari> how is the memory task doing ?
23:33:48 <graue> !bf +++++++++++++++++++++++++++++++++[.]
23:33:49 <GregorR> I don't know why it didn't respond to that !ps ...
23:34:06 <GregorR> I am so glad you didn't put a newline in that ...
23:34:19 <GregorR> However, it seems to be entirely unresponsive now, so who cares!
23:34:23 <graue> !bf +++++++++++++++++++++++++++++++++>++++++++++<[.>.<]
23:34:44 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
23:35:30 <jix> bf2a: user 0m5.128s
23:36:10 <jix> user 0m5.340s
23:38:09 <graue> what program is this for?
23:38:17 <jix> mandelbrot
23:38:21 <jix> bf2a and gbf2c
23:38:48 <GregorR> Anybody care to compare egobfc2m to those?
23:38:49 <graue> over here, the two versions took a little over 10 seconds and bf2a's version was 0.03ms faster
23:42:17 <graue> egobfc2m crashes immediately on running mandelbrot.b
23:43:16 <jix> graue: line198: when 1 => when -1
23:43:26 <graue> I don't think OpenBSD likes it when programs generate code and call it at runtime
23:43:56 <jix> some cpus dislike that (caching..)
23:43:58 * graue tests factor.b with bf2a again
23:44:23 <graue> egobfc2m worked fine on windows here
23:44:40 <graue> I am pretty sure that OpenBSD won't allow it to do what it does for security reasons
23:45:24 <jix> factor.b: 2165843199767 bf2a:0m0.902s gbf2c:0m2.070s
23:45:55 <jix> thats a factor of 2!
23:46:35 <graue> 3.28s vs 1.56s here
23:46:45 <graue> (for the same number)
23:46:46 <jix> which is mine?
23:46:51 <graue> the 1.56s of course
23:47:17 <jix> what machine are you using?
23:47:54 <graue> but that's not really an accurate measure of CPU speed of course
23:48:01 <jix> and slower than on my ppc g4 1000mhz ?
23:48:16 <graue> I didn't have any gcc optimizations on
23:48:34 <graue> unless it optimizes by default, does it?
23:48:43 <jix> default is O2 i think
23:48:43 -!- EgoBot has joined.
23:49:08 <GregorR> !bf >+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+.
23:51:25 <graue> -O0 appears to be the default
23:51:54 <GregorR> Yeah, ps takes a proc in EgoBot.
23:52:37 <graue> jix: factor-gbf2c: 3.32s, factor-bf2a: 1.56s, factor-gbf2c-o2: 1.38s, factor-bf2a-o2: 0.42s, factor-gbf2c-o3: 1.39s, factor-bf2a-o3: 0.40s
23:52:43 <calamari> !bf http://esolangs.org/files/brainfuck/src/hello.b
23:53:31 <graue> !bf +++++++++++++++++++++++++++++++++>++++++++++<[.>.<]
23:53:31 -!- EgoBot has quit (Excess Flood).
23:53:39 <graue> no flood protection yet? :)
23:55:17 <graue> calamari: I imagine your thing didn't work because IRC doesn't allow blank lines
23:55:45 <calamari> graue: yeah, I was testing to see how it handled that
23:55:58 <calamari> I add a space to blank lines so they are displayed