00:00:59 <GregorR-L> By the way, I wrote EgoBF, and that is of course why I think it's the best :P
00:02:47 -!- Gs30ng has joined.
00:05:02 <ihope> How about !bf >+[>+]
00:06:04 <ihope> And no on-the-fly data compression?
00:06:20 <ihope> And why no !bf1? :-)
00:06:56 <GregorR-L> EgoBch, the only implementation of BitChanger :)
00:07:21 <ihope> So BF-PDA could be emulated by replacing > with [@]>?
00:08:01 <GregorR-L> BF-PDA could be implemented, and that would be easier :P
00:08:19 <GregorR-L> Hell, it could be implemented in Glass.
00:08:36 <ihope> Does BitChanger have any I/O?
00:08:50 <GregorR-L> http://www.esolangs.org/wiki/BitChanger
00:09:57 <GregorR-L> I don't know whether I used -lazy-io in EgoBot ...
00:10:10 <GregorR-L> If I used -lazy-io, then ',' and '.' are supported as well.
00:12:12 <GregorR-L> Hah, I just remembered something. I wrote a MISC VM and never released it. And MISC is still marked unimplemented :P
00:12:29 <ihope> I want a functional programming language that produces BF programs.
00:13:06 <ihope> Just have BF instructions be primitives.
00:13:51 <Gs30ng> i'm trying to understand Glass
00:15:00 <ihope> Heck, I'd settle for world denomination.
00:15:15 <GregorR-L> !glass {M[m(_d)(Debug!)"JixMath"(_d)(fl).?]}
00:15:36 <GregorR-L> !glass {M[m(_d)(Debug)!"JixMath"(_d)(fl).?]}
00:15:42 <Gs30ng> well, actually it's been a dead long time since i first tried to understand this
00:15:58 <Gs30ng> and still i don't get it
00:16:12 <Gs30ng> not like another works of GregorR
00:17:37 <GregorR-L> OK, /me bangs a gavel. Glass class is now in session.
00:18:10 <GregorR-L> Glass is an Object Oriented programming language, and therefore has classes
00:18:46 <GregorR-L> To declare a class, use the character {, then the name of the class, then the content of the class (to be discussed later), then a }.
00:19:09 <GregorR-L> The name of the class must start with a capital letter (all global variables start with a capital letter).
00:19:39 <GregorR-L> That class won't do anything btw :P
00:19:57 <GregorR-L> If a variable has more than one letter in the name, it must be surrounded in (). So, for a class named Main: {(Main)...}
00:20:14 <ihope> Do classes have scope?
00:20:21 <ihope> Or rather, scopes?
00:20:26 <GregorR-L> You can't have subclasses, if that's what you mean.
00:20:38 <ihope> I was thinking "local classes".
00:21:08 <GregorR-L> All class definitions are global, objects (class implementations) can be global, local, etc.
00:21:09 <Gs30ng> did the name came from the class?
00:21:37 <Gs30ng> origin of the name Glass
00:22:54 <GregorR-L> Lesson #2: Functions or methods, whatever you want to call them :P
00:23:19 <GregorR-L> Inside of a class (and ONLY inside of a class), you may declare functions.
00:23:46 <GregorR-L> To declare a function, use the character [, then the name of the function, then the content of the function (to be discussed later), then a ].
00:24:02 <Gs30ng> only inside of a class?
00:24:06 <GregorR-L> All function names must start with a lower case letter.
00:24:30 <GregorR-L> For example, for a class named M with a function named m: {M[m...]}
00:24:48 <GregorR-L> It's important to note the function M.m, as that's the starting point for a Glass program.
00:25:05 <GregorR-L> As with classes, if the name has more than one letter, it must be surrounded in ()s.
00:25:27 <ihope> How about classes inside parentheses?
00:25:41 <GregorR-L> Parentheses just hold variable names.
00:26:12 <GregorR-L> If you used a {, }, etc, it would consider that as part of the variable name - the only character invalid in a variable name is ).
00:26:32 <ihope> I gotta go in about five minutes...
00:26:35 <GregorR-L> Questions about functions (not the contents, the declaration)?
00:26:46 <GregorR-L> ihope: You'll have to get the rest of the lesson in the logs then :)
00:28:23 <Gs30ng> i prefer functional rather than object-oriented, but it seems to be possible to code functional in Glass
00:28:53 <GregorR-L> There is no Lesson #x: How to abuse Glass
00:29:41 <GregorR-L> Every operation either pushes something onto the stack or does some operations on the stack.
00:29:54 <ihope> A pushity-poppity 'pooter lingo.
00:30:25 <Gs30ng> ah... that's why the language is reverse polish notation
00:30:29 <GregorR-L> To push a /pointer/ to a variable onto the stack, simply use the name of the variable. For example, to push the variable a, all you have to do is 'a'
00:30:57 <Gs30ng> and now i understand what the hell is 'pointer'
00:31:03 <GregorR-L> Now is a good time to mention that any variable that starts with a capital letter is global, lowercase is class-local, _ is function-local.
00:31:30 <GregorR-L> If the name of the variable has more than one character, it must be surrounded in ()s.
00:31:57 <ihope> Is pushing a pointer rather like pushing the variable name In a Different WaY?
00:32:25 <ihope> Well, this is the point where I step out and let logs do all the work.
00:33:04 <GregorR-L> Now, let's say that you didn't want the pointer to _a on the stack, but the value.
00:33:18 <GregorR-L> The operator * dereferences the top element on the stack.
00:33:27 <GregorR-L> So, to push the /value/ of _a onto the stack: (_a)*
00:34:16 <Gs30ng> you mean, i only want to define something, and have nothing to do with a stack, then i add * after the definition?
00:34:54 <GregorR-L> No, that puts the value of _a onto the stack.
00:35:02 <GregorR-L> You don't need to define variables, they're defined on use.
00:35:37 <GregorR-L> While just doing (_a) pushes a pointer to _a on the stack, doing (_a)* puts the value of _a on the stack.
00:35:46 <GregorR-L> (By pushing a pointer then dereferencing it)
00:36:29 <Gs30ng> if a = 3, (a) or a pushes a, and a* pushes 3, right?
00:36:48 <GregorR-L> You can also push other things onto the stack. To push a number, use <num>.
00:37:57 <GregorR-L> You can also push values from deeper into the stack onto the top of the stack.
00:38:17 <GregorR-L> '0' will duplicate the top value on the stack, '1' will duplicate the second value, etc.
00:38:28 <GregorR-L> You can also put those in () if you need 10 or higher.
00:38:57 <GregorR-L> OK, now let's set the value of a variable.
00:39:06 <GregorR-L> Let's say you want to set the value of _a to 1.
00:39:34 <GregorR-L> = sets the variable in stack position 1 to the value in stack position 0, then pops them both off.
00:39:50 <GregorR-L> So, push the pointer to the variable, then the value you want to set it to, then use =
00:40:14 <GregorR-L> (And there's the reverse polish notation :) )
00:40:32 <Gs30ng> no syntactic sugar. i like that
00:40:50 <Gs30ng> then <1>(_a)= causes an error?
00:41:34 <GregorR-L> (Hm, what should I go to next ...)
00:41:51 <GregorR-L> Oh, heh - to just pop something from the stack, use ','
00:42:40 <GregorR-L> To make an instance of a class, use !.
00:43:26 <GregorR-L> First push a pointer to the variable in which you want the instance to the class, then push a pionter to the class itself. Then use '!', and it will pop those and set the variable to an instance of the class.
00:43:42 <GregorR-L> So, to make _o an instance of class O:
00:45:07 <GregorR-L> OK, so now you have a variable with an instance of a class. Now you need to be able to get to functions in it.
00:45:45 <GregorR-L> Simply push the pointer to the instance of the class, then a pointer to the function, and use '.'. It will dereference the pointer in the scope of the class, and leave a pointer to the function itself on the stack.
00:46:10 <GregorR-L> So, to get a pointer to the function O.o when you have an instance of O in _o:
00:46:23 <GregorR-L> That cannot possibly have been clear :P
00:47:55 <GregorR-L> To call a function that you have on the stack, simply use '?'
00:48:12 <GregorR-L> So, to call O.o for the instance _o:
00:48:37 <Gs30ng> then how can i give some arguments?
00:49:38 <Gs30ng> aha... they are on the stack, ok
00:50:09 <GregorR-L> So, if you had a function that was passed a number, you could do something like the following to put that number in _a:
00:50:44 <GregorR-L> That would push a pointer to _a, then the value one in the stack below it, and put that value in _a, then pop off the value still left in the stack, therefore getting the variable where you want it.
00:50:53 <GregorR-L> Oh, and return values are generally on the stack as well.
00:51:13 <GregorR-L> And by "generally" I mean "always"
00:53:46 <GregorR-L> To set a variable to 'this' (that is, the instance of the current class), push a pointer to the variable, then use the operator '$'.
00:54:39 <GregorR-L> And that's all for lesson #3, anything unclear before lesson #4?
00:56:00 <GregorR-L> Lesson #4: Loops *and conditionals
00:56:20 <GregorR-L> There is only one branching operation in Glass, the while loop. It can be used, however, to emulate a conditional.
00:56:45 <Gs30ng> feeling the Glass page of wiki is kinda unkind
00:57:02 <GregorR-L> A while loop is declared very much like a class or method: a character /, then the name of the variable to loop on, then the content, then \.
00:57:31 <GregorR-L> It will loop so long as the supplied variable is not a zero or an empty string.
00:58:01 <GregorR-L> As with everything else, if the variable is more than one character, it must be in ().
00:58:05 <GregorR-L> So, to loop on the variable _a, use /(_a)...\
00:58:27 <GregorR-L> There's not much interesting we can do with loops or conditionals until we get into built-in classes, the next lesson.
00:59:41 <GregorR-L> You may notice at this point that all of this provides nothing useful - no math, no I/O, just the very basic.
00:59:59 <GregorR-L> Well, that's because in Glass, most real functionality is ousted to built-in classes.
01:00:12 <GregorR-L> That includes I/O, string manipulation, and even basic arithmetic.
01:01:59 <GregorR-L> OK, so let's start with simple I/O, so we can finally make the elusive Hello, World! program.
01:02:08 <GregorR-L> There's a builtin class called 'O'
01:02:41 <GregorR-L> It has two functions: O.o, and O.on.
01:02:51 <GregorR-L> O.o outputs the string on top of the stack, then pops it off.
01:02:59 <GregorR-L> O.on outputs the number on top of the stack, then pops it off.
01:03:12 <GregorR-L> So, you should now know enough to implement Hello, World!
01:03:36 <GregorR-L> All you need to do is instanciate a class O, then push "Hello, World!", then call O.o for that instance.
01:03:46 <GregorR-L> And brb again (too much stuff going on P )
01:20:01 <Gs30ng> i've been afk to have something before starving
01:20:25 <GregorR-L> Then I think it's time for assignment #1 :P
01:20:38 <GregorR-L> Without using the Wiki page, do a Hello, World in Glass.
01:20:49 <GregorR-L> Using !glass if you'd like of course.
01:21:15 <Gs30ng> mhm i should start with the class M and function m...
01:22:13 <Gs30ng> function declaration starts with... (scrolling) ... [
01:23:30 <Gs30ng> and then to instantiate the class O
01:25:25 <Gs30ng> now i call O.o and give "Hello, World!" as its argument
01:25:44 <Gs30ng> argument should be on the stack before the function call, so "Hello, World!"
01:25:58 <Gs30ng> {M[m(_g)O!"Hello, World!"
01:27:04 <Gs30ng> to get method o from _g, (_g)o.
01:27:20 <Gs30ng> {M[m(_g)O!"Hello, World!"(_g)o.
01:27:33 <Gs30ng> {M[m(_g)O!"Hello, World!"(_g)o.?
01:27:44 <Gs30ng> {M[m(_g)O!"Hello, World!"(_g)o.?]}
01:28:39 <Gs30ng> !glass {M[m(_g)O!"Hello, World!"(_g)o.?]}
01:29:43 <GregorR-L> You're well on your way to being a Glass expert ^_^
01:30:10 <Gs30ng> thanks, Professor GregorR
01:30:45 <GregorR-L> The class 'I' (short for Input of course) handles, err, input.
01:30:55 <GregorR-L> It has three functions: I.l, I.c and I.e.
01:31:11 <GregorR-L> That I.l as in line, not I.I as in Input :P
01:31:32 <GregorR-L> I.l inputs a line of input and pushes it onto the stack, L.c inputs a character.
01:31:52 <GregorR-L> I.l inputs a line of input and pushes it onto the stack, I.c inputs a character.
01:32:17 <GregorR-L> I.e pushes the number 1 on eof, or the number 0 if not.
01:32:39 <GregorR-L> And that's all there is to the I class, questions on it?
01:33:10 <Gs30ng> of course not, very easy
01:33:29 <GregorR-L> By the way, three more built-ins to cover, then one more lesson, then we're done ;)
01:33:59 <GregorR-L> The builtin 'A' class handles simple arithmetic.
01:34:42 <GregorR-L> It has 11 binary operations (that is, operations with two operands), and 1 with one unary operation.
01:38:14 <GregorR-L> a (add), s (subtract), m (multiply), d (divide), mod (modulus), e (equals), ne (!=), lt (<), le (<=), gt (>), ge (>=)
01:38:41 <GregorR-L> To use a binary operation, push the two operands in order, call it, and it will pop them, then push the result.
01:38:57 <GregorR-L> The unary operation is floor (that is, round down)
01:39:12 <GregorR-L> To use it, just push the value, then call it, and it will pop it, then push the floored value.
01:39:39 <GregorR-L> Err, sorry, the unary operation is f, which stands for floor >_>
01:40:26 <Gs30ng> so they are not in the shape of +-*/
01:41:07 <GregorR-L> Oh, and dividing by zero will of course do nasty things, don't do it ^_^
01:42:04 <GregorR-L> So, for a simple example, to increment _a, you would push a pointer to _a, then the value to _a, then a 1, then call A.a (to add the value to 1), then use = to set that new value in _a.
01:43:00 <Gs30ng> !glass {M[m(_a)A!<1><0>(_a)d.?]}
01:43:13 <lament> that seems a bit verbose
01:43:17 <GregorR-L> I doubt that it'll actually give any output.
01:43:33 <GregorR-L> The reference interpreter is relatively debug-output free :)
01:43:56 <Gs30ng> !glass {M[m(_o)O!(_a)A!<1><0>(_a)d.?(_o)o.?]}
01:44:14 <Gs30ng> !glass {M[m(_o)O!(_a)A!<1><0>(_a)d.?(_o)on.?]}
01:44:18 <lament> GregorR-L: that's a lot of work to increment something :)
01:44:26 <GregorR-L> To push a variable with more than one character, put it in ()
01:44:34 <GregorR-L> lament: Yeah, that's the joy of builtin classes XD
01:44:43 <Gs30ng> !glass {M[m(_o)O!(_a)A!<1><0>(_a)d.?(_o)(on).?]}
01:45:06 <GregorR-L> If you divide by zero, the results will be unpredictable :P
01:45:35 <Gs30ng> its TOO object-oriented.
01:45:56 <GregorR-L> OK, two more builtins: string manipulation and anonymous variables.
01:46:55 <GregorR-L> Maybe I should just tell you to read the wiki for those XD
01:47:18 * GregorR-L draws a lazy card: Please read the wiki for those, they're described adequately.
01:47:35 <GregorR-L> OK, questions on any of the builtins I went over before the final (very short) lesson?
01:48:19 <GregorR-L> Lesson #6: Constructors and Destructors
01:48:49 <GregorR-L> Naturally, many classes have to be prepared before any functions in them are run.
01:49:00 <GregorR-L> That is of course the purpose of a constructor.
01:49:03 <Gs30ng> i don't know why every functions should be in the class
01:49:15 <GregorR-L> Because if they didn't, it wouldn't be OO :)
01:49:25 <GregorR-L> In Glass, the constructor for a class is named c__
01:49:34 <GregorR-L> It's simply a function like any other.
01:50:02 <GregorR-L> The destructor (which is of course called when the class no longer has any references) is called d__
01:50:18 <GregorR-L> I think that's about all I can teach about Glass, so it's general question time.
01:51:54 <GregorR-L> Yay, no questions, I must be the best teacher ever 8-D
01:52:50 <GregorR-L> I'll post a link to this log on the Glass wiki entry.
01:56:58 <GregorR-L> You are now officially a minion of Glass :P
02:17:24 <ihope> Aand I have to go :-P
02:17:49 <ihope> Well... bye, and thanks for all the fish... I mean, um.
02:17:52 -!- ihope has quit ("Chatzilla 0.9.69.1 [Firefox 1.5/2005111116]").
02:20:02 -!- ihope has joined.
02:20:05 <ihope> Ooh, almost forgot...
02:20:14 <ihope> How do you put quote characters inside a string?
02:21:14 <ihope> Any other escape codes?
02:21:37 <ihope> ...And there is \\, right?
02:22:11 <GregorR-L> And IIRC, that's it - otherwise, you have to use S.ns
02:22:28 -!- ihope has quit (Client Quit).
02:51:45 -!- GregorR-L has quit.
04:12:45 -!- CXI has quit (Success).
04:47:00 -!- Gs30ng has quit ("CCCiRC :: Console-based Convenient Client for IRC :: http://www.perarin.net/s.html").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:06:38 -!- CXI has joined.
08:27:46 <GregorR> I miss the good ol' days (you know, two months ago) when I could come in here and be endlessly entertained by #esoteric antics.
08:31:35 <lament> ah, where have all the flowers gone
08:39:37 * lament gets out his viola d'amore
08:43:14 * GregorR gets out his harpsichord (yeah, I can play a harpsichord and a lute simultaneusly)
08:58:23 * lament gets arrested for indecent exposure
09:49:46 -!- fungebob has quit (Read error: 110 (Connection timed out)).
10:03:25 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
10:06:55 -!- EgoBot has joined.
10:44:41 <GregorR> !daemon roll file://glass/dice.glass
10:44:57 <GregorR> Whoops, lemme do that right :)
10:45:00 <GregorR> !daemon roll glass file://glass/dice.glass
10:45:23 <GregorR> Hmm, sent that to me, one more kink to work out ...
10:46:57 <GregorR> Bah, just accidentally made a bunch of zombies ...
10:47:04 -!- EgoBot has quit ("*fix*").
10:51:32 -!- EgoBot has joined.
11:02:38 -!- Keymaker has joined.
11:26:42 -!- Keymaker has left (?).
11:34:01 <SimonRC> Grrr, Haskell professor sent out patch that doesn't actually correct the probel *at* *all*.
11:34:39 <SimonRC> I spent 3 hours tracking that bug down, while I could have been in the pub.
11:36:33 <SimonRC> fortunately I could see the proble with his patch for it immediately.
12:03:01 -!- perky has quit (Remote closed the connection).
12:36:49 -!- CXII has joined.
12:37:14 -!- CXI has quit (Nick collision from services.).
12:37:16 -!- CXII has changed nick to CXI.
13:49:22 -!- jix has joined.
16:24:56 -!- ihope has joined.
16:25:19 <ihope> Does EgoBot ever check its memos?
18:10:25 -!- Sgeo has joined.
19:12:54 <GregorR> ihope: ... No, why would it.
19:26:34 <EgoBot> Use: daemon <daemon> <daemon-command> Function: start a daemon process.
19:26:51 <GregorR> !daemon roll glass file://glass/dice.glass
19:52:52 <SimonRC> Hmm, Haskell is suprisingly powerful.
19:53:30 <SimonRC> I have just written a parser for a language which in a moment will become more powerful that the original LISP."
19:54:01 <SimonRC> I wrote this with basically no proir knowlage of parsing or interpreting in just a few hours.
19:54:22 <SimonRC> I meant to say it's an interpreter as well.
19:54:50 <SimonRC> You can do better in C++ I assume.
19:55:27 <GregorR> Nah, parsers are easier in Haskell.
19:55:47 <GregorR> That wasn't a "HAH, PUNY MORTAL" laugh.
20:16:52 -!- ihope has quit (Read error: 110 (Connection timed out)).
20:54:49 -!- ihope has joined.
20:59:31 -!- ihope_ has joined.
21:15:46 -!- ihope has quit (Read error: 110 (Connection timed out)).
21:27:33 -!- ihope_ has quit (Read error: 110 (Connection timed out)).
21:27:38 -!- ihope_ has joined.
21:27:42 -!- ihope_ has changed nick to ihope.
21:40:17 <jix> ruby is the only language for writing good parsers (or anything else that can be written ;) )
21:40:22 <jix> goodnight everyone
21:41:08 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
22:05:24 <ihope> Which is better: Unlambda or Lazy K?
22:17:55 <lament> Though my experience with those languages is sadly limited, I can safely state that neither of them is butter.
23:26:06 <GregorR> 1-3, unlambda is better, 4-6, LazyK is better.
23:26:17 <GregorR> Looks like Unlambda is better.
23:27:55 <ihope> Is there a way to have these daemons take parameters?
23:28:57 <GregorR> Yeah, anything after !<whatever> is given as input.
23:30:21 <ihope> Is there a way for any programming lanugage to do EgoBot commands? >:-)
23:31:36 <GregorR> Not any implemented in EgoBot.
23:31:46 <GregorR> EgoBot doesn't parse its own output.
23:31:57 <GregorR> Oh, unless you mean to implement a daemon in any language - any language can have a daemon, yes.
23:32:43 <ihope> I mean something like a Glass class that does !bf_txtgen.
23:32:54 <GregorR> Yeah, that would be totally doable.
23:33:07 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
23:33:09 <EgoBot> 1l 2l adjust axo befunge bch bf{8,[16],32,64} glass glypho kipple lambda lazyk malbolge pbrain rail sadol sceql trigger udage01 unlambda
23:33:23 <ihope> A suicidal Unlambda program?
23:34:36 <ihope> You know, e acts as a comtinuation for the whole program.
23:34:39 <ihope> Or something like that.
23:36:16 <GregorR> !daemon g_bf glass {M[m(_i)I!(_f)(_i)e.?=(_t)<1>=/(_f)(_f)<0>=(_t)<0>=\/(_t)(_b)(BF)!(_i)l.?(_b)(bf).?(_f)(_i)e.?=(_t)<1>=/(_f)(_f)<0>=(_t)<0>=\\]}
23:36:43 <EgoBot> 118 +++++++++++[>++++++>+++++++++>+++>++++<<<<-]>++++++.>++.+++++++..+++.>>.<-.<<+++++++++++++++.>.+++.------.--------.>+. [154]
23:36:54 <GregorR> !g_bf +++++++++++[>++++++>+++++++++>+++>++++<<<<-]>++++++.>++.+++++++..+++.>>.<-.<<+++++++++++++++.>.+++.------.--------.>+.
23:37:26 <GregorR> Hmm, maybe I didn't do that right >_>
23:38:10 <ihope> Glass programs are quite lucid...
23:38:45 <GregorR> Well, that's the condensed version ^_^
23:39:52 <GregorR> I don't think it just took that long, I think the buffers didn't flush properly >_>
23:41:12 <GregorR> !bf_txtgen Hello, World!\n
23:41:49 <EgoBot> 40 +++++++++++++[>+++++++>>><<<<-]>+.+++++. [39]
23:41:49 <GregorR> Woah, undaemon is running? >_O
23:42:03 <GregorR> OK, one sec, have to check undaemon.
23:42:09 <EgoBot> 137 ++++++++++++++[>+++++>+++>++++++++>+++++++<<<<-]>++.>>>+++.<----..+++.<++.------------.<+++++++++++++++.>>.+++.------.>-.<<+.<+++++.>>++. [424]
23:42:52 <ihope> ...So, wait, where's my \a?
23:43:46 <GregorR> !daemon roll glass file://glass/dice.glass
23:44:16 <GregorR> !daemon g_bf glass {M[m(_i)I!(_f)(_i)e.?=(_t)<1>=/(_f)(_f)<0>=(_t)<0>=\/(_t)(_b)(BF)!(_i)l.?(_b)(bf).?(_f)(_i)e.?=(_t)<1>=/(_f)(_f)<0>=(_t)<0>=\\]}
23:44:25 <GregorR> !g_bf ++++++++++++++[>+++++>+++>++++++++>+++++++<<<<-]>++.>>>+++.<----..+++.<++.------------.<+++++++++++++++.>>.+++.------.>-.<<+.<+++++.>>++.
23:44:58 <GregorR> Heheh, it actually showed \n :P
23:45:11 <GregorR> So clearly it isn't doing what I though :P
23:45:49 <GregorR> Anyway, feel free to add daemons *shrugs*
23:45:50 <ihope> Can I !bf_txtgen .....................................................................................................................................................................................................................................................................................................................................?
23:46:22 <GregorR> Yeah, but it won't do anything ...
23:50:00 <GregorR> !daemon roll glass file://glass/dice.glass
23:50:08 <EgoBot> 1 GregorR: daemon roll glass
23:50:21 <GregorR> !daemon roll glass file://glass/dice.glass
23:50:28 <GregorR> OK, all is right int he world.
23:53:42 * GregorR wonders what else would work well in daemon mode.
23:55:06 <GregorR> ihope: Did the log help you learn Glass at all, btw? :)
23:58:49 -!- blahm has joined.
23:58:52 -!- blahm has left (?).
23:59:17 <ihope> He's out and about.