←2005-10-23 2005-10-24 2005-10-25→ ↑2005 ↑all
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:04:37 <GregorR-L> .bashrc
00:04:44 <GregorR-L> Whoops, too late :P
00:05:02 <GregorR-L> G!{M[moO!"You suck GregorR!"oo.?]}
00:05:03 <GlassBot> You suck GregorR!
00:05:07 <GregorR-L> Ow, I'm hurt!
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:02 <calamari> yay
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:23 <GregorR-L> I'll call it EgoBot.
00:27:44 <kipple> ooh. many bots here now :)
00:27:50 <GregorR-L> Heheh
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:40 <GregorR-L> That's what EgoBot will do XD
00:32:56 <GregorR-L> The best part of EsoBot is that it has no problem with infinite loops, since it can multiprocess.
00:32:59 <kipple> ok :)
00:33:38 <marcan> wow :)
00:33:41 <marcan> hi all, by the way
00:33:46 <kipple> hello
00:34:01 <GregorR-L> Hi marcan!
00:34:07 <marcan> just another guy who thinks esoteric languages are fun :)
00:34:11 <GregorR-L> Welcome to #esoteric!
00:34:23 <marcan> thanks
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:35:46 <GregorR-L> What about ircd's? :P
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:36:42 <GregorR-L> nice is your friend ;)
00:36:47 <marcan> of course :)
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:25 <GregorR-L> Yeah, that is awesome.
00:37:49 <kipple> what's UML (not the markup language)
00:37:53 <marcan> user mode linux
00:37:56 <GregorR-L> User-Mode Linux
00:37:59 <GregorR-L> Damn, you're a fast typist.
00:38:06 <marcan> lol
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:26 <kipple> nice
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:21 <GregorR-L> Glass ;)
00:39:30 <graue> Glass would work for that?
00:39:33 <kipple> befunge?
00:39:34 <graue> I should try it then
00:39:34 <GregorR-L> Sure.
00:39:36 <kipple> or Ork
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:34 <graue> that sounds good
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 <GregorR-L> ? How's that?
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:30 <GregorR-L> Exactly
00:42:41 <marcan> that would work
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:44:04 <GregorR-L> lol
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:18:49 <kipple> 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:27 <graue> for instance
01:19:47 <kipple> ah, yes. good point
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:45 <marcan> hmm
01:29:56 <marcan> has anyone written a Tetris game in brainfuck?
01:30:03 <marcan> that would be an interesting project
01:30:05 <kipple> probably not
01:30:18 <kipple> I don't know any games written in bf...
01:30:25 <marcan> there should be some
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:46 <marcan> exactly
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:14 <kipple> yeah
01:31:31 <marcan> the interpreter would need to support unbuffered and nonblocking input though
01:31:33 <marcan> but that's about it
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:29 <marcan> of course
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:50 <marcan> yep
01:32:59 <marcan> I guess we could add in another operator though
01:33:06 <marcan> like % or something
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:23 <marcan> interesting
01:34:44 <marcan> similar to tetris in essence
01:35:25 <graue> how? tetris requires delays and reflexes
01:39:05 <marcan> yeah
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:41:10 <marcan> hmm
01:41:11 <marcan> 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:44:59 <calamari> E!ps
01:45:07 <EsoBot> 3:calamari, 4:marcan, 5:marcan
01:45:12 <marcan> impressive
01:45:28 <calamari> marcan: then use E!input <process> ...
01:45:33 <marcan> yeah, I know
01:45:36 <calamari> cool
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:29 <marcan> same thing here :)
01:46:48 <kipple> Lost Kingdom is not written in brainfuck though, so it doesn't really count.
01:46:54 <graue> indeed
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:11 <graue> that's cool
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:29 <calamari> hehe, I suppose
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:09 <graue> maybe that was it
01:50:38 <calamari> I think it may make some assumptions
01:50:50 <graue> what are they?
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:52:52 <calamari> graue: lol, did I write that?
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:19 <calamari> most were very poor
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:43 <marcan> seeing we have bfvga
01:54:48 <marcan> when will we get bfgl?
01:54:50 <marcan> *grin*
01:54:51 <kipple> pretty close to done I think
01:55:05 <kipple> mracan: hehe.
01:56:32 <kipple> hmm. is there a true esoteric language that at the same time is efficient enough for graphics?
01:56:51 <calamari> I think there is one
01:57:13 <calamari> iirc it was similar to befunge with a huge library of functions
01:57:39 <calamari> it's on the wiki
01:58:05 <graue> gammaplex?
01:58:13 <calamari> that sounds right
01:58:45 <marcan> interesting
01:59:05 <marcan> (and my firefox just crashed on its homepage)
01:59:31 <marcan> (and it did so again)
02:02:12 <calamari> what os
02:03:35 <marcan> linux
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:05:09 <marcan> oh, yeah
02:05:16 <calamari> E!kill 4
02:05:17 <EsoBot> Killed 4.
02:08:32 <kipple> graue: about Kipple 05: I don't think I will finish the spec until I have it fully implemented
02:08:55 <graue> fair enough
02:09:09 <graue> cipple will need updating too!
02:09:12 <graue> as will orkipple
02:09:42 <kipple> have you read the new spec draft?
02:09:57 <graue> not recently
02:10:28 <kipple> unless they want to implement the optional features, updating cipple and orkipple will be rather trivial
02:12:19 <GregorR-L> So ... much ... conversation ...
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:01 <GregorR-L> I might write Glipple.
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:17:13 <marcan> true
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:19:47 <graue> but I don't
02:20:06 <calamari> sure you do :)
02:20:18 <graue> I think someone wrote an interpreter once where printing \0 ended the program
02:20:34 <graue> maybe that was me
02:20:40 <marcan> hmm... Thinking about interpreters and compilers...
02:20:50 <marcan> all that is kind of boring
02:20:52 <marcan> let's make a BF CPU!
02:20:58 <calamari> someone has
02:21:07 <marcan> heh
02:21:22 <marcan> without an FPGA or a microcontroller?
02:22:02 <calamari> http://en.wikipedia.org/wiki/Brainfuck#Hardware
02:22:15 <marcan> read that just now
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:29 <marcan> :)
02:22:53 <marcan> the PIC one is essentially an interpreter for an already existing CPU though
02:22:59 <calamari> yeah thats cheating
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:40 <calamari> or maybae vacuum tubes
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:04 <calamari> nice
02:24:15 <calamari> link to that?
02:24:30 <marcan> http://www.homebrewcpu.com/
02:25:03 <marcan> telnet magic-1.org
02:25:06 <marcan> type that
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:35:43 <calamari> hehe, that's fun
02:37:03 <marcan> indeed
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:35 <marcan> hmm
02:55:43 <marcan> calamari: I'm going to see if I can do it on a simulator
02:58:16 <graue> good luck
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:26 <graue> GregorR: where?
02:58:38 <GregorR> Glass, if you made a class-wide variable of the M class.
02:58:55 <graue> oh
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:44 <marcan> of course
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:31 <marcan> and viceversa
03:01:35 <calamari> but then you get into multiple bytes per instruction which introduces its own complication
03:01:46 <marcan> yeah
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:22 <calamari> like nand
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:31 <marcan> which is just boring
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:05:39 <marcan> boolfuck you mean?
03:05:47 <calamari> yeah, or bitchanger
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:04 <calamari> must be a tiny cat :P
03:10:14 <graue> very good, but can you write "dog" in glass?
03:10:15 <calamari> or a large glass...
03:10:35 <GregorR> G!{M[m(_o)O!"dog"(_o)o.?]}
03:10:37 <GlassBot> dog
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:11:46 <calamari> or nor
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:12:56 <marcan> I could
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:34 <marcan> another after it, NOR
03:13:41 <marcan> and you can build XOR out of that
03:13:47 <marcan> and flipflops, and anything you want
03:13:54 <graue> and NXOR
03:13:59 <marcan> of course
03:14:12 <graue> or is that XNOR?
03:14:29 <marcan> no idea
03:14:30 <GregorR> I prefer to think of it as EQUAL :P
03:14:35 <marcan> never used it
03:14:39 <marcan> yeah
03:14:48 <graue> and XOR as NEQUAL?
03:14:49 <marcan> also, is there a boolean XOR in C?
03:14:52 <graue> no
03:14:54 <GregorR> Yes XD
03:14:57 <marcan> I always wondered that and never bothered to look
03:14:58 <GregorR> ^
03:14:58 <graue> we were just discussing that earlier today
03:15:02 <marcan> ^is bitwise
03:15:06 <graue> GregorR, he means a ^^
03:15:06 <GregorR> Oh, sorry :P
03:15:08 <GregorR> No
03:15:12 <GregorR> Right
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:15:41 <GregorR> Yes, there is ;)
03:16:31 <graue> I want to be able to do "(a ^^ b) = 1;"
03:16:34 <graue> that would be cool
03:16:46 <marcan> assignment?
03:17:04 <graue> wait, that doesn't make any sense
03:17:06 <graue> never mind
03:17:09 <marcan> :)
03:17:09 <GregorR> lol
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:26 <marcan> XORassign
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:31 <marcan> or the other
03:17:33 <marcan> randomly
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:34 <marcan> of course
03:18:36 <GregorR> Hmm ...
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:41 <marcan> hmm...
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:01 <marcan> maybe not in BF
03:20:05 <marcan> but what about l33t?
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:21:24 <graue> bye
03:24:20 <GregorR> So graue, should I start making that CGI class for Glass? ;)
03:27:24 <graue> I guess so
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:05 <GregorR> lol
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:17 <GregorR> Bleck.
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:31 <GregorR> G!{(Main)}{(Test)}
03:35:32 <GlassBot> OK
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:42 <GregorR> Much better.
03:35:47 <GregorR> G!{M[m(_d)(Debug)!"T"(_d)(fl).?]}
03:35:48 <GlassBot> m
03:35:54 <GregorR> G!{T}
03:35:55 <GlassBot> OK
03:35:59 <GregorR> All clean.
03:41:58 <calamari> G!{M[moO!"+++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++."oo.?]}
03:42:00 <GlassBot> +++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++.
03:42:02 <calamari> cool
03:42:08 <calamari> G!{M[moO!"E!bf +++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++."oo.?]}
03:42:08 <GlassBot> E!bf +++++++++++[>+++++++++>++++++++++<<-]>+.>+.<+++.
03:42:10 <EsoBot> dog
03:42:27 <Sgep> Bye all
03:42:31 <calamari> cya Sgep
03:43:05 <tokigun> woah
03:43:07 <tokigun> i'm back
03:43:24 <GregorR> Bye Sgep
03:43:26 <GregorR> Hi tokigun
03:43:32 <tokigun> ;)
03:43:34 <calamari> F!34.
03:43:34 <falsebot> 34
03:43:37 <GregorR> I just got my first Glass CGI script working :)
03:43:38 <calamari> F!34,
03:43:38 <falsebot> "
03:43:49 <calamari> F!34."a"34.
03:43:50 <falsebot> 34a34
03:44:00 <tokigun> GregorR: show me :p
03:44:10 <GregorR> I'm behind a LAN which is behind a LAN.
03:44:18 <tokigun> hmm.
03:44:21 <GregorR> {M[m(_o)O!"Content-type: text/plain\n\nThis is a test\n"(_o)o.?]}
03:44:23 <GregorR> That's the code.
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:44:54 <calamari> oops
03:45:15 <GregorR> I'm still working on it ;)
03:45:27 <calamari> no, my bad
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:46:09 <EsoBot> dog
03:49:27 <GregorR> OK, it will clearly need access to the environment for GET, but what about POST ...
03:50:09 <GregorR> It can get post as-is.
03:50:18 <calamari> F!"G!{M[moO!"34,"BF!+++++++++++[>++++++>+++>++++>++++<<<<-]>+++.+++++++++++++++++++++++++++++.++++.+++.>-.<---.-----.++.+++++++++++++++++.-----.+++.>>++.<<----------------.>.+++++++++++..>---..>-....<...<<-------.>>+++++++++++++++++++.>....<<..>>...<.>........<<..>--..<++.<++.>>++.>.<<+.>.>.<<.>--.>...<<."34,"oo.?]}"
03:50:18 <falsebot> Flood!
03:50:21 <calamari> bah
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:51:52 <tokigun> (if you use cgi)
03:52:00 <GregorR> Mm, that's true.
03:52:10 <GregorR> OK, I'm going to have to make environment vars >_<
03:52:11 <GregorR> Bleck.
03:54:51 -!- graue has quit.
04:04:00 <calamari> sometimes linux is dumb
04:04:11 <calamari> I can't output ! without it being interpreted
04:05:50 <GregorR> ?
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:49 <GlassBot> OK
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:18:40 <GlassBot> OK
04:19:24 <GregorR> G!{M[m(_o)O!(_h)(Hsh)!"A""B"(_h)s.?"A"(_h)g.?(_o)o.?]}
04:19:25 <GlassBot> gv
04:19:30 <GregorR> Ewwwwwwwwwwwww
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:07 <GlassBot> OK
04:21:11 <GregorR> G!{M[m(_o)O!(_h)(Hsh)!"A""B"(_h)s.?"A"(_h)g.?(_o)o.?]}
04:21:13 <GlassBot> B
04:21:17 <GregorR> Wow.
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:32 <GlassBot> F
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:41 <GlassBot> F
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:21:46 <GlassBot> F
04:21:48 <GregorR> Unwow ...
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:22 <GlassBot> OK
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:30 <GlassBot> F
04:23:32 <GregorR> >_<
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:23:51 <EsoBot> dog
04:23:55 <calamari> !!! :)
04:24:14 <GregorR> Yes yes, bots are fun :P
04:24:34 <GregorR> G!{M[m(_o)O!(_s)S!"A""A"(_s)e.?(_o)(on).?]}
04:24:44 <GregorR> ...
04:25:04 <GregorR> G!{M[m(_o)O!"Hello?"(_o)o.?]}
04:25:06 <GlassBot> Hello?
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:25:51 <GregorR> Dot dot dot ...
04:26:27 <GregorR> Oh >_<
04:26:29 <GregorR> I know the problem.
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:00 <GlassBot> OK
04:27:06 <GregorR> G!{M[m(_o)O!(_s)S!"A""A"(_s)e.?(_o)(on).?]}
04:27:07 <GlassBot> 1
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:27:36 <GregorR> Grr.
04:27:43 * GregorR takes this offline.
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:52:57 <GregorR> Helloooo, GlassBot?
04:53:17 <GregorR> Again with the lag.
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 <GlassBot> OK
04:56:01 <GregorR> Anyway calamari, you don't need a biquine.
04:56:11 <calamari> I suppose not :)
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:29 <falsebot> G!{M[m(_f)(FE)!(_f)(fe).?]}
04:56:30 <GlassBot> F!"G!{M[m(_f)(FE)!(_f)(fe).?]}"
04:56:31 <falsebot> G!{M[m(_f)(FE)!(_f)(fe).?]}
04:56:32 <GlassBot> F!"G!{M[m(_f)(FE)!(_f)(fe).?]}"
04:56:33 <falsebot> G!{M[m(_f)(FE)!(_f)(fe).?]}
04:56:34 <GlassBot> F!"G!{M[m(_f)(FE)!(_f)(fe).?]}"
04:56:35 <falsebot> 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:37 <falsebot> G!{M[m(_f)(FE)!(_f)(fe).?]}
04:56:38 -!- GlassBot has left (?).
04:56:55 -!- GlassBot has joined.
04:57:04 <GregorR> G!{(FE)}
04:57:05 <GlassBot> OK
04:57:12 <GregorR> See, no sweat.
04:57:14 <GregorR> :P
04:57:48 <calamari> F!["'[,34,$!34,'],!"]'[,34,$!34,'],!
04:57:48 <falsebot> ["'[,34,$!34,'],!"]'[,34,$!34,'],!
04:58:09 <GregorR> Hmm
04:58:18 <calamari> I didn't write that ;)
04:58:25 <calamari> F!"F!"["'[,34,$!34,'],!"]'[,34,$!34,'],!
04:58:25 <falsebot> F!["'[,34,$!34,'],!"]'[,34,$!34,'],!
04:58:27 <GregorR> lol
04:58:36 <calamari> I don't really understand how quines work
04:58:52 <GregorR> Quines by dissection 101:
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.
04:59:45 <calamari> s/it's/its/
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:06:26 <EsoBot> test
05:06:29 <calamari> E!ps
05:06:30 <EsoBot> No processes.
05:08:01 <calamari> thanks for the quine lesson
05:09:21 <GregorR> Not that it could possibly have been helpful :P
05:09:45 <calamari> a little I think
05:10:10 <GregorR> If you knew Glass, the Glass quine would be the perfect quine-by-dissection example :P
05:10:24 <calamari> hehe
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:13:00 <GregorR> XD
05:22:20 <GregorR> World's worst C quine (just wrote it):
05:22:22 <GregorR> #include <stdio.h>
05:22:25 <GregorR> #define A(X) fputs(X
05:22:26 <GregorR> stdout) #define B(X) pu
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:13 <GregorR> #include <stdio.h>
05:23:15 <GregorR> #define A(X) fputs(X,stdout)
05:23:17 <GregorR> #define B(X) putchar(X)
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:23:23 <GregorR> Tada
05:23:25 <GregorR> World's worst C quine.
05:27:42 <Robdgreat> geez
05:47:43 -!- Robdgreat has left (?).
05:47:58 -!- Robdgreat has joined.
05:48:07 <Robdgreat> well that was interesting
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:03 <GlassBot> OK
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:10 <GlassBot> OK
06:00:16 <GregorR> Hashes :)
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:36 <GregorR> Or ... death.
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:18 <GlassBot> OK
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:32 <GlassBot> F
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:38 <GlassBot> B
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:03:50 <GlassBot> D
06:03:54 <GregorR> ^_^
06:05:38 <GregorR> MAN I love Glass.
06:05:41 <GregorR> Glass = awesome.
06:05:49 <GregorR> And I'm not just saying that because I wrote it ;)
06:05:57 <lament> it does look neat
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:08:53 <lament> well
06:08:55 <lament> it does in Python too
06:09:03 <lament> but it's still something like a = 1 + 2
06:09:09 <lament> :P
06:09:24 <GregorR> Yes, but Python isn't designed to be idiotic ;)
06:09:36 <lament> hmmm
06:09:39 <lament> are you sure of that? :)
06:09:44 <GregorR> lol
06:09:46 <GregorR> No.
06:09:46 <lament> sometimes i wonder...
06:09:47 <GregorR> No I am not.
06:09:57 <lament> i guess Glass is just better designed
06:10:01 <lament> (to be idiotic)
06:10:04 <GregorR> lol
06:10:25 <GregorR> It's OO, has a main stack, uses postfix notation, and extensively uses pointers - now THAT'S idiotic!
06:11:59 <lament> yes. yes it is.
07:56:16 -!- calamari has quit ("Leaving").
07:56:41 -!- EsoBot has quit (Remote closed the connection).
07:56:48 <GregorR> Bye bye EsoBot.
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.
10:58:38 <jix> E!hrlp
10:58:40 <jix> moin
10:58:42 <jix> E!help
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:05:31 <kipple> which is?
13:06:06 <jix> textmate
13:06:07 <kipple> let me guess? SubEthaEdit?
13:06:20 <kipple> never heard of it :)
13:06:22 <jix> textmate > subethaedit
13:06:45 <jix> http://macromates.com/
13:07:06 <kipple> don't run OSX
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:25 <jix> oh
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:46:48 <GregorR> jix: Doblepong :P
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:47:46 <GregorR> Quite :P
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:03 <GregorR> Awesome :) :) :)
18:52:26 <jix> is M.c__ called on startup?
18:54:40 <GregorR> No.
18:54:49 <GregorR> M is funky in just about every way :P
18:54:58 <jix> hrhr
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:56:38 <GregorR> ;)
18:56:46 <jix> online?
18:56:51 <GregorR> With GlassBot.
18:57:10 <jix> oh
18:57:16 <jix> why?
18:57:36 <jix> does glassbot remember global vars?
18:57:42 <GregorR> Yes.
18:57:56 <GregorR> But more importantly, it remembers classes, and you will have wiped out one ;)
18:58:08 <jix> oh...
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:36 <GlassBot> OK
18:59:41 <jix> G!{(Tape)[(c__)t(TapeItem)!][nttn.?=][pttp.?=][gtg.?][sts.?]}
18:59:42 <GlassBot> OK
18:59:51 <jix> glassbot knows tape now
19:00:44 <GregorR> ^_^
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:33 <jix> i know
19:02:45 <jix> but Debug is implementation specific too
19:02:53 <GregorR> Good point.
19:03:10 -!- GlassBot has joined.
19:03:32 <GregorR> G!{M[m(_d)(Debug)!"A"<5>aM*(_d)s.?]}
19:03:33 <GlassBot> (M*:c)(a)<5>"A"
19:03:37 <GregorR> Tada
19:04:21 <jix> G!{M[m"^PRIVMSG #esoteric test"~O.o~]}
19:04:23 <GlassBot> ^PRIVMSG #esoteric test
19:04:28 <jix> hm...
19:04:30 <GregorR> Only works for me ;)
19:04:33 <jix> ah
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:10 <GregorR> Yes :)
19:06:25 <jix> G!OO!"Test"Oo.?
19:06:26 <GlassBot> OK
19:06:31 <jix> whoops
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:42 <GlassBot> Test
19:06:56 <jix> mOO! << how cool
19:07:11 <GregorR> lol
19:07:38 <GregorR> BTW, here's my "Array" (LLL) class:
19:07:48 <GregorR> G!{M[m"Arr"~Debug.fl~]}
19:07:50 <GlassBot> c__ g l s
19:07:55 <GregorR> G!{M[m"Arre"~Debug.fl~]}
19:07:56 <GlassBot> c__ g gn s sn
19:10:09 <jix> is the new version with stack printing online?
19:12:03 <GregorR> No, I'll up in it a sec.
19:12:09 <GregorR> Up it in a sec even.
19:12:13 <GregorR> I just found this link: http://abstractfactory.blogspot.com/2005/10/only-debate-on-intelligent-design-that.html
19:12:15 <GregorR> Hilarious.
19:14:18 <jix> LOL
19:15:19 <jix> /away
19:16:16 <GregorR> Grr, I'm having upload problems >_<
19:19:23 <GregorR> OK, glass-0.10.tar.bz2 is up.
19:19:26 <CXI> hmm
19:19:36 <CXI> this looks interesting: http://firefoxit.mozdev.org/
19:23:31 <GregorR> Time to make a BF.fire?
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:33 <CXI> eww :/
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:29:59 <GregorR> Yeah
19:30:54 <CXI> http://del.icio.us/tag/software+cool
19:30:59 <CXI> this has shown up some neat stuff
19:31:53 <GregorR> Awesome.
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:28 <Keymaker> hmh
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:38:05 <Keymaker> ok
19:38:11 <Keymaker> that sounds better than sq
19:40:34 <CXI> hmm
19:40:40 <CXI> er, one thing about sql
19:40:53 <CXI> isn't that standard for plaintext sql query files?
19:42:02 <Keymaker> no idea
19:43:02 <GregorR> Yes.
19:43:04 <GregorR> Yes it is.
19:43:07 <GregorR> DO NOT use .sql.
19:43:42 <Keymaker> ok, sql it'll be
19:43:55 <Keymaker> :)
19:44:02 <GregorR> >_>
19:44:07 <GregorR> I don't know of any sq.
19:45:32 <Keymaker> mmh.. the language name is sceql.. i'm sure there can be something better than 'sq'..
19:46:05 <fizzie> .sceql? :p
19:46:46 <Keymaker> hmmm
19:47:24 <Keymaker> by the way, does one print '\' in by printing "\\" or something?
19:47:31 <Keymaker> (in c)
19:47:53 <CXI> yeah
19:47:59 <Keymaker> ok
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:26 <Keymaker> printf("\")?
19:49:46 <GregorR> printf("\\");
19:49:51 <GregorR> putchar('\\');
19:49:53 <fizzie> No, "\\". But it's passed as the string containing a single \ to printf.
19:49:54 <Keymaker> ok
19:50:23 <GregorR> In Glass you make a number with the ASCII value then do S.ns :)
19:50:32 <Keymaker> :)
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:11 <Keymaker> kipple: yeah, nothing! :)
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:05 <kipple> html too
19:53:12 <fizzie> Some use .htm still.
19:53:18 <fizzie> ".jaa" or ".jav" or ".jva" would sound: really stupid.
19:53:27 <kipple> I've seen .jav
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:54:32 <kipple> good
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:17 <GregorR> Both .cc and .cc?
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:39 <GregorR> Same with .C
19:56:43 <kipple> LOL. finally someone who's done it properly (guess what the TMMLPTEALPAITAFNFAL extension is?)
19:57:11 <fizzie> .tmmlptealpaitafnfal?
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:08:29 <jix> .dylib
20:08:37 <jix> .pages
20:08:47 <jix> .keynote
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:14:06 <Keymaker> phew..
20:14:57 <GregorR> BOOM!
20:20:34 <jix> G!{M[m(_s)S!"test"(_s)si.?~Debug.s]}
20:20:36 <GlassBot> OK
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:36 <jix> :(
20:21:52 <jix> G!{M[m<1><2><3>~Debug.s~]}
20:21:54 <GlassBot> <3><2><1>
20:25:31 <GregorR> Umm
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:27 <GregorR> (_s)(si).?
20:26:31 <jix> argh
20:26:39 <jix> G!{M[m(_s)S!"test"(_s)(si).?~Debug.s~]}
20:26:41 <GlassBot> "test"
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:12 <GlassBot> "Tfst"
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:30 <jix> i know
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:15 <GregorR> lol, OR vs AND, aaaah! :P
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:17 <jix> ok
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:29 <GlassBot> OK
20:31:37 <jix> typo..
20:31:42 <jix> G!{M[m~I.c~~Debug.s~]}
20:31:48 <jix> input?
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:17 <GregorR> A string.
20:32:24 <GregorR> (With a single character)
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:35:44 <GlassBot> <6>"Hello "
20:35:50 <GregorR> Bloody hell.
20:36:06 <Keymaker> hehe
20:36:12 <GregorR> Missed a line.
20:36:19 <Keymaker> anyways, gotta go. bye
20:36:26 <jix> bye
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:27 <GlassBot> "World!""Hello "
20:37:31 <GregorR> Much better.
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:48 <GlassBot> "Hello World!"
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:39:41 <GlassBot> OK
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:41:19 <GregorR> ^_^
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:42:27 <GregorR> :)
20:42:30 <GregorR> Quines are fun 8-D
20:43:09 <GregorR> G!{M[m~Debug.cl~]}
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:22 <GregorR> G!{M[m"L"~Debug.fl~]}
20:43:24 <GlassBot> a n o x
20:43:31 <GregorR> G!{M[m"L""a"~Debug.fc~]}
20:43:32 <GlassBot> (_a)2=(_b)1=,,/(_a)/(_b)<1>^\<0>^\<0>
20:43:38 <GregorR> Oh right, L = logic.
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:44 <jix> dvorak?
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:21 <GregorR> Heheh.
20:45:35 <GregorR> This is just what I do for my own perverse entertainment.
20:45:41 <jix> ah
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:48:24 <GregorR> OMG that rocks.
20:48:41 <CXI> :o
20:49:18 * GregorR bows down before jix's 31337 colorization prowess.
20:49:48 <jix> with folding!
20:49:54 <GregorR> Yeah, I see.
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:39 <calamari> hi
20:52:42 <GregorR> 'lo
20:52:48 <jix> moin calamari
20:52:49 <jix> G!{M[m"LameQuine"~Debug.fl~]}
20:52:51 <GlassBot> lq
20:53:17 <jix> G!{M[ml(LameQuine)!l.(lq).?]}
20:53:18 <GlassBot> {M[ml(LameQuine)!l.(lq).?]}
20:53:21 <jix> argh
20:53:26 <jix> G!{M[ml(LameQuine)!l(lq).?]}
20:53:27 <GlassBot> {M[ml(LameQuine)!l(lq).?]}
20:53:31 <GregorR> LameQuine.lq uses debug to output the M class :P
20:53:36 <jix> ah
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:10 <GlassBot> {M[ml(LameQuine)!l(lq).?" "]}
20:54:19 <GregorR> It's very limited ;)
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:54:57 <GlassBot> {M[m(_t)$(_t)b.?]}
20:54:59 <GregorR> :)
20:57:37 -!- EsoBot has joined.
20:57:46 <GregorR> EsoBot, my good friend.
20:57:50 <jix> E!help
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:08 <CXI> haha
20:58:13 <jix> E!ls
20:58:14 <EsoBot> Bad or inaccessible URL `http://localhost/ls/dirs'.
20:58:21 <calamari> oops need to start apache
20:58:41 <calamari> ok try again :)
20:58:44 <GregorR> E!unnecessary http://www.google.com/
20:58:45 <jix> E!ls
20:58:46 <EsoBot> bf/
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:17 <GregorR> lol
20:59:18 <GregorR> Great minds?
20:59:27 <jix> hrhr
20:59:52 <calamari> looks like a small output bug there
21:01:55 <jix> E!kill
21:01:57 <EsoBot> No such process `'.
21:02:03 <jix> E!kill 0
21:02:04 <EsoBot> No such process `0'.
21:02:07 <calamari> E!ps
21:02:09 <EsoBot> No processes.
21:02:13 <calamari> E!bf +[]
21:02:20 <jix> E!ps
21:02:22 <EsoBot> 3:calamari
21:02:30 <jix> E!kill calamari
21:02:31 <EsoBot> No such process `calamari'.
21:02:32 <jix> ^^
21:02:34 <calamari> lol
21:02:39 <jix> ah
21:02:39 <calamari> E!kill 3
21:02:40 <EsoBot> Killed 3.
21:02:49 <GregorR> G!{(EE)[e(_o)O!"E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++."(_o)o.?]}
21:02:50 <GlassBot> OK
21:03:00 <calamari> maybe I should make a pkill
21:03:00 <GregorR> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:03:01 <EsoBot> G!{M[me(EE)!ee.?]}
21:03:03 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:03:04 <EsoBot> G!{M[me(EE)!ee.?]}
21:03:06 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:03:07 <EsoBot> G!{M[me(EE)!ee.?]}
21:03:09 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:03:10 <EsoBot> G!{M[me(EE)!ee.?]}
21:03:11 <calamari> excellent!
21:03:12 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:03:13 <EsoBot> G!{M[me(EE)!ee.?]}
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:16 <EsoBot> G!{M[me(EE)!ee.?]}
21:03:18 <GregorR> :)
21:03:30 -!- GlassBot has joined.
21:03:34 <GregorR> G!{(EE)}
21:03:35 <GlassBot> OK
21:03:41 <calamari> G!{M[me(EE)!ee.?]}
21:03:53 <calamari> G!{(EE)[e(_o)O!"E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++."(_o)o.?]}
21:03:55 <GlassBot> OK
21:04:01 <jix> G!{(EE)}
21:04:03 <GlassBot> OK
21:04:07 <calamari> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:04:08 <EsoBot> G!{M[me(EE)!ee.?]}
21:04:12 <calamari> hahhaa
21:04:14 <calamari> too late
21:04:21 <calamari> G!{(EE)[e(_o)O!"E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++."(_o)o.?]}
21:04:22 <GlassBot> OK
21:04:24 <calamari> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:04:25 <EsoBot> G!{M[me(EE)!ee.?]}
21:04:26 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:04:27 <EsoBot> G!{M[me(EE)!ee.?]}
21:04:29 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:04:30 <EsoBot> G!{M[me(EE)!ee.?]}
21:04:31 <GlassBot> E!bf +++++++++++[>++++++>+++>+++++++>+++++++++++<<<<-]>+++++.>.>>++.<.++++++++++++++.++++++++++++++++++.--------.<+++++++.<--..>+.--------.>..<+++++++++++++.<------.>>--------.>++.
21:04:32 <calamari> E!ps
21:04:32 <jix> G!{(EE)}
21:04:33 <EsoBot> 3:GlassBot
21:04:33 <EsoBot> G!{M[me(EE)!ee.?]}
21:04:33 <GlassBot> OK
21:04:39 <calamari> E!ps
21:04:40 <EsoBot> No processes.
21:04:46 <GregorR> lol, bot war.
21:05:07 <calamari> how about glass eso and false
21:05:19 <GregorR> I'm doing that now :)
21:05:26 <calamari> lol.. I should have known
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:05:55 <GlassBot> OK
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:05 <GregorR> calamari: No
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:18 <falsebot> G!{M[me(EE)!ee.?]}
21:06:20 <GlassBot> E!bf +++++++++++++++[>++++++++>+++++>++>++++++<<<<-]>>-----.>+++.+.<+.>-.<<+++.>++++++.>>+.++++++++++++++++++.--------.<+++++++.<--------..>+.--------.>..<+++++++++++++.<------.>>--------.<<<++.>>------------.
21:06:21 <EsoBot> F!"G!{M[me(EE)!ee.?]}"
21:06:22 <falsebot> G!{M[me(EE)!ee.?]}
21:06:23 <GlassBot> E!bf +++++++++++++++[>++++++++>+++++>++>++++++<<<<-]>>-----.>+++.+.<+.>-.<<+++.>++++++.>>+.++++++++++++++++++.--------.<+++++++.<--------..>+.--------.>..<+++++++++++++.<------.>>--------.<<<++.>>------------.
21:06:24 <EsoBot> F!"G!{M[me(EE)!ee.?]}"
21:06:25 <falsebot> G!{M[me(EE)!ee.?]}
21:06:26 <GregorR> G!{(EE)}
21:06:27 <GlassBot> E!bf +++++++++++++++[>++++++++>+++++>++>++++++<<<<-]>>-----.>+++.+.<+.>-.<<+++.>++++++.>>+.++++++++++++++++++.--------.<+++++++.<--------..>+.--------.>..<+++++++++++++.<------.>>--------.<<<++.>>------------.
21:06:28 <GlassBot> OK
21:06:28 <EsoBot> F!"G!{M[me(EE)!ee.?]}"
21:06:28 <falsebot> G!{M[me(EE)!ee.?]}
21:06:32 <GregorR> :)
21:06:39 <GregorR> Glass can in shell mode, but not in IRC mode.
21:06:41 <graue> great
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:08:55 <GregorR> Same idea :P
21:09:48 <calamari> E!bf ++++++++++++++[>+++++>++>+++++++++>+++>+++++<<<<<-]>.>+++++.+.<+.>-.>---.<<++++++.++++++++++++++.>>--------------.--------.>--.>-..<+.<<.>..>+++++.>------.<<<<++.>>++++++++++++++++++++++++.<+.
21:09:49 <EsoBot> F!"G!{M[me(EE)!ee.?]}"
21:09:50 <falsebot> G!{M[me(EE)!ee.?]}
21:10:00 <GregorR> Sorry calamari, I took out the Glass class :P
21:10:20 <calamari> that's okay
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:10:58 <GregorR> Yeah.
21:11:01 <calamari> cool
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:13:51 <GregorR> lol
21:14:01 <calamari> oops nm that was -t 6
21:14:31 <GregorR> What does that actually do?
21:14:48 <calamari> increases the number of memory cells used
21:15:02 <GregorR> Ah.
21:15:10 <GregorR> And why does it think that this is good: +++++++++++[>++++++>++++++++++>>>>>>>><<<<<<<<<<-]>.>--.-----------.+++++++.
21:15:29 <GregorR> BF! +++++++++++[>++++++>++++++++++>>>>>>>><<<<<<<<<<-]>.>--.-----------.+++++++.
21:15:31 <BFBot> Blah
21:15:38 <calamari> it uses the number of cells you tell it to use
21:15:49 <GregorR> Oh, I see XD
21:15:54 <GregorR> Heheh
21:16:04 <CXI> yay
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:28 <GregorR> So would ORK.
21:16:31 <graue> scoring criteria could include the "compression ratio" achieved by the shortest known 99 bottles of beer program
21:16:31 <CXI> haha
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:03 <falsebot> 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:31 * calamari tries -t 7
21:17:32 <CXI> not by comparison to what I want it to do
21:17:45 <graue> I see
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 <jix> HAHA
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 <CXI> haha
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 <jix> LOL
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:27 <GregorR> Pfft.
21:18:28 <graue> hooray
21:18:30 <calamari> hahhaha
21:18:41 <GregorR> Using the debug class is cheating ;)
21:18:46 <jix> i know
21:18:54 <jix> but it is unstopable without bot admins
21:19:11 <GregorR> True.
21:19:14 <calamari> need to port glass to Java ;)
21:19:27 -!- GlassBot has joined.
21:20:32 <calamari> or you can implement an interpreter in bf ;)
21:20:40 <graue> or Pbrain
21:20:52 <calamari> pbrain looks neat
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:24:11 <GregorR> Mmm, 96 bottles of flood.
21:25:02 <calamari> E!ls bf
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:38 <EsoBot> Lost Kingdom
21:25:39 <EsoBot> (C) Jon Ripley 2004, 2005
21:25:40 <EsoBot> Brainfuck Edition v0.11
21:25:42 <EsoBot>
21:25:43 <EsoBot> To read the back-story enter '!'.
21:25:44 <EsoBot> For a list of commands enter '?'.
21:25:45 <EsoBot>
21:25:46 <EsoBot> Enable long room descriptions (Y/N) ?
21:25:57 <calamari> E!ps
21:25:58 <EsoBot> 3:calamari
21:26:03 <calamari> E!input 3 y\n
21:26:06 <EsoBot>
21:26:08 <EsoBot> Ramshackle Hut
21:26:09 <EsoBot>
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:15 <EsoBot> road.
21:26:19 <GregorR> E!input 3 quit\ny\ny\n
21:26:20 <EsoBot>
21:26:21 <EsoBot> You can see:
21:26:24 <EsoBot> a small wooden box of matches sitting on the table (2)
21:26:27 <EsoBot>
21:26:28 <EsoBot> >
21:26:35 <EsoBot> Are you sure (Y/N) ?
21:26:36 <calamari> haha yes yes will start the game over
21:26:38 <EsoBot>
21:26:40 <EsoBot> *** You have quit ***
21:26:41 <EsoBot>
21:26:42 <EsoBot> You scored 0 points out of a possible 100.
21:26:42 <GregorR> Oh damn, that's right >_<
21:26:43 <EsoBot> You have earned the rank of Amateur.
21:26:44 <EsoBot>
21:26:45 <EsoBot> Another game (Y/N) ?
21:26:46 <EsoBot>
21:26:47 <EsoBot>
21:26:49 <EsoBot>
21:26:50 <EsoBot> Lost Kingdom
21:26:51 <GregorR> E!kill 3
21:26:51 <EsoBot> (C) Jon Ripley 2004, 2005
21:26:53 <EsoBot> Killed 3.
21:26:55 <EsoBot> Brainfuck Edition v0.11
21:27:00 <GregorR> More efficient :P
21:27:25 <calamari> jix: feel free to run that via private message :)
21:27:58 <GregorR> Heheh, awesome.
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:15 <GregorR> Not on the channel ...
21:35:21 <calamari> for pm...
21:35:28 <GregorR> Ah :P
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:35:52 <GregorR> Yeah, that's true.
21:36:03 <calamari> I could limit it to one process per nick
21:37:06 <GregorR> E!ls /
21:37:08 <EsoBot> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
21:37:08 <EsoBot> <html>
21:37:09 <EsoBot> <head>
21:37:10 <EsoBot> <title>Index of /ls</title>
21:37:11 <EsoBot> </head>
21:37:12 <EsoBot> <body>
21:37:13 <GregorR> >_O
21:37:13 <EsoBot> <h1>Index of /ls</h1>
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:22 <EsoBot> <hr></pre>
21:37:23 <calamari> lol
21:37:24 <EsoBot> <address>Apache/2.0.54 (Ubuntu) mod_jk2/2.0.4 Server at localhost Port 80</address>
21:37:24 <GregorR> E!kill 3
21:37:26 <EsoBot> </body></html>
21:37:28 <EsoBot> No such process `3'.
21:37:31 <GregorR> E!ps
21:37:33 <EsoBot> No processes.
21:37:34 <GregorR> Oh, it's done :P
21:37:45 <marcan> lol
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:15 <marcan> in 1 blah
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:49 <calamari> marcan: -1?
21:38:51 <marcan> to specify PID
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:32 <calamari> -1 is numeric as well
21:39:42 <marcan> of course, but less common
21:39:48 <marcan> or in [1] or whatever
21:39:52 <marcan> just come up with something unusual
21:40:00 <GregorR> Ø!
21:40:11 * marcan switches to a UTF-8 console
21:40:15 <calamari> A! ?
21:40:31 <GregorR> Ø = O + /
21:40:32 <jix> 慶!
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:08 <calamari> Ø = {}
21:41:12 <GregorR> Ÿ = char255!
21:41:21 <marcan> actually, not
21:41:30 <GregorR> Err, wait, that's ÿ :P
21:41:31 <calamari> I think it's a little y
21:41:32 <jix> ☣!
21:41:36 <marcan> char 255 is
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:41:54 <marcan> :P
21:42:01 <lament> F!24n;!
21:42:02 <falsebot> twenty-four
21:42:06 <GregorR> Wow.
21:42:07 <lament> F!63n;!
21:42:07 <falsebot> sixty-three
21:42:08 <GregorR> That's awesome.
21:42:13 <lament> F!3n;!
21:42:13 <falsebot> three
21:42:18 <GregorR> F!56437890543n;!
21:42:18 <falsebot> -three
21:42:21 <GregorR> lol
21:42:23 <marcan> F!183;!
21:42:23 <falsebot> Error: 183
21:42:31 <lament> it works only from 0 to 99
21:42:32 <calamari> F!183n;!
21:42:32 <falsebot> -three
21:42:33 <marcan> F!183555;!
21:42:33 <falsebot> Error: 183555
21:42:33 <lament> so as to fit a certain song
21:42:41 <marcan> F!99;!
21:42:42 <falsebot> Error: 99
21:42:45 <marcan> yeah right
21:42:47 <calamari> F!99n;!
21:42:47 <falsebot> ninety-nine
21:42:49 <marcan> oh
21:42:51 <marcan> my bad
21:42:53 <marcan> forgot the n
21:42:55 <marcan> F!99n;!
21:42:55 <falsebot> ninety-nine
21:42:58 <marcan> F!9999n;!
21:42:58 <falsebot> -nine
21:43:17 <lament> the -nine part is correct. The number does end in "-nine" :)
21:43:21 <calamari> F!99a;!
21:43:21 <falsebot> Error: 'a'
21:43:22 <marcan> of course
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:43:52 <marcan> heh
21:43:54 <GregorR> lol
21:44:06 <marcan> would it do anything?
21:44:10 <marcan> does IRC take blank lines?
21:44:24 <calamari> if they are articially padded with spaces, yep
21:44:28 <graue>
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:44:43 <calamari> yes
21:44:50 <marcan> ok, makes sense then
21:44:51 <GlassBot> Maximum time exceeded.
21:45:29 <lament> F!42ANSWER:
21:45:37 <lament> F!ANSWERn;!
21:45:37 <falsebot> Error: Argument to > is not a number
21:45:42 <lament> crap
21:45:52 <jix> GregorR: there are challanges like 99bob etc.. the output is vorgeschrieben(/me is looking that word up)
21:45:57 <lament> F!ANSWER;n;!
21:45:57 <falsebot> forty-two
21:46:07 <lament> QED
21:46:08 <GregorR> Static?
21:46:27 <jix> the output has to be what the challenge says
21:46:31 <lament> ahh
21:46:35 <lament> kolmogorov complexity
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:49:38 <GregorR> lol
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:50:45 <GregorR> Heheh, true.
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:52:50 <jix> -u+a
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:24 <GregorR> Actually, I should say:
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:21 <calamari> graue: why is that?
21:59:37 <GregorR> Because then interpreters can be written in any language, even Java.
21:59:55 <calamari> can you implement a kill?
22:00:14 <graue> if you know how to call system(), you can implement anything you can type at the shell...
22:00:15 <GregorR> Of course.
22:00:19 <calamari> and can it run interactive programs?
22:00:24 <GregorR> Yes.
22:00:44 <calamari> does it exist?
22:00:49 <graue> not yet
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:01:47 <marcan> that'd be nice
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:17 <calamari> err 300 chars
22:02:22 <marcan> and add a flood limit
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:07 <marcan> good then
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:26 <calamari> yeah
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:54 <GregorR> But limited in scope.
22:04:55 <lament> see #math
22:04:55 <graue> why doesn't it support Kipple? that already has a Java interpreter
22:04:59 <graue> as does Glypho
22:05:07 <lament> there's a Mathematica interpreter in #math
22:05:09 <lament> mbot
22:05:10 <calamari> who said it doesn't support them
22:05:15 <GregorR> E!help
22:05:16 <graue> E!help
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:21 <GregorR> E!kipple
22:05:23 <EsoBot> Invalid command `kipple'.
22:05:28 <calamari> it hasn't implemented, but they should be supported
22:05:29 <GregorR> EsoBot said so.
22:05:34 <calamari> there is a difference
22:05:36 <GregorR> -_-
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:56 <graue> yes
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:07:30 <calamari> nah, Java is good
22:07:43 <lament> not really
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:06 <calamari> sure..
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:12 <lament> (and neither is java)
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:41 <calamari> yes
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:05 <marcan> also true
22:15:07 <lament> Which is why i like Python.
22:15:13 <marcan> exactly
22:15:13 <calamari> python.. lol
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:09 <marcan> makes you write clean
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:30 <graue> I like the braces
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:39 <lament> calamari: WOAH
22:16:42 <lament> you're so lucky
22:16:44 <GregorR> What should EgoBot's trigger be?
22:16:53 <marcan> EG!?
22:17:01 <GregorR> Preferably one character.
22:17:03 <lament> i wish i had a job like that!
22:17:05 <calamari> how about just !
22:17:06 <graue> :!
22:17:09 <marcan> just G then or so
22:17:14 <graue> just G?
22:17:17 <lament> Great
22:17:22 <calamari> if it will replace all bots, one char is enough
22:17:30 <GregorR> I'll make it '!' ftm.
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:17:46 <lament> i used ! first! :P
22:18:00 <calamari> lament: you also used EsoBot first.. sorry bout that ;)
22:18:55 <calamari> E!quit
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:18 <calamari> E!1 234\n
22:20:21 <EsoBot> 234: 2 3 3 13
22:20:27 <graue> E!1 2832921\n
22:20:28 <EsoBot> No such process `1'.
22:20:38 <graue> E!bf http://localhost/bf/factor.b
22:20:41 <graue> E!ps
22:20:42 <EsoBot> 1:graue
22:20:44 <graue> E!1 2832921\n
22:20:50 <EsoBot> 2832921: 3 3 3 7 13 1153
22:21:04 <graue> E!1 2812097\n
22:21:05 <EsoBot> No such process `1'.
22:21:54 <graue> E!bf http://localhost/bf/factor.b
22:21:56 <graue> E!1 2812097\n
22:22:02 <calamari> E!ps
22:22:04 <EsoBot> 1:calamari, 2:graue
22:22:18 <graue> argh
22:22:20 <graue> E!2 2812097\n
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:19 <calamari> E!ps
22:23:20 <EsoBot> 1:calamari, 2:graue
22:23:27 <calamari> yeah
22:23:28 <graue> geez, that's slow
22:23:31 <EsoBot> 2812097: 71 39607
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:04 <jix> hmm
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:30:11 <jix> good
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:51:17 <GregorR> Because it's a Pentium 4.
22:52:01 <graue> is this usual and expected behavior?
22:52:14 <jix> usual yes
22:52:26 <jix> killed "my" laptop
22:52:28 <GregorR> Yes.
22:52:32 <graue> dang
22:52:32 <GregorR> Usual and expected.
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:39 <GregorR> Really?
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:09 <calamari> tikes
23:06:16 <calamari> was trying to take down my system
23:06:28 <GregorR> OK, what BF interpreter should I use?
23:06:34 <graue> for what?
23:06:59 <GregorR> EgoBot
23:07:21 <graue> egobfi, of course
23:07:27 -!- EsoBot has joined.
23:07:44 <calamari> E!bf +[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
23:07:45 <GregorR> lol, I'll do that XD
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:00 <calamari> E!1 SHPX LBH\n
23:16:02 <EsoBot> F
23:16:03 <EsoBot> U
23:16:04 <EsoBot> C
23:16:05 <EsoBot> K
23:16:06 <EsoBot>
23:16:07 <EsoBot> Y
23:16:08 <EsoBot> O
23:16:09 <EsoBot> U
23:16:10 <EsoBot>
23:16:11 <calamari> lol
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:02 <calamari> dunno
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:10 <calamari> E!ls bf
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:09 <calamari> aha
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:47 <graue> oh
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:07 <GregorR> Almost got it ...
23:23:54 <calamari> E!ps
23:23:55 <EsoBot> 1:calamari, 2:calamari
23:23:57 <graue> jix: bf2a beats gbf2c by 0.03 ms on mandelbrot
23:24:24 <calamari> E!kill 1
23:24:25 <EsoBot> Killed 1.
23:24:47 <calamari> E!2 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.!
23:24:50 <EsoBot> <
23:24:57 <calamari> E!ps
23:24:59 <EsoBot> No processes.
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:00 <jix> whooo?
23:29:09 <calamari> E!quit
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:22 <calamari> E!1 abcdef\n
23:30:23 <EsoBot> nopqrs
23:30:29 <calamari> E!ps
23:30:31 <EsoBot> 1:calamari
23:30:37 <calamari> E!1 \n
23:30:38 <EsoBot>
23:30:40 <calamari> E!ps
23:30:41 <EsoBot> 1:calamari
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:30:44 <calamari> E!kill 1
23:30:45 <EsoBot> Killed 1.
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:05 <EsoBot> Lost Kingdom
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:08 <EsoBot>
23:31:09 <EsoBot> To read the back-story enter '!'.
23:31:09 <graue> jix: oh
23:31:10 <EsoBot> For a list of commands enter '?'.
23:31:11 <EsoBot>
23:31:12 <EsoBot> Enable long room descriptions (Y/N) ?
23:31:17 <calamari> cool :)
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:34 <graue> jix: that's true
23:31:34 <calamari> E!1 n\n
23:31:36 <EsoBot>
23:31:37 <EsoBot> You are in a small hut by a dirt road.
23:31:39 <EsoBot>
23:31:41 <EsoBot> You can see:
23:31:42 <EsoBot> some matches (2)
23:31:43 <graue> jix: but this isn't using 32768 cells
23:31:43 <EsoBot>
23:31:44 <EsoBot> >
23:31:59 -!- EgoBot has joined.
23:32:04 <GregorR> !ps
23:32:05 <EgoBot> 1 GregorR
23:32:08 <jix> graue: but i have to check every > for an overflow
23:32:11 <graue> true
23:32:17 <GregorR> !bf >+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+.
23:32:18 <EgoBot> Hello World!
23:32:23 <GregorR> :)
23:32:26 <calamari> !bf +[]
23:32:30 <GregorR> !ps
23:32:31 <EgoBot> 1 calamari
23:32:31 <EgoBot> 2 GregorR
23:32:35 <GregorR> I can't kill them yet :P
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:02 <calamari> !ps
23:33:02 <EgoBot> 1 calamari
23:33:03 <GregorR> !ps
23:33:03 <EgoBot> 1 GregorR
23:33:17 <calamari> !ps
23:33:31 <GregorR> I killed your first proc manually btw :P
23:33:34 <calamari> hehe
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:07 <calamari> !ps
23:34:08 <GregorR> !ps
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:34:59 <calamari> very cool start in any case
23:35:21 <graue> yes
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:44:59 <GregorR> Heheh
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:46:56 <jix> ah ok..
23:47:17 <jix> what machine are you using?
23:47:25 <graue> Athlon XP 1800+
23:47:33 <jix> mhz?
23:47:44 <graue> 1536 MHz
23:47:54 <graue> but that's not really an accurate measure of CPU speed of course
23:48:00 <jix> i know
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:20 <jix> ah
23:48:21 <jix> ok
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:48:46 <jix> i used O3
23:48:48 <GregorR> !ps
23:48:49 <EgoBot> 1 GregorR
23:49:08 <GregorR> !bf >+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+.
23:49:08 <EgoBot> Hello World!
23:51:23 <calamari> !bf +[]
23:51:25 <graue> -O0 appears to be the default
23:51:29 <calamari> !ps
23:51:30 <EgoBot> 1 calamari
23:51:30 <EgoBot> 2 calamari
23:51:35 <calamari> ?
23:51:46 <calamari> oh.. for the ps :)
23:51:54 <GregorR> Yeah, ps takes a proc in EgoBot.
23:51:56 <GregorR> !kill 1
23:52:00 <GregorR> !ps
23:52:00 <EgoBot> 1 GregorR
23:52:02 <calamari> can it list the process name?
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:52:53 <GregorR> No URLs yet.
23:53:10 <calamari> !bf ++++++++++..
23:53:31 <graue> !bf +++++++++++++++++++++++++++++++++>++++++++++<[.>.<]
23:53:31 <EgoBot> !
23:53:31 <EgoBot> !
23:53:31 <EgoBot> !
23:53:31 <EgoBot> !
23:53:31 <EgoBot> !
23:53:31 -!- EgoBot has quit (Excess Flood).
23:53:39 <graue> no flood protection yet? :)
23:54:39 <GregorR> No :P
23:54:41 <GregorR> Not 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
←2005-10-23 2005-10-24 2005-10-25→ ↑2005 ↑all