←2006-01-15 2006-01-16 2006-01-17→ ↑2006 ↑all
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:01:23 <ihope> :-)
00:02:47 -!- Gs30ng has joined.
00:05:02 <ihope> How about !bf >+[>+]
00:05:22 <GregorR-L> That would be mean.
00:05:35 <GregorR-L> EgoBF is autoexpanding.
00:05:42 <ihope> Ooh...
00:06:04 <ihope> And no on-the-fly data compression?
00:06:10 <GregorR-L> No :P
00:06:20 <ihope> And why no !bf1? :-)
00:06:29 <GregorR-L> That's !bch
00:06:35 <ihope> Oh.
00:06:42 <ihope> With @ to flip?
00:06:44 <GregorR-L> (BitChanger)
00:06:47 <GregorR-L> Yuh
00:06:56 <GregorR-L> EgoBch, the only implementation of BitChanger :)
00:07:04 <ihope> :-)
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:06 <ihope> :-)
00:08:08 <ihope> !ps
00:08:10 <EgoBot> 1 ihope: ps
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:11 <ihope> Oh.
00:09:51 <Gs30ng> hi
00:09:53 <Gs30ng> long time no see
00:09:57 <GregorR-L> I don't know whether I used -lazy-io in EgoBot ...
00:10:00 <GregorR-L> Hi Gs30ng
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:19 <ihope> Hah!
00:12:29 <ihope> I want a functional programming language that produces BF programs.
00:12:36 <GregorR-L> Ow.
00:13:06 <ihope> Just have BF instructions be primitives.
00:13:51 <Gs30ng> i'm trying to understand Glass
00:14:28 <ihope> Me too,
00:14:36 <GregorR-L> Heehee
00:14:38 <GregorR-L> World domination ^_^
00:14:42 <ihope> :-D
00:14:51 <GregorR-L> Jix got it pretty quick.
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:31 <GregorR-L> Whoops
00:15:36 <GregorR-L> !glass {M[m(_d)(Debug)!"JixMath"(_d)(fl).?]}
00:15:40 <EgoBot> c c__ log p sp sqrt
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:04 <GregorR-L> Heee
00:16:12 <Gs30ng> not like another works of GregorR
00:16:50 <GregorR-L> What, 2L was easy?
00:17:06 <ihope> 2EZ?
00:17:12 <GregorR-L> lol
00:17:37 <GregorR-L> OK, /me bangs a gavel. Glass class is now in session.
00:17:57 <GregorR-L> Lesson #1: Classes
00:18:10 <GregorR-L> Glass is an Object Oriented programming language, and therefore has classes
00:18:24 <ihope> Gasp!
00:18:44 <SimonRC> ihope: not Gasp, Glass
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:18:54 <ihope> My mistake...
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:16 <GregorR-L> For example, for a class named M:
00:19:18 <GregorR-L> {M...}
00:19:27 <ihope> !glass {M...}
00:19:30 <EgoBot> OK
00:19:39 <GregorR-L> That class won't do anything btw :P
00:19:41 <Gs30ng> lolo
00:19:43 <ihope> :-)
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:03 <GregorR-L> Any questions about classes?
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:20:44 <ihope> ...Yah know?
00:20:55 <Gs30ng> ok i have a question
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:12 <Gs30ng> *come
00:21:27 <GregorR-L> Gs30ng: What do you mean?
00:21:37 <Gs30ng> origin of the name Glass
00:21:42 <GregorR-L> Oh, yeah.
00:21:49 <GregorR-L> Class + Gregor = Glass
00:21:53 <ihope> Ah
00:22:01 <Gs30ng> whoa
00:22:05 <Gs30ng> cool.
00:22:13 <ihope> omg ur so vane
00:22:16 <GregorR-L> Yup
00:22:23 <GregorR-L> Time for lesson #2?
00:22:25 <SimonRC> heh
00:22:39 <ihope> Yeah!
00:22:54 <GregorR-L> Lesson #2: Functions or methods, whatever you want to call them :P
00:23:04 <ihope> Functions...
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:23:55 <Gs30ng> oops.
00:24:02 <Gs30ng> only inside of a class?
00:24:06 <ihope> !glass {M[a]}
00:24:06 <GregorR-L> All function names must start with a lower case letter.
00:24:06 <GregorR-L> Yes.
00:24:10 <EgoBot> NO M.m!
00:24:15 <ihope> Oh.
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:13 <GregorR-L> Like {(Main)[(main)...]}
00:25:27 <ihope> How about classes inside parentheses?
00:25:41 <GregorR-L> Parentheses just hold variable names.
00:25:47 <ihope> :-)
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:27:25 <ihope> :-)
00:27:27 <Gs30ng> mhm
00:27:54 * GregorR-L waits for questions.
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:02 <Gs30ng> lol
00:29:10 <GregorR-L> Shall we proceed?
00:29:15 <Gs30ng> sure
00:29:21 <GregorR-L> Lesson #3: Basic Code
00:29:26 <GregorR-L> Glass is a stack-based language.
00:29:37 <Gs30ng> what
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:38 <GregorR-L> So, to push _a, use: '(_a)'
00:31:57 <ihope> Is pushing a pointer rather like pushing the variable name In a Different WaY?
00:32:00 <ihope> *Way
00:32:08 <GregorR-L> Very much so.
00:32:12 <ihope> Ah.
00:32:25 <ihope> Well, this is the point where I step out and let logs do all the work.
00:32:32 <GregorR-L> Bye ihope.
00:32:38 <ihope> Buh-bye
00:32:41 <Gs30ng> bye
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:33:32 <GregorR-L> Questions so far?
00:34:12 <GregorR-L> brb
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:18 <Gs30ng> value... aha
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:11 <Gs30ng> mhm
00:36:29 <Gs30ng> if a = 3, (a) or a pushes a, and a* pushes 3, right?
00:36:38 <GregorR-L> Precisely.
00:36:44 <Gs30ng> ok
00:36:48 <GregorR-L> You can also push other things onto the stack. To push a number, use <num>.
00:36:52 <GregorR-L> <0>, <1>, etc.
00:36:58 <GregorR-L> Or <0.1435432542> :)
00:37:15 <GregorR-L> To push a string, use "..."
00:37:17 <Gs30ng> then also <0xFF>? (:
00:37:24 <GregorR-L> No hex ATM :P
00:37:38 <GregorR-L> Just decimal.
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:37 <GregorR-L> Questions on any of those?
00:38:42 <Gs30ng> nope
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:17 <GregorR-L> You need the operator =.
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:39:59 <GregorR-L> (_a)<1>=
00:40:14 <GregorR-L> (And there's the reverse polish notation :) )
00:40:28 <GregorR-L> Got it?
00:40:32 <Gs30ng> no syntactic sugar. i like that
00:40:33 <Gs30ng> yeap
00:40:40 <Gs30ng> oh, well
00:40:46 <GregorR-L> ?
00:40:50 <Gs30ng> then <1>(_a)= causes an error?
00:40:58 <GregorR-L> Yeah, that wouldn't work.
00:41:03 <Gs30ng> ok
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:16 <GregorR-L> I guess it's time for classes :)
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:43:44 <GregorR-L> (_o)O!
00:43:47 <GregorR-L> Questions?
00:44:01 <Gs30ng> very clear so far
00:44:12 <GregorR-L> OK, brb
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:14 <GregorR-L> (_o)o.
00:46:23 <GregorR-L> That cannot possibly have been clear :P
00:47:06 <GregorR-L> Still understanding?
00:47:38 <Gs30ng> yeap
00:47:43 <GregorR-L> OK, good ^_^
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:15 <GregorR-L> (_o)o.?
00:48:37 <Gs30ng> then how can i give some arguments?
00:48:48 <GregorR-L> It has the same stack you do.
00:48:51 <GregorR-L> So arguments are on the stack.
00:49:10 <GregorR-L> It's all one big main stack :)
00:49:38 <Gs30ng> aha... they are on the stack, ok
00:49:42 <GregorR-L> Yup
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:14 <GregorR-L> (_a)1=,
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:51:45 <GregorR-L> Questions on passing-by-stack?
00:52:49 <Gs30ng> nope
00:52:53 <GregorR-L> Hoopla
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:53:51 <GregorR-L> (_t)$
00:53:54 <GregorR-L> For example.
00:54:39 <GregorR-L> And that's all for lesson #3, anything unclear before lesson #4?
00:55:41 <Gs30ng> clear
00:55:45 <GregorR-L> Good
00:55:52 <GregorR-L> Lesson #4: Loops
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:56:58 <GregorR-L> Hah, I'm sure it is :P
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:58:36 <GregorR-L> So, questions?
00:59:01 <Gs30ng> easy
00:59:08 <GregorR-L> Figured, short lesson ^_^
00:59:20 <Gs30ng> what a language
00:59:20 <GregorR-L> Lesson #5: Built-In Classes
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:00:43 <GregorR-L> Err, brb.
01:01:44 <GregorR-L> Back
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:13 <GregorR-L> Which stands for 'Output'
01:02:20 <GregorR-L> And allows you to output strings.
01:02:29 <GregorR-L> And numbers.
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:03:50 <GregorR-L> *:P
01:05:51 * GregorR-L upgrades that brb into a bbiab.
01:16:02 <GregorR-L> OK, back.
01:16:06 <GregorR-L> Gs30ng: Still there?
01:20:01 <Gs30ng> i've been afk to have something before starving
01:20:07 <Gs30ng> ok i'm totally back
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:20:55 <Gs30ng> i'll try
01:21:15 <Gs30ng> mhm i should start with the class M and function m...
01:21:23 <GregorR-L> Yup
01:21:49 <Gs30ng> {M
01:22:13 <Gs30ng> function declaration starts with... (scrolling) ... [
01:22:24 <Gs30ng> {M[m
01:23:30 <Gs30ng> and then to instantiate the class O
01:23:39 <Gs30ng> (_g)O!
01:24:32 <GregorR-L> So far looks good.
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:31 <Gs30ng> and then call it
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:30 <GregorR-L> Feel free to use !glass
01:28:39 <Gs30ng> !glass {M[m(_g)O!"Hello, World!"(_g)o.?]}
01:28:43 <EgoBot> Hello, World!
01:28:48 <Gs30ng> whoa
01:29:26 <GregorR-L> Congrats :)
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:12 <GregorR-L> Heh
01:30:21 <GregorR-L> Next built-in: Input
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:39 <GregorR-L> Err, I.e, sorry.
01:31:43 <GregorR-L> Err, I.c
01:31:46 <GregorR-L> Lemme try that again.
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:34 <GregorR-L> And the next lesson is a short'n.
01:33:42 <GregorR-L> OK, onto arithmetic!
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:34:46 <GregorR-L> The binary operations are:
01:35:31 <GregorR-L> Gah, brb
01:35:50 <Gs30ng> brb too
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:40:56 <GregorR-L> No, they're all by-name.
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:42:23 <GregorR-L> (_m)A!(_a)(_a)*<1>(_m)a.?=
01:42:28 <GregorR-L> *whew*
01:42:31 <GregorR-L> Questions?
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:27 <Gs30ng> oops.
01:43:33 <GregorR-L> The reference interpreter is relatively debug-output free :)
01:43:45 <GregorR-L> lament: How so?
01:43:56 <Gs30ng> !glass {M[m(_o)O!(_a)A!<1><0>(_a)d.?(_o)o.?]}
01:44:08 <GregorR-L> To output a number, use O.on
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:44:49 <EgoBot> 1
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:40 <Gs30ng> it's*
01:45:41 <GregorR-L> Heehee
01:45:56 <GregorR-L> OK, two more builtins: string manipulation and anonymous variables.
01:46:35 <GregorR-L> *whew* *cough* *sputter*
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:47:57 <Gs30ng> nope
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:12 <Gs30ng> lol
01:52:50 <GregorR-L> I'll post a link to this log on the Glass wiki entry.
01:53:20 <Gs30ng> that is one good idea
01:56:43 <GregorR-L> OK, 's linked.
01:56:58 <GregorR-L> You are now officially a minion of Glass :P
02:11:44 * SimonRC goes to bed
02:17:06 * ihope is back!
02:17:24 <ihope> Aand I have to go :-P
02:17:40 <GregorR-L> Hah
02:17:41 <GregorR-L> Bye
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:20:56 <GregorR-L> \"
02:21:02 <ihope> :-)
02:21:04 <GregorR-L> You can also use \n
02:21:09 <GregorR-L> IIRC
02:21:10 <GregorR-L> :)
02:21:14 <ihope> Any other escape codes?
02:21:37 <ihope> ...And there is \\, right?
02:21:56 <GregorR-L> Yeah
02:22:07 <ihope> Anything else?
02:22:11 <GregorR-L> And IIRC, that's it - otherwise, you have to use S.ns
02:22:23 <ihope> Okay. Thanks
02:22:28 -!- ihope has quit (Client Quit).
02:51:44 <GregorR-L> Well, back home.
02:51:45 -!- GregorR-L has quit.
03:30:17 <GregorR> Well, back home.
04:12:45 -!- CXI has quit (Success).
04:13:23 <GregorR> 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:31:42 <GregorR> lol
08:31:48 * GregorR gets out his lute.
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:57:49 * lament gets out his organ
08:58:23 * lament gets arrested for indecent exposure
08:58:28 <GregorR> lol
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:03:31 <GregorR> Whooooooooops
10:06:55 -!- EgoBot has joined.
10:44:41 <GregorR> !daemon roll file://glass/dice.glass
10:44:43 <GregorR> !roll
10:44:47 <EgoBot> Huh?
10:44:57 <GregorR> Whoops, lemme do that right :)
10:45:00 <GregorR> !daemon roll glass file://glass/dice.glass
10:45:01 <GregorR> !roll
10:45:05 <EgoBot> You rolled a 4
10:45:06 <GregorR> !roll
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:03 <GregorR> !raw QUIT *fix*
10:47:04 -!- EgoBot has quit ("*fix*").
10:51:32 -!- EgoBot has joined.
11:02:38 -!- Keymaker has joined.
11:02:44 <Keymaker> !roll
11:02:47 <EgoBot> Huh?
11:03:01 <Keymaker> hmm, it doesn't work!
11:03:08 <Keymaker> lousy robot!!
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:12:15 * SimonRC goes
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:25 <GregorR> !reload
19:26:28 <GregorR> !help daemon
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:27:00 <EgoBot> You rolled a 1
19:27:04 <GregorR> Hoopla.
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:08 <SimonRC> Ooops
19:54:22 <SimonRC> I meant to say it's an interpreter as well.
19:54:29 <GregorR> Hah
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.
19:57:51 <SimonRC> ah, ok
20:16:52 -!- ihope has quit (Read error: 110 (Connection timed out)).
20:24:53 * SimonRC curses XOFF
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").
21:43:04 * SimonRC goes.
21:49:45 * ihope comes
22:05:24 <ihope> Which is better: Unlambda or Lazy K?
22:14:39 <lament> better?
22:15:39 <ihope> Aye, better.
22:16:02 <lament> better?
22:16:07 <ihope> Aye, better.
22:16:18 <lament> better?
22:16:31 <ihope> Nay, butter.
22:17:55 <lament> Though my experience with those languages is sadly limited, I can safely state that neither of them is butter.
22:18:07 <ihope> Ah.
23:25:49 <GregorR> Umm
23:26:06 <GregorR> 1-3, unlambda is better, 4-6, LazyK is better.
23:26:08 <GregorR> !roll
23:26:11 <EgoBot> You rolled a 3
23:26:17 <GregorR> Looks like Unlambda is better.
23:26:40 <ihope> Okay. Thanks.
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:29:09 <ihope> Oh...
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:03 <ihope> !help
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:33:32 <ihope> !unlambda `e`.*i
23:33:37 <EgoBot> *
23:33:41 <ihope> !ps
23:33:45 <EgoBot> 2 ihope: ps
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:22 <GregorR> !bf_txtgen Hello, World!
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:01 <GregorR> !undaemon g_bf
23:39:02 <GregorR> !kill 2
23:39:05 <EgoBot> Hello, World!
23:39:07 <EgoBot> Process 2 killed.
23:39:09 <GregorR> GARR
23:39:12 <GregorR> It worked :P
23:39:34 <ihope> :-)
23:39:52 <GregorR> I don't think it just took that long, I think the buffers didn't flush properly >_>
23:39:57 <GregorR> I wonder why
23:39:59 <GregorR> !roll
23:40:03 <EgoBot> You rolled a 4
23:40:04 <GregorR> Works, but g_bf doesn't
23:40:57 <GregorR> *shrugs*
23:41:01 <GregorR> OH
23:41:03 <GregorR> Of course.
23:41:07 <GregorR> It didn't output a \n
23:41:12 <GregorR> !bf_txtgen Hello, World!\n
23:41:23 <ihope> !bf_txtgen \a
23:41:26 <ihope> !ps
23:41:31 <EgoBot> 2 ihope: bf_txtgen
23:41:33 <EgoBot> 3 GregorR: undaemon
23:41:35 <EgoBot> 4 GregorR: bf_txtgen
23:41:35 <ihope> !kill 2
23:41:37 <EgoBot> 5 ihope: bf_txtgen
23:41:39 <EgoBot> 6 ihope: ps
23:41:41 <EgoBot> Process 2 killed.
23:41:49 <EgoBot> 40 +++++++++++++[>+++++++>>><<<<-]>+.+++++. [39]
23:41:49 <GregorR> Woah, undaemon is running? >_O
23:41:59 <GregorR> !kill 3
23:42:00 <ihope> Eep!
23:42:01 <EgoBot> Process 3 killed.
23:42:03 <GregorR> OK, one sec, have to check undaemon.
23:42:09 <EgoBot> 137 ++++++++++++++[>+++++>+++>++++++++>+++++++<<<<-]>++.>>>+++.<----..+++.<++.------------.<+++++++++++++++.>>.+++.------.>-.<<+.<+++++.>>++. [424]
23:42:25 <GregorR> Oh, I see the problem.
23:42:52 <ihope> ...So, wait, where's my \a?
23:43:14 <GregorR> It only parses \n :P
23:43:20 <ihope> :-)
23:43:37 <GregorR> !reload
23:43:46 <GregorR> !daemon roll glass file://glass/dice.glass
23:43:57 <EgoBot> You rolled a 3
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:54 <GregorR> !show 1
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:24 <GregorR> !undaemon g_bf
23:45:25 <GregorR> !kill 2
23:45:29 <EgoBot> Hello, World!\n
23:45:31 <EgoBot> Process 2 killed.
23:45:49 <GregorR> Anyway, feel free to add daemons *shrugs*
23:45:50 <ihope> Can I !bf_txtgen .....................................................................................................................................................................................................................................................................................................................................?
23:46:19 <GregorR> Umm ...
23:46:22 <GregorR> Yeah, but it won't do anything ...
23:46:54 <ihope> :-)
23:49:35 <GregorR> One more fix ...
23:49:37 <GregorR> !kill 1
23:49:41 <EgoBot> Process 1 killed.
23:49:42 <GregorR> !reload
23:50:00 <GregorR> !daemon roll glass file://glass/dice.glass
23:50:05 <GregorR> !ps d
23:50:08 <EgoBot> 1 GregorR: daemon roll glass
23:50:11 <EgoBot> 2 GregorR: ps
23:50:14 <GregorR> !undaemon roll
23:50:16 <EgoBot> Process 1 killed.
23:50:20 <GregorR> Cool :)
23:50:21 <GregorR> !daemon roll glass file://glass/dice.glass
23:50:28 <GregorR> OK, all is right int he world.
23:50:30 <GregorR> *in the
23:50:40 <EgoBot> You rolled a 1
23:53:42 * GregorR wonders what else would work well in daemon mode.
23:54:09 <GregorR> Some sort of game ...
23:54:25 <ihope> Hmm...
23:55:06 <GregorR> ihope: Did the log help you learn Glass at all, btw? :)
23:55:41 <ihope> I think so,
23:58:49 -!- blahm has joined.
23:58:52 -!- blahm has left (?).
23:58:59 <GregorR> BLAHM!
23:59:05 <GregorR> He's in and he's out.
23:59:08 <GregorR> Just like that.
23:59:09 <ihope> :-)
23:59:09 <GregorR> BLAHM!
23:59:17 <ihope> He's out and about.
23:59:20 <ihope> He's like that.
←2006-01-15 2006-01-16 2006-01-17→ ↑2006 ↑all