←2005-10-22 2005-10-23 2005-10-24→ ↑2005 ↑all
00:23:07 <GregorR> lol
00:25:00 <calamari> how's that glass conversion going? need a cool language in EsoBot :)
00:25:28 <calamari> I was looking at the logs.. I guess I stole lament's original bot name
00:25:55 <calamari> There was EsoShell, so I named it EsoBot.. oops
00:26:28 <calamari> hmm.. wonder what this does
00:26:54 <calamari> E!bf ++++++++[>++++++++<-]>+[..................................................................]
00:28:37 <calamari> not very much, apparently
00:28:50 <calamari> E!bf +[>+]
00:28:57 <calamari> E!bf <
00:29:00 <EsoBot> Memory pointer position out of range: -1
00:29:06 <calamari> E!ps
00:29:07 <EsoBot> 1:calamari, 2:calamari
00:29:32 <calamari> E!bf +[>+]
00:29:32 <calamari> E!bf +[>+]
00:29:33 <calamari> E!bf +[>+]
00:29:33 <calamari> E!bf +[>+]
00:29:33 <calamari> E!bf +[>+]
00:29:33 <calamari> E!bf +[>+]
00:29:35 <calamari> E!bf +[>+]
00:29:37 <calamari> E!bf +[>+]
00:29:39 <calamari> E!bf +[>+]
00:29:41 <calamari> E!bf +[>+]
00:29:45 <calamari> E!bf +[>+]
00:29:47 <calamari> E!bf +[>+]
00:29:49 <calamari> E!bf +[>+]
00:29:51 <calamari> E!bf +[>+]
00:29:55 <calamari> E!bf +[>+]
00:29:57 <calamari> E!bf +[>+]
00:29:59 <calamari> E!bf +[>+]
00:30:01 <calamari> E!bf +[>+]
00:30:03 <calamari> E!bf +[>+]
00:30:05 <calamari> E!bf +[>+]
00:30:07 <calamari> E!bf +[>+]
00:30:09 <calamari> E!ps
00:30:43 <calamari> hmm, weird.. no output?
00:30:56 <calamari> E!ps
00:31:12 <calamari> hahahaha
00:31:14 <calamari> Exception in thread "Thread-14" java.lang.OutOfMemoryError: Java heap space
00:31:14 <EsoBot> 1:calamari, 2:calamari, 3:calamari, 4:calamari, 5:calamari, 6:calamari, 7:calamari, 8:calamari, 9:calamari, 10:calamari, 11:calamari, 12:calamari, 13:calamari, 14:calamari, 15:calamari, 16:calamari, 17:calamari, 18:calamari, 19:calamari, 20:calamari, 21:calamari, 22:calamari, 23:calamari
00:31:33 <calamari> its still running.. that's amazing
00:31:47 <calamari> E!kill 1
00:31:48 <calamari> E!kill 2
00:32:19 <EsoBot> 1:calamari, 2:calamari, 3:calamari, 4:calamari, 5:calamari, 6:calamari, 7:calamari, 8:calamari, 9:calamari, 10:calamari, 11:calamari, 12:calamari, 13:calamari, 14:calamari, 15:calamari, 16:calamari, 17:calamari, 18:calamari, 19:calamari, 20:calamari, 21:calamari, 22:calamari, 23:calamari
00:32:20 <EsoBot> Killed 1.
00:33:07 <EsoBot> Killed 2.
00:35:28 <calamari> hmm weird
00:35:31 <calamari> E!ps
00:35:32 <EsoBot> 1:calamari, 2:calamari, 3:calamari, 6:calamari, 8:calamari, 9:calamari, 12:calamari, 14:calamari, 16:calamari, 18:calamari
00:35:53 <calamari> guess when it crashes out like that I need to handle it better on my end
00:36:06 <calamari> Java seems to be doing great tho
00:42:20 <calamari> E!quit
00:42:21 -!- EsoBot has quit ("requested by calamari").
00:43:02 -!- EsoBot has joined.
00:47:43 -!- EsoBot has quit ("requested by calamari").
00:48:42 -!- EsoBot has joined.
00:48:53 <calamari> E!bf +[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
00:48:54 <calamari> E!bf +[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
00:48:55 <calamari> E!bf +[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
00:48:56 <calamari> E!bf +[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
00:48:56 <calamari> E!bf +[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
00:48:57 <calamari> E!bf +[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
00:48:58 <calamari> E!bf +[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
00:49:00 <calamari> E!bf +[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
00:49:04 <calamari> E!bf +[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
00:49:06 <EsoBot> Killed 3: Out of memory.
00:49:18 <calamari> E!ps
00:49:20 <EsoBot> 1:calamari, 2:calamari, 4:calamari, 5:calamari, 6:calamari, 7:calamari, 8:calamari, 9:calamari
00:49:40 <EsoBot> Killed 9: Out of memory.
00:49:49 <EsoBot> Killed 5: Out of memory.
00:50:10 <EsoBot> Killed 2: Out of memory.
00:50:21 <EsoBot> Killed 1: Out of memory.
00:50:29 <EsoBot> Killed 7: Out of memory.
00:50:54 <EsoBot> Killed 6: Out of memory.
00:50:59 <EsoBot> Killed 8: Out of memory.
00:51:08 <EsoBot> Killed 4: Out of memory.
00:51:14 <calamari> E!ps
00:51:15 <EsoBot> No processes.
00:56:19 -!- EsoBot has quit ("requested by calamari").
00:56:56 -!- EsoBot has joined.
00:57:07 <GregorR> Dot dot dot.
00:57:27 <GregorR> G!{M[m(_o)O!"EsoBot sux0rzzzz!"(_o)o.?]}
00:57:28 <GlassBot> EsoBot sux0rzzzz!
00:58:10 <calamari> ;)
00:58:27 <calamari> I haven't implemented that whole program save thing, maybe I should
00:58:51 <calamari> of course, with as much as I terminate the bot, it wouldn't be that useful
00:59:01 <GregorR> lol
00:59:15 <GregorR> That's why you save to disk.
00:59:38 <calamari> heh, yeah right
01:00:31 <GregorR> GlassBot does.
01:00:40 <GregorR> G!{M[m(_d)(Debug)!(_d)(cl).?]}
01:00:43 <GlassBot> A Arr Arre Debug Emote F Fib LameQuine M O Rand S V
01:00:50 <GregorR> Those classes are all saved to disk :)
01:01:00 <calamari> cool
01:01:11 <GregorR> G!{M[m(_d)(Debug)!"LameQuine"(_d)(fl).?]}
01:01:12 <GlassBot> lq
01:01:16 <GregorR> G!{M[m(_d)(Debug)!"LameQuine""lq"(_d)(fc).?]}
01:01:17 <GlassBot> (_d)(Debug)!(_o)O!"{M[m"(_o)o.?"M""m"(_d)(fc).?"]}"(_o)o.?
01:01:36 <GregorR> G!{M[m(_l)(LameQuine)!(_l)(lq).?]}
01:01:37 <GlassBot> {M[m(_l)(LameQuine)!(_l)(lq).?]}
01:01:43 <GregorR> Heheh
01:04:36 -!- EsoBot has quit ("requested by calamari").
01:05:10 <calamari> G!{}
01:05:16 -!- EsoBot has joined.
01:05:57 <calamari> G!{
01:05:58 <GregorR> calamari: Congratulations, you've done nothing in Glass ;)
01:06:04 <calamari> G!}
01:06:11 <calamari> G!}{
01:06:15 <GregorR> G!{M[m(_o)O!"The first step to writing a glass program is nothing!"(_o)o.?]}
01:06:15 <calamari> G!}{}
01:06:30 <GregorR> >_O
01:06:50 <calamari> G!._o_O_o_.
01:06:55 <GregorR> That's weird, it's not receiving any input, it didn't even get your {}
01:07:15 <GregorR> G!{M[m(_o)O!"The first step to writing a glass program is nothing!"(_o)o.?]}
01:07:24 <GlassBot> OK
01:07:24 <GlassBot> OK
01:07:24 <GlassBot> OK
01:07:24 <GlassBot> OK
01:07:25 <GlassBot> The first step to writing a glass program is nothing!
01:07:26 <GlassBot> OK
01:07:28 <GlassBot> OK
01:07:30 <GlassBot> The first step to writing a glass program is nothing!
01:07:31 <GregorR> Whoah XD
01:07:36 <calamari> lagged I guess
01:07:39 <GregorR> Yeah.
01:07:49 <GregorR> bbiab
01:10:17 <calamari> G!{Test[main(_o)O!"Hello World!"(_o)o.?]}
01:10:19 <GlassBot> OK
01:10:50 <calamari> oops
01:10:58 <calamari> G!{(Test)[(main)(_o)O!"Hello World!"(_o)o.?]}
01:10:59 <GlassBot> OK
01:11:50 <calamari> G!{M[(main)(_o)O!"Hello World!"(_o)o.?]}
01:12:19 <calamari> G!{M[m(_o)O!"Hello World!"(_o)o.?]}
01:12:21 <GlassBot> Hello World!
01:12:32 <calamari> G!{(Main)[m(_o)O!"Hello World!"(_o)o.?]}
01:12:33 <GlassBot> OK
01:13:58 <calamari> aha, has to be M m
01:15:00 <calamari> G!{(Main)[m(var)O!"Hello World!"(var)o.?]}
01:15:01 <GlassBot> OK
01:15:05 <calamari> G!{(M)[m(var)O!"Hello World!"(var)o.?]}
01:15:06 <GlassBot> Hello World!
01:15:36 <calamari> G!{M[m(vara)O!"Hello World!"(varb)o.?]}
01:21:26 <calamari> G!{(M)[m(o)O!"Hello World!"(o)o.?]}
01:21:28 <GlassBot> Hello World!
01:21:33 <calamari> G!{(M)[moO!"Hello World!"oo.?]}
01:21:35 <GlassBot> Hello World!
01:21:40 <calamari> G!{M[moO!"Hello World!"oo.?]}
01:21:41 <GlassBot> Hello World!
01:21:50 <calamari> G!{M[moO!"Hello World!""a"oo.?]}
01:21:51 <GlassBot> a
01:21:57 <calamari> G!{M[moO!"Hello World!"oo.?]}
01:21:59 <GlassBot> Hello World!
01:22:16 <calamari> G!{M[moO!"Hello World!"oo.?]}{}
01:22:17 <GlassBot> Hello World!
01:22:26 <calamari> G!{M[moO!"Hello World!"oo.?]}{M[moO!"Hello World!"oo.?]}
01:22:27 <GlassBot> Hello World!
01:22:34 <calamari> G!{M[moO!"Hello Worlda!"oo.?]}{M[moO!"Hello Worldb!"oo.?]}
01:22:35 <GlassBot> Hello Worldb!
01:27:04 <calamari> BF!+.
01:27:06 <BFBot> <CTCP>
01:27:31 <calamari> BF!+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
01:27:40 <BFBot> Infinite loop?
01:28:33 <calamari> BF!<
01:28:35 <BFBot> Range error!
01:28:38 <calamari> BF!]
01:28:39 <BFBot> Unmatched [ or ]
01:28:41 <calamari> BF![
01:28:43 <BFBot> Unmatched [ or ]
01:28:47 <calamari> BF!@
01:28:55 <calamari> BF!#
01:29:09 -!- cmeme has quit ("Client terminated by server").
01:29:37 <calamari> BF!+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
01:29:38 <BFBot> Infinite loop?
01:29:44 -!- cmeme has joined.
01:30:16 <calamari> BF!+[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+.
01:30:17 <BFBot> Infinite loop?
01:30:33 <calamari> BF!+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+.
01:30:35 <BFBot> <CTCP>
01:30:45 <calamari> BF!+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]+.
01:30:46 <BFBot> Unmatched [ or ]
01:31:15 <calamari> BF!-.
01:31:16 <BFBot>
01:31:24 <calamari> E!-.
01:31:25 <EsoBot> Invalid command `-.'.
01:31:30 <calamari> E!bf -.
01:31:32 <EsoBot> ?
01:32:03 <calamari> E!bf +++++++++++++++[>++++++++++++++++<-]>+++++++++++++++.
01:32:05 <EsoBot>
01:33:37 -!- cmeme has quit (Client Quit).
01:34:12 -!- cmeme has joined.
01:38:11 -!- calamari has quit ("Leaving").
01:44:01 <Robdgreat> E!bf ++++++++++[>++++++++<-]>++++++++.
01:44:03 <EsoBot> X
01:56:20 <GregorR> Heh
01:57:34 <GregorR> G!Uhttp://pastebin.ca/raw/26340
01:57:40 <GlassBot> OK
01:58:09 <GregorR> G!{M[m(_b)(BF)!"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++."(_b)(bf).?]}
01:58:32 <GregorR> Hmm...?
01:58:59 <GregorR> G!{M[m(_d)(Debug)!(_d)(cl).?]}
01:59:01 <GlassBot> A Arr Arre BF Debug Emote F Fib LameQuine M Main O Rand S T Test V
01:59:05 <GregorR> G!{M[m(_d)(Debug)!"BF"(_d)(fl).?]}
01:59:07 <GlassBot> bf
01:59:12 <GregorR> G!{M[m(_d)(Debug)!"BF""bf"(_d)(fc).?]}
01:59:13 <GlassBot> (_a)A!(_o)O!(_s)S!(_p)1=,(_pp)<0>=(_m)(Arr)!(_mp)<0>=(_pc)(_pp)*(_p)*(_s)l.?(_a)(le).?=/(_pc)(_pcur)(_p)*(_pp)*(_s)i.?(_s)(sn).?=(_isc)(_pcur)*<43>e.?=/(_isc)(_isc)<0>=(_c)(_mp)*(_m)g.?=(_c)(_c)*<1>(_a)a.?=(_mp)*(_c)*(_m)s.?\(_isc)(_pcur)*<45>(_a)e.?=/(_isc)(_isc)<0>=(_c)(_mp)*(_m)g.?=(_c)(_c)*<1>(_a)s.?=(_mp)*(_c)*(_m)s.?\(_isc)(_pcur)*<60>(_a)e.?=/(_isc)(_isc)<0>=(_mp)(_mp)*<1 >(_a)s.?=(_b)(_mp)*<0>(_a)(lt).?=/(_b)^\\(_isc)(_pcur)*<62>(_a)e.?=/(_isc
01:59:21 <GregorR> Heheh, that's too long :P
02:09:28 -!- CXI has quit (Connection timed out).
02:17:53 <GregorR> G!{M[m(_b)(BF)!"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++."(_b)(bf).?]}
02:18:10 <GregorR> *shrugs*
02:20:39 <GregorR> G!Uhttp://pastebin.ca/raw/26342
02:20:47 <GlassBot> OK
02:20:55 <GregorR> G!{M[m(_b)(BF)!"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++."(_b)(bf).?]}
02:20:56 <GlassBot> A
02:20:59 <GregorR> ^_^
03:51:47 -!- kipple has quit (Read error: 110 (Connection timed out)).
03:58:19 -!- GlassBot has quit (Read error: 104 (Connection reset by peer)).
03:58:29 -!- GregorR has quit (Remote closed the connection).
04:19:54 -!- GregorR has joined.
04:20:22 -!- BFBot has quit (Read error: 110 (Connection timed out)).
04:20:35 <GregorR> Sorry 'bout that, had to restart.
04:20:38 -!- GlassBot has joined.
04:20:47 -!- BFBot has joined.
04:44:27 <Robdgreat> word
04:59:32 -!- Arrogant has joined.
05:11:48 <GregorR> G!{M[m(_o)O!"Hello, Arrogant!"(_o)o.?]}
05:11:49 <GlassBot> Hello, Arrogant!
05:35:34 <Robdgreat> so what's everybody up to?
05:38:20 <Arrogant> That's your new language eh?
05:38:47 <Arrogant> Looks different
05:54:56 <GregorR> Heheh
05:55:47 <GregorR> It's OO!
06:04:11 <GlassBot> OK
06:04:14 <GlassBot> OK
06:04:23 <GregorR> Hmm, why is it responding in the wrong channel ...
06:04:43 <GregorR> Oh, I see ^_^
06:40:55 -!- EsoBot has quit (Remote closed the connection).
06:42:53 -!- GregorR has quit ("brb").
06:52:31 -!- GregorR has joined.
06:53:06 <GregorR> G!{M[m(_o)O!"I'm still alive!"(_o)o.?]}
06:53:07 <GlassBot> I'm still alive!
06:53:16 <GregorR> Yeah, figured as much.
06:53:18 <GregorR> Oh, never mind :P
07:06:14 -!- tokigun has quit (Remote closed the connection).
07:10:20 -!- tokigun has joined.
07:46:30 <tokigun> hello everyone
07:46:46 <GregorR> 'lo tokigun
07:46:52 <tokigun> well
07:46:59 <GregorR> G!{M[m(_o)O!"Hi tokigun!"(_o)o.?]}
07:47:01 <GlassBot> Hi tokigun!
07:47:15 <tokigun> hmm, irc bots everywhere ;)
07:47:50 <GregorR> BF!+++++++++++++++[>+++++>+++++++>+++++++>++<<<<-]>---.>>.>++.<+++++++++++.<++++++.----.--.--.>+.-------.>+.
07:47:51 <BFBot> Hi tokigun!
07:47:58 <GregorR> F!"Hi tokigun!"
07:47:58 <falsebot> Hi tokigun!
07:48:06 <GregorR> Aww, EsoBot isn't on :P
07:48:07 <tokigun> hmm
07:48:26 <tokigun> falsebot for False, BFBot for brainfuck, GlassBot for Glass, EsoBot for what?
07:48:38 <tokigun> http://tokigun.daybreaker.info/irclog/?network=freenode&channel=esoteric
07:48:41 <GregorR> EsoBot is like EsoShell, it runs several (but really just BF)
07:48:57 <tokigun> aha
07:50:42 <GregorR> Hmm
07:50:45 <GregorR> Another logger?
07:50:46 -!- CXI has joined.
07:50:47 <tokigun> i've took midterm exam...
07:50:50 <tokigun> GregorR: yes
07:51:10 <GregorR> Which user here is logging there? :P
07:51:14 <tokigun> i've used it for logging hanirc channels, but it works well for freenode :)
07:51:30 <tokigun> my irssi log
07:51:34 <GregorR> Ahh
07:51:44 <GregorR> So it's not another cmeme, clog, it's a real person :P
07:51:50 <tokigun> (with small php script for parsing irssi coloring)
07:51:53 <tokigun> :)
07:53:10 <tokigun> php code looks like this: http://tokigun.daybreaker.info/irclog/?action=source
07:53:55 <GregorR> Not much of a fan of comments, are you? ;)
07:55:01 <tokigun> ;)
07:56:11 <GregorR> G!{M[m(_o)O!"^QUIT :Upgrades!"(_o)o.?]}
07:56:14 -!- GlassBot has quit ("Upgrades!").
07:57:33 -!- GlassBot has joined.
07:58:32 <GregorR> G!{M[m(_o)O!(_a)A!" "(_n)<500>=/(_n)(_n)(_n)*<1>(_a)s.?0(_o)o.?\,]}
07:58:41 <GregorR> Whoops, that's not quite right ...
07:58:43 <GlassBot> Maximum time exceeded.
07:58:47 <GregorR> G!{M[m(_o)O!(_a)A!" "(_n)<500>=/(_n)(_n)(_n)*<1>(_a)s.?=0(_o)o.?\,]}
07:58:49 <GlassBot> Flood!
07:58:54 <GregorR> Good GlassBot :)
07:59:35 <GregorR> G!{M[m(_d)(Debug)!"BF""bf"(_d)(fc).?]}
07:59:38 <GlassBot> (_a)A!(_o)O!(_s)S!(_p)1=,(_pp)<0>=(_m)(Arr)!(_mp)<0>=(_pc)(_pp)*(_p)*(_s)l.?(_a)(le).?=/(_pc)(_pcur)(_p)*(_pp)*(_s)i.?(_s)(sn).?=(_isc)(_pcur)*<43>(_a)e.?=/(_isc)(_isc)<0>=(_c)(_mp)*(_m)g.?=(_c)(_c)*<1>(_a)a.?=(_mp)*(_c)*(_m)s.?\(_isc)(_pcur)*<45>(_a)e.?=/(_isc)(_isc)<0>=(_c)(_mp)*(_m)g.?=(_c)(_c)*<1>(_a)s.?=(_mp)*(_c)*(_m)s.?\(_isc)(_pcur)*<60>(_a)e.?=/(_isc)(_isc)<0>=(_mp)(_mp)*<1>(_a)s.? Flood!
07:59:42 <GregorR> Okidoke
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:04:41 <tokigun> who is running GlassBot? GregorR?
08:04:45 <GregorR> Yup.
08:04:51 <GregorR> Since I'm the only person who knows Glass :P
08:04:57 <tokigun> aha ;)
08:05:17 <GregorR> I'm also running BFBot.
08:05:50 <tokigun> well, then who's running falsebot and EsoBot?
08:05:57 <GregorR> falsebot: lament
08:06:00 <GregorR> EsoBot: calamari
08:09:47 <GregorR> BF!++++++++++[>+++++++>++++++++++++>+++>+++++<<<<-]>.>>+++.+.<<+.>>-.<+++.<++++++.++++++++++++++.>--------------.++.--------------------------------.>.+.>+.+.--------.----------.<<<-------------------------.>.+++++.-.>-.>.<<<---------------.+.--------.>>>.<<++++++++++++++++++++++++++++..<++.+++++++++++++++++.++++++++++++++++++++++++++++++.>++++++++++++++.>+.
08:09:48 <BFBot> F!"G!{M[moO!"34,"BOTS!"34,"oo.?]}"
08:09:48 <falsebot> G!{M[moO!"BOTS!"oo.?]}
08:09:51 <GlassBot> BOTS!
08:10:00 <GregorR> That's the fun of bots :)
08:19:34 <tokigun> ehm
08:19:44 <tokigun> i'm setting my own irc bot -- tokinyaan
08:21:06 <GregorR> To do a language?
08:24:01 <tokigun> hmmmm
08:30:42 <GregorR> Sorry to flood, but:
08:30:44 <GregorR> 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
08:30:46 <GregorR> 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
08:30:48 <GregorR> 12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
08:31:35 <GregorR> 400 >_O
08:38:59 -!- Arrogant has quit (Read error: 113 (No route to host)).
09:44:09 -!- puzzlet has joined.
10:09:28 -!- marcan has joined.
12:48:05 <CXI> haha
12:48:13 <CXI> here's a challenge - come up with a dual quine
12:48:40 <CXI> when you run it in brainfuck it returns its own sourcecode in False
12:48:49 <CXI> when you run it in False it returns the original brainfuck source
12:48:57 <CXI> then run it in here and the bots explode... :o
14:59:18 <fizzie> Phew. Managed to build a 4-bit ripple-carry adder with OpenTTD.
16:25:03 -!- Sgep has joined.
16:25:27 <Sgep> hi-all
16:50:32 -!- kipple has joined.
17:36:10 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
17:36:56 -!- mtve has quit (Read error: 110 (Connection timed out)).
17:38:34 -!- puzzlet has joined.
18:47:59 -!- mtve has joined.
18:54:22 -!- graue has joined.
19:36:39 -!- Sgep has changed nick to Sgep|test.
19:40:55 -!- Sgep|test has changed nick to Sgep|tet.
19:41:25 -!- Sgep|tet has changed nick to Sgep.
19:42:12 * GregorR dances.
19:45:11 <GregorR> G!{(FE)[(fe)(_o)O!(_s)S!<34>(_s)(ns).?"F!"(_o)o.?0(_o)o.?"{M[m(_fe)(FE)!(_fe)(fe).?]}"(_o)o.?0(_o)o.?,]}
19:45:15 <GlassBot> OK
19:45:24 <GregorR> CXI: Just for you!
19:45:33 <GregorR> Oh wait, I missed something ;)
19:45:38 <GregorR> G!{(FE)[(fe)(_o)O!(_s)S!<34>(_s)(ns).?"F!"(_o)o.?0(_o)o.?"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"(_o)o.?0(_o)o.?,]}
19:45:40 <GlassBot> OK
19:45:43 <GregorR> CXI: Just for you!
19:45:56 <GregorR> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:45:56 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:45:58 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:45:58 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:00 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:46:01 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:02 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:46:02 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:04 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:46:04 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:06 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:46:07 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:08 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:46:09 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:10 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:46:11 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:12 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:46:15 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:16 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:46:17 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:18 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:46:19 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:20 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:46:21 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:22 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:46:23 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:24 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:46:25 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:26 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:46:27 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:28 <GlassBot> F!"G!{M[m(_fe)(FE)!(_fe)(fe).?]}"
19:46:29 <falsebot> G!{M[m(_fe)(FE)!(_fe)(fe).?]}
19:46:29 -!- GlassBot has left (?).
19:46:32 <GregorR> :)
19:46:41 -!- GlassBot has joined.
19:47:53 <GregorR> G!{(FE)}
19:47:54 <GlassBot> OK
19:50:01 <GregorR> G!{M[m(_d)(Debug)!(_d)(cl).?]}
19:50:03 <GlassBot> A Arr Arre BF Debug Emote F FE Fib LameQuine M Main O Rand S T Test V
19:50:26 <GregorR> G!{M[m(_d)(Debug)!"T"(_d)(fl).?]}
19:50:27 <GlassBot> m
19:50:32 <GregorR> G!{M[m(_d)(Debug)!"Test"(_d)(fl).?]}
19:50:34 <GlassBot> main
19:50:40 <GregorR> Heh
19:52:05 <graue> time for a sceqlbot?
19:52:18 <GregorR> The more the merrier!
19:55:30 <graue> do you have some sort of "bot that just connects and parses messages" program to base these things off of?
20:06:29 <GregorR> No XD
20:06:54 <GregorR> But I could build one *shrugs*
20:09:01 <lament> graue: in python, there's irclib.py
20:09:02 <Sgep> Sgeo_
20:09:17 <graue> sadly, I do not know python
20:10:11 <fizzie> In Java there's a few irc-bot libraries too.
20:10:23 <graue> I was thinking along the lines of C
20:11:13 <fizzie> I would assume there to be some pre-made libraries for C too. Or you could write an eggdrop module.
20:12:02 <GregorR> graue: The easiest thing to do would be to use netcat for your network connection and then just parse stdin, it's really a very simple protocol.
20:12:25 <graue> ah, netcat
20:12:41 <GregorR> It's how GlassBot and BFBot work :P
20:19:29 <graue> I've lost the desire to do this
20:21:35 <lament> just learn python :)
20:21:47 <graue> I've tried, many times
20:21:52 <graue> python is *not* my style
20:22:52 <fizzie> You've seen the Python love story video?
20:25:27 <graue> no
20:25:58 <graue> explain?
20:27:33 <cpressey> GregorR: now do it between two bots whose owners are away
20:27:57 <GregorR> Well, since I own all but one of the bots in this room, that's impossible ;)
20:28:12 <cpressey> oh
20:29:21 <lament> F!["F!G;!"]G:
20:29:25 <lament> F!G;!
20:29:25 <falsebot> F!G;!
20:31:22 <CXI> haha
20:31:25 <CXI> Gregor: that's awesome :D
20:31:41 <CXI> graue: had a look at ruby?
20:31:47 <fizzie> graue; this one: http://www.ibiblio.org/pub/multimedia/video/obp/IntroducingPython.mpg (picked up the url from #scheme).
20:33:16 <lament> i still don't understand how can anybody possibly not like Python :)
20:33:26 <lament> well, okay, i understand that. But preferring C to Python?
20:33:46 <graue> lament: C is a much smaller and more predictable language
20:34:02 <lament> Python is quite small.
20:34:14 <graue> didn't seem that way to me
20:34:28 <CXI> C is pretty amazingly small
20:34:29 <GregorR> Ye gads XD
20:35:20 <CXI> but yeah, sometimes I want more... elegant, than small
20:35:28 <CXI> and a lot of C feels very hacky
20:35:35 <lament> graue: brainfuck is much smaller and more predictable than C
20:35:43 <GregorR> SMALLER?!?!?!?
20:35:58 <cpressey> and far more elegant
20:36:04 <lament> indeed
20:36:11 <cpressey> so there
20:36:20 <graue> but with a cost in terms of maintainability
20:36:33 <CXI> actually, I've been meaning to ask
20:36:38 <CXI> what does python do that's so amazing?
20:36:53 <GregorR> It has significant whitespace!
20:36:57 <lament> CXI: it's extremely readable. It makes sense.
20:36:57 <GregorR> YAAAAAAAAAAAAAY
20:36:58 <CXI> like, I had a brief look at it, but nothing really struck me as "wow, this is awesome"
20:37:41 <graue> usually my attempts to learn Python end when I get sick of the billion exceptions I have to be looking for constantly, or how obscure the rules for deep vs. shallow copies are
20:37:56 <lament> graue: uhhh
20:38:00 <lament> doesn't sound like any python i know of
20:38:12 <lament> interesting.
20:38:23 <CXI> doesn't python have subclassed exceptions?
20:38:29 <CXI> and an inbuilt exception handler anyway?
20:38:52 <lament> the copying semantics in Python are extremely simple:
20:38:58 <lament> nothing ever gets implicitly copied.
20:39:08 <lament> unlike c!
20:39:15 <graue> not even numbers?
20:39:16 <lament> where some things are copied and some are passed by reference...
20:39:24 <graue> that doesn't sound like any C I know of
20:39:41 <lament> graue: arrays are passed by reference
20:39:50 <graue> no, they degrade into pointers
20:39:55 <graue> nothing is ever passed by reference
20:39:59 <cpressey> there are no "arrays" in C
20:40:03 <CXI> basically - in C everything's copied, in python everything's referenced
20:40:10 <lament> cpressey: that's the problem. There are.
20:40:12 <CXI> (also, in ruby... *drool*)
20:40:15 <graue> cpressey: they're mere syntactic sugar, but they do exist
20:40:22 <lament> CXI: (no. Arrays are not copied)
20:40:23 <cpressey> lament: no, only pointer arithmetic.
20:40:33 <CXI> well, it depends how you look at it
20:40:33 <lament> cpressey: read the standard :)
20:40:44 <CXI> I visualise arrays as pointers, in which case the pointers are copied
20:40:59 <CXI> but I understand what you mean, it is confusing
20:41:02 <lament> aanyway
20:41:11 <cpressey> lament: are you suggesting that C99 says that arrays are passed by reference?
20:41:27 <lament> cpressey: it says they decay into pointers. You can't pass arrays at all.
20:41:46 <graue> which makes perfect sense
20:41:56 <cpressey> which doesn't suggest "pass by reference" to me at all
20:41:58 <lament> cpressey: C arrays have a very obscure existence. The main reason you can tell they're there at all is because sizeof() knows about them
20:42:06 <cpressey> ah well
20:42:07 <cpressey> sizeof is a hack
20:42:11 <lament> yes, it is.
20:42:24 <lament> but sizeof treats arrays differently from pointers
20:42:28 <lament> therefore, the two are different
20:42:31 <GregorR> #include <sys/types.h> ... uint_32 :) :)
20:42:43 <lament> graue: anyway!
20:42:47 <graue> what would you use instead of sizeof if you were designing C over again?
20:42:51 <lament> like i said, in python everything is passed by ref. No exceptions.
20:43:01 <CXI> heh, exceptions
20:43:12 <lament> graue: but things like numbers are immutable
20:43:16 <cpressey> graue: explicit byte arrays, probably.
20:43:30 <lament> graue: so it doesn't matter if they're ppassed by ref or by val - you can't modify them anyway
20:43:38 <CXI> hey Gregor, how do the bots avoid getting in an infinite loop?
20:43:41 <cpressey> lament: what if i want a guarantee that some function won't change the object i pass to it?
20:43:49 <GregorR> BF!+[]
20:43:52 <BFBot> Infinite loop?
20:43:58 <GregorR> G!{M[m(_a)<50>=/(_a)\]}
20:44:02 <CXI> counter?
20:44:04 <lament> cpressey: pass it an immutable object :)
20:44:08 <GregorR> CXI: Yup.
20:44:09 <GlassBot> Maximum time exceeded.
20:44:09 <lament> cpressey: no guarantees otherwise.
20:44:17 <CXI> fair enough :)
20:44:20 <CXI> in ruby you can do object.freeze
20:44:23 <cpressey> lament: so it has to be on a per-object basis, not a per-function basis?
20:44:26 <CXI> which is fun
20:44:29 <cpressey> man, even C does better than that
20:44:30 <GregorR> CXI: BFBot has a counter for each loop, GlassBot has a counter for the total time.
20:44:35 <CXI> ah
20:44:44 <lament> cpressey: python is very, very lax about "guarantees".
20:45:10 <GregorR> Clearly a good thing, right? :P
20:45:12 <lament> it's extremely dynamic
20:45:13 <cpressey> clearly.
20:45:18 <lament> which is a valid reason not to like it
20:45:24 <lament> but usually not the reason why people don't :)
20:45:49 <CXI> I feel like doing some genetic programming... it sounds totally neat
20:45:50 <GregorR> I don't particularly dislike the structure, etc, I just can't wrap my head around the notion of significant indentation. It just seems a bit silly :P
20:46:06 <CXI> heh
20:46:08 <lament> GregorR: you indent your programs anyway, right?
20:46:10 <CXI> it strikes me as gimmicky
20:46:11 <cpressey> well, if i wanted "extremely dynamic" i'd probably go with ruby, honestly.
20:46:18 <cpressey> but, generally i don't
20:46:18 <lament> GregorR: so, just keep indenting them.
20:46:29 <lament> ruby and python aren't all that different
20:46:39 <lament> but yeah.
20:46:40 <cpressey> lament: oohh.. don't tell that to a rabid ruby fan
20:46:46 <CXI> haha
20:46:46 <GregorR> lament: If I want to write a quick program and don't have an auto-indenting text editor, I usually won't indent because I just need a quick program.
20:46:46 <lament> cpressey: oh, i know
20:46:52 <CXI> speaking as a rabid ruby fan, they're not that different
20:46:58 <lament> cpressey: but it's true :)
20:47:04 <GregorR> I like ruby.
20:47:08 <cpressey> CXI: are you also a rabid python fan? :)
20:47:15 <CXI> actually, I never really got into python
20:47:27 <CXI> if only because I don't much see the point after using ruby
20:47:28 <lament> many rabid python fans would get offended as well
20:47:35 <lament> yeah, that's it really
20:47:39 <lament> if you know one of (python, ruby)
20:47:44 <lament> there's very little reason to learn the other
20:47:49 <cpressey> lament: well, ruby does have that smalltalk-ish gimmick where you can alter the class structure at runtime... i've not heard of that been done in python.
20:47:54 <lament> they fit the same niche
20:48:00 <lament> cpressey: you can.
20:48:03 <CXI> heh
20:48:08 <CXI> ruby is stupidy dynamic
20:48:19 * CXI remembers writing some code to update itself while running
20:48:21 * GregorR huggles C++
20:48:23 <cpressey> lament: excellent. i guess.
20:48:33 <CXI> include $0; if I remember :/
20:48:41 <cpressey> i always thought it was silly to ever design a program where you would want to do that :)
20:48:43 <GregorR> I love you C++, you're my only friend. Except for C.
20:48:44 <lament> i like python more because it reminds me of perl less :)
20:48:48 <cpressey> kind of like self-modifying code
20:48:52 <CXI> well
20:48:56 <CXI> it was an irc bot
20:49:03 <CXI> and I didn't want to lose the connection on every change
20:49:33 <lament> c++ makes me really, really scared
20:49:35 <CXI> I quite like perl, but it's got that same hacky feeling
20:49:39 <graue> by the way, thanks for introducing me to Lua, cpressey
20:49:54 <lament> CXI: it certainly does.
20:49:55 <graue> I haven't done much with it yet, but it's the first high-level language that's seemed interesting to me (for more than 15 minutes)
20:49:55 <GregorR> I hate perl a lot. I am an advocate for banning all new perl code.
20:50:00 <lament> CXI: it's esoteric.
20:50:04 <GregorR> Want to write perl? Write python.
20:50:09 <cpressey> graue: err... you're welcome? (i wasn't aware i was introducing anything to anyone :)
20:50:12 <CXI> haha
20:50:22 <graue> cpressey: in a discussion awhile ago you mentioned it
20:50:27 <cpressey> ah, ok.
20:50:30 <CXI> perl was what I wrote random things in before I found ruby
20:50:37 <cpressey> well, it's true that i like lua more than ruby or python
20:50:38 <cpressey> or php
20:50:39 <cpressey> hahahahah
20:50:46 <lament> ruby is a cross between perl and smalltalk :P
20:51:05 <GregorR> PHP for web programming is the best, hands down. People who use PHP for non-web programming, however, are weird :P
20:51:15 <CXI> :D
20:51:24 <lament> GregorR: some people would cut your balls of for saying that.
20:51:29 <lament> GregorR: (i mean the first sentence)
20:51:33 <cpressey> python and php are crippled for any serious functional programming, which is too bad
20:51:34 <lament> s/of/off
20:51:42 <lament> cpressey: i don't see why.
20:52:02 <lament> cpressey: by functional you mean FP?
20:52:04 <cpressey> lament: python doesn't to tail calls, and iirc its lambdas are limited to something like one line of code?
20:52:09 <cpressey> s/to/do
20:52:11 <lament> right
20:52:22 <cpressey> that's crippled in my book :)
20:52:25 <lament> cpressey: python is not MEANT for functional programming.
20:52:29 <lament> of course it's crippled.
20:52:40 <lament> Scheme is not meant for serious OO programming, either.
20:52:49 <lament> you can't have a language do everything.
20:52:55 <CXI> ruby <3
20:53:06 <cpressey> lament: i'm sorry if i've offended you
20:53:10 <lament> haha
20:53:18 <cpressey> i wasn't planning to do any FP in python
20:53:41 <lament> hell
20:53:43 <cpressey> but there are certainly people who would like to do that, and that is their biggest complaint
20:53:43 <graue> I wrote a brainfuck interpreter in Lua once, by the way: http://www.oceanbase.org/graue/junk/bf-fast.lua
20:53:48 <graue> guess I should add that to the file archive
20:53:49 <lament> Guido says he regrets ever putting lambdas in Python
20:54:05 <lament> they give people the wrong impression :)
20:54:08 <cpressey> that's his perogative
20:54:11 <CXI> so, lua is essentially a bunch of C libraries?
20:54:16 <cpressey> i'd rather he just implement them properly
20:54:18 <cpressey> it can't be that hard
20:54:20 <cpressey> lua does it
20:54:25 <cpressey> and it's like 1/5 the size?
20:54:50 <graue> CXI: Lua is a programming language
20:55:23 <GregorR> BTW, what do other people think is the best for web programming?
20:55:26 <CXI> hmm, never mind, I misread something
20:55:31 <CXI> rails!
20:55:36 <CXI> actually, that's a lie, I've never used rails
20:55:48 <CXI> but I hear it has rakefiles instead of makefiles
20:56:03 <GregorR> Why would it need any sort of *akefiles?
20:56:07 <cpressey> ColdFusion, or something else that will tie me into a proprietary cult
20:56:13 <GregorR> LOL
20:56:17 <CXI> heh
20:56:18 <GregorR> cpressey: ASP?
20:56:25 <GregorR> cpressey: ASP .... DOT NET!!!!!?
20:56:29 <cpressey> ah yes, that's the otehr one
20:56:45 <lament> wheeeeee
20:56:47 <CXI> oh awesome!
20:56:49 <fizzie> Rails is what people-I-know often seem to recommend. I've always wanted to try the PLT web server, or some other scheme/continuation-based web thingie, but haven't.
20:56:52 <GregorR> <% response.print "My code looks retarded!" %>
20:56:56 <CXI> "There is not enough room on the disk to save blah.zip..."
20:57:10 <CXI> they added an error dialog to firefox when there's no room
20:57:18 <CXI> instead of just randomly aborting the file transfer halfway through
20:57:22 <GregorR> lol
20:57:46 <lament> heh
20:58:07 <fizzie> Perl and apache and mod_perl and HTML:Mason was a nice enough combination, I guess, it's just that... well, Perl.
20:58:10 <GregorR> So, what I'm understanding is that the only competitor to PHP is ROR?
20:58:31 <GregorR> Perl doesn't count, and along the same lines neither does Brainfuck or False.
20:58:48 <CXI> I was going to mention mod_bf :/
20:58:49 <fizzie> Firefox with gnome-vfs and an smb:// url messed up the download manager pretty badly, when downloading >4G files.
20:58:54 <cpressey> GregorR: well... couldn't you take just about any language and make it "html templatized" ?
20:59:11 <cpressey> not that that is the only trick
20:59:15 <cpressey> to a good web language
20:59:21 <fizzie> -1796223 KB of 375.9 MB at -675.-6 KB/sec; 0-53:0-31 remain
20:59:30 <GregorR> cpressey: I was asking what people preferences were, not what would be possible ;)
20:59:37 <CXI> lua looks pretty
20:59:39 <fizzie> (and then it stopped at 2^32-1 bytes and left me an incomplete file.)
20:59:41 <CXI> not many brackets
20:59:59 <cpressey> GregorR: ok, i don't do much web programming. mostly it's simple cgi-like stuff. so perl is "fine"
21:00:44 <GregorR> Let's all stop this discussion and play libc scrabble ;)
21:01:23 <cpressey> right now i'm learning haskell.
21:01:30 <CXI> haskell is a fun language
21:03:01 <cpressey> yeah, it has its moments
21:03:20 <cpressey> ...although they usually don't involve its syntax. the list patterns, especially. uggh\
21:03:26 <CXI> haha, yeah
21:03:28 <CXI> its syntax is kinda icky
21:03:39 <CXI> but the language itself is quite elegant
21:03:50 <CXI> actually, I'm curious about python
21:03:53 <CXI> how is it in terms of OO-ness?
21:04:27 <cpressey> reputedly good
21:05:00 <cpressey> i'd have to defer to a real python programmer, as i've only hacked up existing python code
21:05:08 <CXI> ah
21:05:08 <lament> haskell is amazing :)
21:05:12 <lament> but waaaay over my head
21:05:22 <lament> CXI: OO-ness is what?
21:06:14 <CXI> well, ruby for example has a really strong and flexible object model...
21:06:28 <CXI> everything's an object, but there are certain defaults set up so it doesn't feel cumbersome (*cough* java)
21:06:55 <cpressey> graue / CXI: the thing that struck me about lua is that i had a vague idea in my mind what an "ideal small scripting language" would look like before i saw it; and then when i saw it, it was like, "oh. that
21:07:05 <cpressey> that's really quite close to what i was thinking"
21:07:06 <cpressey> :)
21:07:15 <lament> CXI: well, everything's an object in Python.
21:07:41 <CXI> lua looks quite pretty
21:07:55 <CXI> very similar to ruby, actually
21:08:26 <cpressey> CXI: yeah, it's pretty hard to obfuscate it. (but far from impossible - just start playing with metatables, and you're pretty much guaranteed to be able to build something that you can't easily understand)
21:09:08 <CXI> heh
21:09:11 <cpressey> dealing with a language means knowing what parts to stay the hell away from
21:09:22 <GregorR> lol
21:09:25 <GregorR> Well put
21:09:31 <cpressey> thanks :)
21:09:41 <lament> python and ruby are rather similar in their OO model. Ruby has more syntax for it, and things like being able to modify existing types
21:10:06 <lament> (can do that in python, but the changes won't apply to existing objects)
21:10:30 <cpressey> ah
21:10:45 <cpressey> that's what i was referring to about changing the class structure at runtime-
21:10:49 <cpressey> applying to existing object
21:11:13 <lament> yeah. you can't do that.
21:12:09 <lament> python doesn't treat functions any different from other objects. ruby does for some reason
21:12:32 <CXI> does it?
21:12:41 <lament> yes
21:13:14 <lament> functions aren't even objects in ruby at all
21:13:19 <lament> you have to do something to them first
21:13:22 <lament> i don't remember the details
21:14:04 <lament> oh, you know what really turned me off ruby? This http://www.rubygarden.org/faq/entry/show/14
21:15:14 <CXI> some random guy ranting about how ruby's better than everything?
21:15:40 <lament> no
21:15:48 <lament> their description of python is _completley wrong_
21:15:56 <lament> and it's on the faq of the official website
21:16:06 <lament> eh. *completely
21:16:41 <lament> it probably wasn't wrong back when it was written
21:16:52 <lament> (python used to suck a lot more than it does now)
21:17:36 <GregorR> How 'bout Glass :)
21:17:38 <CXI> hmm
21:17:49 <CXI> but yeah, it's possible you're thinking of the non-oo way of using functions
21:17:57 <CXI> 'cause ruby has lots of random things like that
21:18:14 <lament> CXI: ruby has that weird special syntax for passing one function
21:18:19 <CXI> yeah
21:18:25 <CXI> because it's a common task
21:19:18 <lament> bah
21:19:19 <lament> ruby sucks
21:19:21 <lament> python sucks
21:19:25 <CXI> :D
21:19:28 <lament> if you want smalltalk you know where to find it :)
21:19:31 <cpressey> the weird (social) thing about ruby and python seems to be how much each camp is concerned with the other. i guess it's just because they're both in almost the same niche?
21:19:59 <lament> i dunno about ruby
21:20:07 <lament> python python fans are much more obsessed with Perl
21:20:13 <lament> s/python python/but python
21:20:21 <cpressey> might be a misperception on my part... i've known a few trolls
21:20:38 <cpressey> yeah, there's perl too... not sure what people think of it anymore
21:20:41 <CXI> http://www.ruby-doc.org/docs/ProgrammingRuby/html/ref_c_proc.html
21:20:53 <CXI> but yeah, python, perl and ruby all occupy a similar space
21:21:25 <lament> python and ruby are MUCH closer to each other than either is to perl, though
21:21:35 <lament> i wouldn't mind programming in either python or ruby
21:21:41 <lament> i would definitely not like having to program in perl
21:22:41 <GregorR> Hmm, which of these thirty obscure forms should I use ... should I pass $_, thus making it so you can't insert another line before this one? Yes, yes I should.
21:22:58 <CXI> haha
21:25:04 <lament> the main difference with perl and other languages lies in the mentality of the programmer :)
21:25:18 <GregorR> The "in" on the "sane"?
21:27:41 <GregorR> print while (<>);
21:27:43 <GregorR> That's the line!
21:27:50 <GregorR> Doesn't that just scream "cat" to you!
21:28:00 <cpressey> it's The Unix Way
21:30:17 <lament> GregorR: no, but it makes _me_ want to scream
21:30:20 <cpressey> if your brain has already been rotted so much by 300 baud teletype sessions with a VAX that you consider awk, sh, and sed to be efficient tools, why not use a language which combines their slapdash functionality while retaining their charming syntaxes?
21:30:30 <fizzie> My problem with Perl is that I always end up playing with references, and then it ends up in code like $t->[$e->[2]->[1]]->[$e->[2]->[2]]->[$e->[2]->[3]]
21:31:35 <GregorR> See, my only problem with perl is that it's terrible in virtually every imaginable way.
21:31:44 <fizzie> Or I go "hey, I haven't used a regular expression in the last 10 lines, must write while(length($rest) > 0 && $rest =~ /^((?:(?:$ex_nt|$ex_t|$ex_e)(?:\s+|$|(?=\|)))*)\s*(?:\||$)\s*(.*)$/) here". (Those are both real-life examples, btw.)
21:32:40 <fizzie> (Although in the latter case there actually seems to be an if(/^\s*($ex_nt)\s*->\s*(.*)$/) 9 lines before.)
21:32:54 <lament> that looks like False
21:33:19 <fizzie> my @rules = sort { $a eq $g->{'start'} ? $b eq $g->{'start'} ? 0 : -1 : $b eq $g->{'start'} ? 1 : $a cmp $b } keys %{$g->{'prods'}};
21:33:22 <fizzie> What does that look like? :p
21:33:46 <GregorR> It looks like I'm dying.
21:33:47 <fizzie> ?: is my favourite operator.
21:34:26 <GregorR> >_<
21:36:10 <fizzie> Isn't there a $_ in Ruby too?
21:36:24 <cpressey> oh no fair, using ternary ?: without parens
21:36:59 <fizzie> That's what precedence is for.
21:37:23 <cpressey> yes, at least perl borrowed that from the language that got it right the first time - C
21:37:39 <cpressey> precedence, that is
21:37:57 <graue> the precedence for some of the bitwise stuff in C is weird
21:38:03 <cpressey> all 24 levels of it
21:38:44 <graue> like a & 1<<b
21:38:50 <graue> which parses as (a&1) << b
21:39:09 <cpressey> yeah, that was probably an outright Mistake
21:39:15 <cpressey> >> and << often have a constant operand
21:39:27 <cpressey> so it "feels" like it should be high precendce
21:40:24 <CXI> heh
21:40:29 <cpressey> hm, but so does &
21:40:31 <fizzie> I think << has a higher precedence than bitwise-&, though.
21:40:35 <cpressey> so maybe my logic is wrong there
21:40:38 <lament> lamen't rules for precendence:
21:40:41 <lament> er
21:40:45 <lament> lament's
21:40:48 <CXI> I want to see more use of the precedence difference between &&/|| and and/or
21:40:56 <lament> rule 1. * has higher precendence than +
21:41:05 <lament> rule 2. The precendence of = is very very low.
21:41:12 <lament> rule 3. For everything else, use parentheses.
21:41:22 <CXI> if (foo and bar || baz or moo)
21:41:52 <fizzie> But (in C) & and | have an abnormally low precedence, and I think someone claimed that came from some long-forgotten era before && and || were invented and people used &, | as logical-and/or.
21:42:03 <lament> makes sense
21:42:07 <lament> false still uses them that way :)
21:42:33 <fizzie> But when I write "a & 1 == 1", I wouldn't assume it to parse as "a & (1 == 1)".
21:43:00 <fizzie> Well, perhaps that's not a good example.
21:43:12 <lament> why not?
21:43:15 <lament> does it actually parse that way?
21:43:35 <fizzie> Yes, according to the first few tables I googled. Haven't checked the standard, but they can't all be wrong.
21:43:49 <cpressey> i think does, or at least, perl does
21:44:03 <cpressey> == has higher prec than &
21:44:05 <fizzie> But I'd probably write just "a & 1", that "== 1" is quite useless. "a & 0x0f == 0x07" is perhaps a better example.
21:45:33 <fizzie> I wonder why C doesn't have a logical XOR, ^^
21:47:41 <GregorR> G!{M[moO!"Glass is better than perl! Glass is better than C! Glass is better than C++! Glass is the best!"oo.?]}
21:47:42 <GlassBot> Glass is better than perl! Glass is better than C! Glass is better than C++! Glass is the best!
21:48:54 <CXI> what the heck is glass anyway?
21:49:09 <GregorR> CXI: http://www.esolangs.org/wiki/Glass
21:49:33 <GregorR> It combines OO with a main stack with all sorts of pointers, making it the least logically designed language /EVER/!
21:50:03 <GregorR> Or, alternatively, the most illogically designed language ever.
21:50:14 <graue> have you written a Brainfuck-to-Glass compiler yet?
21:50:16 <GregorR> Oh, and postfix notation.
21:50:25 <fizzie> Actually it reminded me of the Java VM.
21:50:27 <GregorR> I'm working on a BF interpreter in Glass.
21:50:40 <graue> that will make BFBot obsolete!
21:50:42 <graue> :)
21:50:49 <GregorR> Yup, then I can kill 'im :)
21:50:56 <graue> or, better yet, write a Glass interpreter in Brainfuck
21:51:19 <GregorR> BF!+++++++++++++[>++++++>+++++++++>+++>++++++++<<<<-]>.>------.>+++++.------------.>----.<<.-.>+++++++.<++++++.>-------.>+++++++.--.<<--------..>.<+.>>----.<+.
21:51:21 <BFBot> No, don't kill me!
21:51:33 <Sgep> BFBot?
21:51:43 <GregorR> Sgep: BFBot is a bot ... to run BF :P
21:51:51 <cpressey> fizzie: that (missing ^^) bugged me too, i actually had a thought about it the other day, though: it's probably missing because xor lacks short-circuit semantics
21:52:08 <cpressey> the design methodology of C has always favoured the compiler over the programmer anyway :)
21:52:52 <graue> actually the use of #include (rather than an "import" statement, for instance) is bad for the compiler too, since parsing header files is slow
21:52:52 <lament> ^^ is missing because it would look too cute
21:53:31 <cpressey> graue: ok, in that case, it was favouring the OS's obsession with text files :)
21:53:53 <GregorR> I think #include vs #import is a simple we-didn't-know-any-better-at-the-time problem.
21:55:35 <fizzie> Many compilers cheat with pre-compiled headers and such.
21:58:09 <GregorR> G!{L[a(_a)2=(_b)1=,,/(_a)/(_b)<1>^\<0>^\<0>][o(_a)2=(_b)1=,,/(_a)<1>^\/(_b)<1>^\<0>][x(_a)2=(_b)1=,,/(_a)/(_b)<0>^\<1>^\/(_b)<1>^\<0>][n(_a)1=,/(_a)<0>^\<1>^]}
21:58:11 <GlassBot> OK
21:58:20 <GregorR> Yay, I finally have logic in Glass :P
22:08:24 <GregorR> How do you change the text of the {{stub}} message on Wikimedia?
22:09:33 <GregorR> Never mind, found it.
22:24:00 <graue> starting your own wiki?
22:25:05 <GregorR> No, I was changing the stub message on the Esowiki.
22:25:32 <graue> what?!
22:25:38 <graue> but I loved the existing stub message! :(
22:25:45 <GregorR> I only changed one word.
22:26:03 <graue> we were going to get married in January :(
22:26:13 <GregorR> "It means that it is not detailed enougg" -> "This means that it is not detailed enough"
22:26:17 <GregorR> lol
22:26:41 <GregorR> Except that it didn't say "enougg" :P
22:26:58 <GregorR> So have I hideously scarred and disfigured your bride-to-be?
22:28:51 <graue> yes, but I will scar it some more because it still sounds a bit awkward
22:29:12 <graue> there
23:03:09 -!- calamari has joined.
23:04:54 <graue> hello, calamari
23:05:03 <calamari> hi graue
23:06:44 <graue> where is esobot?
23:07:34 -!- EsoBot has joined.
23:07:35 <calamari> I shut down my computer last night
23:07:39 <graue> E!help
23:07:40 <EsoBot> Commands: bf, cat, help, kill, ls, ps, quit, unnecessary.
23:07:46 <graue> E!help cat
23:07:47 <EsoBot> Commands: bf, cat, help, kill, ls, ps, quit, unnecessary.
23:07:55 <graue> E!man 1 cat
23:07:56 <EsoBot> Invalid command `man'.
23:07:57 <calamari> hehe that was the next thing I was going to work on
23:08:00 <graue> heh
23:08:12 <calamari> the help system isn't very helpful
23:08:26 <calamari> I want to move it to private message, then I can be more verbose
23:08:46 <graue> is this written in java as usual?
23:08:48 <calamari> E!bf +[]
23:08:49 <calamari> yeah
23:09:02 <calamari> E!bf +[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+]
23:09:08 <calamari> E!ps
23:09:13 <EsoBot> 1:calamari, 2:calamari
23:09:18 <EsoBot> Killed 2: Out of memory.
23:09:22 <calamari> E!ps
23:09:24 <EsoBot> 1:calamari
23:09:32 <calamari> E!kill 1
23:09:33 <graue> by the way, as a Java user, what do you think of Glass?
23:09:33 <EsoBot> Killed 1.
23:11:00 <calamari> I haven't learned how to use glass all the way yet, but I like the OO/pointers thing a lot (not many do OO), and it's a great looking language too... so yeah, Glass is very cool :)
23:15:19 <calamari> dunno why, but I think it's really neat that Java can run out of memory yet kill the thread and keep running as if nothing ever happened. Maybe Linux plays a part in that too.. hehe
23:16:02 <calamari> the M$ experience taught me that such things must lead to a crash.. need to unlearn that
23:18:04 <calamari> E!ls
23:18:05 <EsoBot> bf/
23:18:08 <calamari> E!ls bf/
23:18:09 <EsoBot> bfi.b bottles.b factor.b helloum.b LostKng.b prime.b triangle.b
23:18:42 <calamari> E!bf http://localhost/bf/factor.b
23:18:58 <calamari> E!bf input 525454650\n
23:18:58 <graue> doesn't that require input?
23:19:01 <graue> oh
23:19:02 <calamari> oops
23:19:09 <calamari> E!input 1 525454650\n
23:19:10 <EsoBot> No such process `1'.
23:19:14 <calamari> E!ps
23:19:16 <EsoBot> 2:calamari
23:19:18 <calamari> E!input 2 525454650\n
23:19:31 <EsoBot> 525454650: 2 3 3 5 5 7 31 5381
23:20:13 <calamari> the best for spamming the channel is the random.b from the files archive :)
23:20:52 <graue> heh
23:21:06 <calamari> E!bf http://esolangs.org/files/brainfuck/src/random.b
23:21:10 <EsoBot> œua\hpdg౱_ܻrɇyidR@J* 'NH}tocaay^8~N@_HTỎ@=D8:a=wC8_xLYp6Yo[8\6DN
23:21:11 <calamari> E!ps
23:21:12 <EsoBot> 3:calamari
23:21:14 <EsoBot> @-_-Ѣs!X#;_[6$5T
23:21:15 <calamari> E!kill 3
23:21:17 <EsoBot> Killed 3.
23:21:22 <calamari> isn't that lovely
23:21:32 <graue> yes
23:21:58 <graue> I have my laptop now, so maybe I can run Java programs soon (after it downloads 96 updates, that is)
23:22:07 <calamari> breezy?
23:22:36 <graue> no, it's just the security updates for hoary
23:22:40 <calamari> oic
23:22:59 <calamari> breezy isn't that much diffrent than hoary.. hoary was a bit different than warty though
23:23:21 <calamari> I think the warty hoary thing was because of xorg and the newer gnome
23:23:51 <calamari> I wish there was applications:/// again tho :( still can't edit my menus easily
23:24:31 <calamari> They need to make it drag & drop like win98 through xp have all had
23:24:59 <graue> geez, the bandwidth bill for security.ubuntu.com must be huge
23:25:29 <calamari> I think part of the problem is that they are trying to conform to that Linux standard thing (can't think of its name)
23:25:49 <calamari> I've looked at the menu standard they are using, and it's horrible
23:26:10 <calamari> For example, it says that entries should never be delted, just hidden
23:26:26 <calamari> and it's an xml nightmare
23:27:32 <graue> I'm downloading about 158 MB of updates
23:27:32 <graue> the freedesktop.org standards?
23:28:08 <calamari> yeah, those
23:33:31 <graue> agh! ls sorts case-insensitively! and when I press Tab in the shell to get a list of possibilities, it lists dot files!
23:34:42 * graue has gotten very used to the BSD userland, clearly
23:37:27 <calamari> I never noticed the sorting thing, because Windows never cared much about case .. ehhe
23:38:54 <calamari> mine doesn't seem to list . files on tab
23:39:05 <calamari> unless I first type a dot then press tab
23:40:31 <graue> well, it doesn't include . and ..
23:40:59 <graue> but other than that, it definitely does do that here
23:41:00 <calamari> oh, you mean BSD doesn't
23:41:10 <graue> yeah
23:41:16 <graue> bash, as configured on ubuntu, does
23:41:31 <calamari> <shrug>
23:41:37 <graue> I don't understand why it would sort case-insensitively though
23:41:49 <graue> that defeats the whole purpose of "README" and "Makefile" and "COPYING"
23:42:02 <lindi-> graue: what locales are you using?
23:42:34 <calamari> I thought those were upper case just to make them stand out.. learned something new today :)
23:43:27 <calamari> hi lindi, how are you?
23:43:34 <graue> lindi-: I have no idea, so whatever's the default
23:45:26 <lindi-> graue: put the output of "locale" online somewhere
23:45:57 <lindi-> calamari: i'm fine, been busy with bug reports and school stuff, what's up for you?
23:46:26 <calamari> school, work.. messing around in eso-land :)
23:46:30 <calamari> what bug reports?
23:47:42 <lindi-> mostly to gnu classpath but also to random other projects
23:47:59 <graue> lindi-: everything says "en_US.UTF-8"
23:48:02 <calamari> oh, that's right :)
23:48:22 <graue> lindi-: except LC_ALL which is empty
23:48:58 <lindi-> calamari: latest one took a while to find, some statistics stuff in octave was broken and gave wrong results
23:49:31 <calamari> lindi: I hear that work on classpath has really been strong lately, that's great
23:49:40 <lindi-> graue: try "env LC_COLLATE=C ls"
23:49:57 <calamari> maybe someday I'll be able to get my swing apps to work on it
23:49:58 <lindi-> calamari: yep, it's definitely improving
23:50:04 <graue> lindi-: yay
23:50:40 <lindi-> calamari: just give me an url and i can check them out with latest cvs head
23:54:40 <calamari> lindi-: http://lilly.csoft.net/~jeffryj/programs/bf/bfdebug-1.61.jar
23:55:15 -!- GregorR-L has joined.
23:57:17 <graue> didn't someone implement sokoban in befunge once?
23:57:53 <graue> lindi-: what does linux use instead of a .profile?
23:58:04 <lindi-> graue: linux?
23:58:09 <graue> I put "export LC_COLLATE=C" in my .profile but it hasn't helped
23:58:11 <graue> or bash or whatever
23:58:27 <lindi-> bash uses .profile
23:59:21 <lindi-> hmm, or is it just .bash_profile
←2005-10-22 2005-10-23 2005-10-24→ ↑2005 ↑all