00:00:59 By the way, I wrote EgoBF, and that is of course why I think it's the best :P 00:01:23 :-) 00:02:47 -!- Gs30ng has joined. 00:05:02 How about !bf >+[>+] 00:05:22 That would be mean. 00:05:35 EgoBF is autoexpanding. 00:05:42 Ooh... 00:06:04 And no on-the-fly data compression? 00:06:10 No :P 00:06:20 And why no !bf1? :-) 00:06:29 That's !bch 00:06:35 Oh. 00:06:42 With @ to flip? 00:06:44 (BitChanger) 00:06:47 Yuh 00:06:56 EgoBch, the only implementation of BitChanger :) 00:07:04 :-) 00:07:21 So BF-PDA could be emulated by replacing > with [@]>? 00:08:01 BF-PDA could be implemented, and that would be easier :P 00:08:06 :-) 00:08:08 !ps 00:08:10 1 ihope: ps 00:08:19 Hell, it could be implemented in Glass. 00:08:36 Does BitChanger have any I/O? 00:08:50 http://www.esolangs.org/wiki/BitChanger 00:09:11 Oh. 00:09:51 hi 00:09:53 long time no see 00:09:57 I don't know whether I used -lazy-io in EgoBot ... 00:10:00 Hi Gs30ng 00:10:10 If I used -lazy-io, then ',' and '.' are supported as well. 00:12:12 Hah, I just remembered something. I wrote a MISC VM and never released it. And MISC is still marked unimplemented :P 00:12:19 Hah! 00:12:29 I want a functional programming language that produces BF programs. 00:12:36 Ow. 00:13:06 Just have BF instructions be primitives. 00:13:51 i'm trying to understand Glass 00:14:28 Me too, 00:14:36 Heehee 00:14:38 World domination ^_^ 00:14:42 :-D 00:14:51 Jix got it pretty quick. 00:15:00 Heck, I'd settle for world denomination. 00:15:15 !glass {M[m(_d)(Debug!)"JixMath"(_d)(fl).?]} 00:15:31 Whoops 00:15:36 !glass {M[m(_d)(Debug)!"JixMath"(_d)(fl).?]} 00:15:40 c c__ log p sp sqrt 00:15:42 well, actually it's been a dead long time since i first tried to understand this 00:15:58 and still i don't get it 00:16:04 Heee 00:16:12 not like another works of GregorR 00:16:50 What, 2L was easy? 00:17:06 2EZ? 00:17:12 lol 00:17:37 OK, /me bangs a gavel. Glass class is now in session. 00:17:57 Lesson #1: Classes 00:18:10 Glass is an Object Oriented programming language, and therefore has classes 00:18:24 Gasp! 00:18:44 ihope: not Gasp, Glass 00:18:46 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 My mistake... 00:19:09 The name of the class must start with a capital letter (all global variables start with a capital letter). 00:19:16 For example, for a class named M: 00:19:18 {M...} 00:19:27 !glass {M...} 00:19:30 OK 00:19:39 That class won't do anything btw :P 00:19:41 lolo 00:19:43 :-) 00:19:57 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 Any questions about classes? 00:20:14 Do classes have scope? 00:20:21 Or rather, scopes? 00:20:26 You can't have subclasses, if that's what you mean. 00:20:38 I was thinking "local classes". 00:20:44 ...Yah know? 00:20:55 ok i have a question 00:21:08 All class definitions are global, objects (class implementations) can be global, local, etc. 00:21:09 did the name came from the class? 00:21:12 *come 00:21:27 Gs30ng: What do you mean? 00:21:37 origin of the name Glass 00:21:42 Oh, yeah. 00:21:49 Class + Gregor = Glass 00:21:53 Ah 00:22:01 whoa 00:22:05 cool. 00:22:13 omg ur so vane 00:22:16 Yup 00:22:23 Time for lesson #2? 00:22:25 heh 00:22:39 Yeah! 00:22:54 Lesson #2: Functions or methods, whatever you want to call them :P 00:23:04 Functions... 00:23:19 Inside of a class (and ONLY inside of a class), you may declare functions. 00:23:46 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 oops. 00:24:02 only inside of a class? 00:24:06 !glass {M[a]} 00:24:06 All function names must start with a lower case letter. 00:24:06 Yes. 00:24:10 NO M.m! 00:24:15 Oh. 00:24:30 For example, for a class named M with a function named m: {M[m...]} 00:24:48 It's important to note the function M.m, as that's the starting point for a Glass program. 00:25:05 As with classes, if the name has more than one letter, it must be surrounded in ()s. 00:25:13 Like {(Main)[(main)...]} 00:25:27 How about classes inside parentheses? 00:25:41 Parentheses just hold variable names. 00:25:47 :-) 00:26:12 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 I gotta go in about five minutes... 00:26:35 Questions about functions (not the contents, the declaration)? 00:26:46 ihope: You'll have to get the rest of the lesson in the logs then :) 00:27:25 :-) 00:27:27 mhm 00:27:54 * GregorR-L waits for questions. 00:28:23 i prefer functional rather than object-oriented, but it seems to be possible to code functional in Glass 00:28:53 There is no Lesson #x: How to abuse Glass 00:29:02 lol 00:29:10 Shall we proceed? 00:29:15 sure 00:29:21 Lesson #3: Basic Code 00:29:26 Glass is a stack-based language. 00:29:37 what 00:29:41 Every operation either pushes something onto the stack or does some operations on the stack. 00:29:54 A pushity-poppity 'pooter lingo. 00:30:25 ah... that's why the language is reverse polish notation 00:30:29 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 and now i understand what the hell is 'pointer' 00:31:03 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 If the name of the variable has more than one character, it must be surrounded in ()s. 00:31:38 So, to push _a, use: '(_a)' 00:31:57 Is pushing a pointer rather like pushing the variable name In a Different WaY? 00:32:00 *Way 00:32:08 Very much so. 00:32:12 Ah. 00:32:25 Well, this is the point where I step out and let logs do all the work. 00:32:32 Bye ihope. 00:32:38 Buh-bye 00:32:41 bye 00:33:04 Now, let's say that you didn't want the pointer to _a on the stack, but the value. 00:33:18 The operator * dereferences the top element on the stack. 00:33:27 So, to push the /value/ of _a onto the stack: (_a)* 00:33:32 Questions so far? 00:34:12 brb 00:34:16 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 No, that puts the value of _a onto the stack. 00:35:02 You don't need to define variables, they're defined on use. 00:35:18 value... aha 00:35:37 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 (By pushing a pointer then dereferencing it) 00:36:11 mhm 00:36:29 if a = 3, (a) or a pushes a, and a* pushes 3, right? 00:36:38 Precisely. 00:36:44 ok 00:36:48 You can also push other things onto the stack. To push a number, use . 00:36:52 <0>, <1>, etc. 00:36:58 Or <0.1435432542> :) 00:37:15 To push a string, use "..." 00:37:17 then also <0xFF>? (: 00:37:24 No hex ATM :P 00:37:38 Just decimal. 00:37:57 You can also push values from deeper into the stack onto the top of the stack. 00:38:17 '0' will duplicate the top value on the stack, '1' will duplicate the second value, etc. 00:38:28 You can also put those in () if you need 10 or higher. 00:38:37 Questions on any of those? 00:38:42 nope 00:38:57 OK, now let's set the value of a variable. 00:39:06 Let's say you want to set the value of _a to 1. 00:39:17 You need the operator =. 00:39:34 = sets the variable in stack position 1 to the value in stack position 0, then pops them both off. 00:39:50 So, push the pointer to the variable, then the value you want to set it to, then use = 00:39:59 (_a)<1>= 00:40:14 (And there's the reverse polish notation :) ) 00:40:28 Got it? 00:40:32 no syntactic sugar. i like that 00:40:33 yeap 00:40:40 oh, well 00:40:46 ? 00:40:50 then <1>(_a)= causes an error? 00:40:58 Yeah, that wouldn't work. 00:41:03 ok 00:41:34 (Hm, what should I go to next ...) 00:41:51 Oh, heh - to just pop something from the stack, use ',' 00:42:16 I guess it's time for classes :) 00:42:40 To make an instance of a class, use !. 00:43:26 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 So, to make _o an instance of class O: 00:43:44 (_o)O! 00:43:47 Questions? 00:44:01 very clear so far 00:44:12 OK, brb 00:45:07 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 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 So, to get a pointer to the function O.o when you have an instance of O in _o: 00:46:14 (_o)o. 00:46:23 That cannot possibly have been clear :P 00:47:06 Still understanding? 00:47:38 yeap 00:47:43 OK, good ^_^ 00:47:55 To call a function that you have on the stack, simply use '?' 00:48:12 So, to call O.o for the instance _o: 00:48:15 (_o)o.? 00:48:37 then how can i give some arguments? 00:48:48 It has the same stack you do. 00:48:51 So arguments are on the stack. 00:49:10 It's all one big main stack :) 00:49:38 aha... they are on the stack, ok 00:49:42 Yup 00:50:09 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 (_a)1=, 00:50:44 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 Oh, and return values are generally on the stack as well. 00:51:13 And by "generally" I mean "always" 00:51:45 Questions on passing-by-stack? 00:52:49 nope 00:52:53 Hoopla 00:53:46 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 (_t)$ 00:53:54 For example. 00:54:39 And that's all for lesson #3, anything unclear before lesson #4? 00:55:41 clear 00:55:45 Good 00:55:52 Lesson #4: Loops 00:56:00 Lesson #4: Loops *and conditionals 00:56:20 There is only one branching operation in Glass, the while loop. It can be used, however, to emulate a conditional. 00:56:45 feeling the Glass page of wiki is kinda unkind 00:56:58 Hah, I'm sure it is :P 00:57:02 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 It will loop so long as the supplied variable is not a zero or an empty string. 00:58:01 As with everything else, if the variable is more than one character, it must be in (). 00:58:05 So, to loop on the variable _a, use /(_a)...\ 00:58:27 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 So, questions? 00:59:01 easy 00:59:08 Figured, short lesson ^_^ 00:59:20 what a language 00:59:20 Lesson #5: Built-In Classes 00:59:41 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 Well, that's because in Glass, most real functionality is ousted to built-in classes. 01:00:12 That includes I/O, string manipulation, and even basic arithmetic. 01:00:43 Err, brb. 01:01:44 Back 01:01:59 OK, so let's start with simple I/O, so we can finally make the elusive Hello, World! program. 01:02:08 There's a builtin class called 'O' 01:02:13 Which stands for 'Output' 01:02:20 And allows you to output strings. 01:02:29 And numbers. 01:02:41 It has two functions: O.o, and O.on. 01:02:51 O.o outputs the string on top of the stack, then pops it off. 01:02:59 O.on outputs the number on top of the stack, then pops it off. 01:03:12 So, you should now know enough to implement Hello, World! 01:03:36 All you need to do is instanciate a class O, then push "Hello, World!", then call O.o for that instance. 01:03:46 And brb again (too much stuff going on P ) 01:03:50 *:P 01:05:51 * GregorR-L upgrades that brb into a bbiab. 01:16:02 OK, back. 01:16:06 Gs30ng: Still there? 01:20:01 i've been afk to have something before starving 01:20:07 ok i'm totally back 01:20:25 Then I think it's time for assignment #1 :P 01:20:38 Without using the Wiki page, do a Hello, World in Glass. 01:20:49 Using !glass if you'd like of course. 01:20:55 i'll try 01:21:15 mhm i should start with the class M and function m... 01:21:23 Yup 01:21:49 {M 01:22:13 function declaration starts with... (scrolling) ... [ 01:22:24 {M[m 01:23:30 and then to instantiate the class O 01:23:39 (_g)O! 01:24:32 So far looks good. 01:25:25 now i call O.o and give "Hello, World!" as its argument 01:25:44 argument should be on the stack before the function call, so "Hello, World!" 01:25:58 {M[m(_g)O!"Hello, World!" 01:27:04 to get method o from _g, (_g)o. 01:27:20 {M[m(_g)O!"Hello, World!"(_g)o. 01:27:31 and then call it 01:27:33 {M[m(_g)O!"Hello, World!"(_g)o.? 01:27:44 {M[m(_g)O!"Hello, World!"(_g)o.?]} 01:28:30 Feel free to use !glass 01:28:39 !glass {M[m(_g)O!"Hello, World!"(_g)o.?]} 01:28:43 Hello, World! 01:28:48 whoa 01:29:26 Congrats :) 01:29:43 You're well on your way to being a Glass expert ^_^ 01:30:10 thanks, Professor GregorR 01:30:12 Heh 01:30:21 Next built-in: Input 01:30:45 The class 'I' (short for Input of course) handles, err, input. 01:30:55 It has three functions: I.l, I.c and I.e. 01:31:11 That I.l as in line, not I.I as in Input :P 01:31:32 I.l inputs a line of input and pushes it onto the stack, L.c inputs a character. 01:31:39 Err, I.e, sorry. 01:31:43 Err, I.c 01:31:46 Lemme try that again. 01:31:52 I.l inputs a line of input and pushes it onto the stack, I.c inputs a character. 01:32:17 I.e pushes the number 1 on eof, or the number 0 if not. 01:32:39 And that's all there is to the I class, questions on it? 01:33:10 of course not, very easy 01:33:29 By the way, three more built-ins to cover, then one more lesson, then we're done ;) 01:33:34 And the next lesson is a short'n. 01:33:42 OK, onto arithmetic! 01:33:59 The builtin 'A' class handles simple arithmetic. 01:34:42 It has 11 binary operations (that is, operations with two operands), and 1 with one unary operation. 01:34:46 The binary operations are: 01:35:31 Gah, brb 01:35:50 brb too 01:38:14 a (add), s (subtract), m (multiply), d (divide), mod (modulus), e (equals), ne (!=), lt (<), le (<=), gt (>), ge (>=) 01:38:41 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 The unary operation is floor (that is, round down) 01:39:12 To use it, just push the value, then call it, and it will pop it, then push the floored value. 01:39:39 Err, sorry, the unary operation is f, which stands for floor >_> 01:40:26 so they are not in the shape of +-*/ 01:40:56 No, they're all by-name. 01:41:07 Oh, and dividing by zero will of course do nasty things, don't do it ^_^ 01:42:04 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 (_m)A!(_a)(_a)*<1>(_m)a.?= 01:42:28 *whew* 01:42:31 Questions? 01:43:00 !glass {M[m(_a)A!<1><0>(_a)d.?]} 01:43:13 that seems a bit verbose 01:43:17 I doubt that it'll actually give any output. 01:43:27 oops. 01:43:33 The reference interpreter is relatively debug-output free :) 01:43:45 lament: How so? 01:43:56 !glass {M[m(_o)O!(_a)A!<1><0>(_a)d.?(_o)o.?]} 01:44:08 To output a number, use O.on 01:44:14 !glass {M[m(_o)O!(_a)A!<1><0>(_a)d.?(_o)on.?]} 01:44:18 GregorR-L: that's a lot of work to increment something :) 01:44:26 To push a variable with more than one character, put it in () 01:44:34 lament: Yeah, that's the joy of builtin classes XD 01:44:43 !glass {M[m(_o)O!(_a)A!<1><0>(_a)d.?(_o)(on).?]} 01:44:49 1 01:45:06 If you divide by zero, the results will be unpredictable :P 01:45:35 its TOO object-oriented. 01:45:40 it's* 01:45:41 Heehee 01:45:56 OK, two more builtins: string manipulation and anonymous variables. 01:46:35 *whew* *cough* *sputter* 01:46:55 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 OK, questions on any of the builtins I went over before the final (very short) lesson? 01:47:57 nope 01:48:19 Lesson #6: Constructors and Destructors 01:48:49 Naturally, many classes have to be prepared before any functions in them are run. 01:49:00 That is of course the purpose of a constructor. 01:49:03 i don't know why every functions should be in the class 01:49:15 Because if they didn't, it wouldn't be OO :) 01:49:25 In Glass, the constructor for a class is named c__ 01:49:34 It's simply a function like any other. 01:50:02 The destructor (which is of course called when the class no longer has any references) is called d__ 01:50:18 I think that's about all I can teach about Glass, so it's general question time. 01:51:54 Yay, no questions, I must be the best teacher ever 8-D 01:52:12 lol 01:52:50 I'll post a link to this log on the Glass wiki entry. 01:53:20 that is one good idea 01:56:43 OK, 's linked. 01:56:58 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 Aand I have to go :-P 02:17:40 Hah 02:17:41 Bye 02:17:49 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 Ooh, almost forgot... 02:20:14 How do you put quote characters inside a string? 02:20:56 \" 02:21:02 :-) 02:21:04 You can also use \n 02:21:09 IIRC 02:21:10 :) 02:21:14 Any other escape codes? 02:21:37 ...And there is \\, right? 02:21:56 Yeah 02:22:07 Anything else? 02:22:11 And IIRC, that's it - otherwise, you have to use S.ns 02:22:23 Okay. Thanks 02:22:28 -!- ihope has quit (Client Quit). 02:51:44 Well, back home. 02:51:45 -!- GregorR-L has quit. 03:30:17 Well, back home. 04:12:45 -!- CXI has quit (Success). 04:13:23 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 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 ah, where have all the flowers gone 08:31:42 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 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 Whooooooooops 10:06:55 -!- EgoBot has joined. 10:44:41 !daemon roll file://glass/dice.glass 10:44:43 !roll 10:44:47 Huh? 10:44:57 Whoops, lemme do that right :) 10:45:00 !daemon roll glass file://glass/dice.glass 10:45:01 !roll 10:45:05 You rolled a 4 10:45:06 !roll 10:45:23 Hmm, sent that to me, one more kink to work out ... 10:46:57 Bah, just accidentally made a bunch of zombies ... 10:47:03 !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 !roll 11:02:47 Huh? 11:03:01 hmm, it doesn't work! 11:03:08 lousy robot!! 11:26:42 -!- Keymaker has left (?). 11:34:01 Grrr, Haskell professor sent out patch that doesn't actually correct the probel *at* *all*. 11:34:39 I spent 3 hours tracking that bug down, while I could have been in the pub. 11:36:33 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 Does EgoBot ever check its memos? 18:10:25 -!- Sgeo has joined. 19:12:54 ihope: ... No, why would it. 19:26:25 !reload 19:26:28 !help daemon 19:26:34 Use: daemon Function: start a daemon process. 19:26:51 !daemon roll glass file://glass/dice.glass 19:27:00 You rolled a 1 19:27:04 Hoopla. 19:52:52 Hmm, Haskell is suprisingly powerful. 19:53:30 I have just written a parser for a language which in a moment will become more powerful that the original LISP." 19:54:01 I wrote this with basically no proir knowlage of parsing or interpreting in just a few hours. 19:54:08 Ooops 19:54:22 I meant to say it's an interpreter as well. 19:54:29 Hah 19:54:50 You can do better in C++ I assume. 19:55:27 Nah, parsers are easier in Haskell. 19:55:47 That wasn't a "HAH, PUNY MORTAL" laugh. 19:57:51 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 ruby is the only language for writing good parsers (or anything else that can be written ;) ) 21:40:22 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 Which is better: Unlambda or Lazy K? 22:14:39 better? 22:15:39 Aye, better. 22:16:02 better? 22:16:07 Aye, better. 22:16:18 better? 22:16:31 Nay, butter. 22:17:55 Though my experience with those languages is sadly limited, I can safely state that neither of them is butter. 22:18:07 Ah. 23:25:49 Umm 23:26:06 1-3, unlambda is better, 4-6, LazyK is better. 23:26:08 !roll 23:26:11 You rolled a 3 23:26:17 Looks like Unlambda is better. 23:26:40 Okay. Thanks. 23:27:55 Is there a way to have these daemons take parameters? 23:28:57 Yeah, anything after ! is given as input. 23:29:09 Oh... 23:30:21 Is there a way for any programming lanugage to do EgoBot commands? >:-) 23:31:36 Not any implemented in EgoBot. 23:31:46 EgoBot doesn't parse its own output. 23:31:57 Oh, unless you mean to implement a daemon in any language - any language can have a daemon, yes. 23:32:43 I mean something like a Glass class that does !bf_txtgen. 23:32:54 Yeah, that would be totally doable. 23:33:03 !help 23:33:07 help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon 23:33:09 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 A suicidal Unlambda program? 23:33:32 !unlambda `e`.*i 23:33:37 * 23:33:41 !ps 23:33:45 2 ihope: ps 23:34:36 You know, e acts as a comtinuation for the whole program. 23:34:39 Or something like that. 23:36:16 !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 !bf_txtgen Hello, World! 23:36:43 118 +++++++++++[>++++++>+++++++++>+++>++++<<<<-]>++++++.>++.+++++++..+++.>>.<-.<<+++++++++++++++.>.+++.------.--------.>+. [154] 23:36:54 !g_bf +++++++++++[>++++++>+++++++++>+++>++++<<<<-]>++++++.>++.+++++++..+++.>>.<-.<<+++++++++++++++.>.+++.------.--------.>+. 23:37:26 Hmm, maybe I didn't do that right >_> 23:38:10 Glass programs are quite lucid... 23:38:45 Well, that's the condensed version ^_^ 23:39:01 !undaemon g_bf 23:39:02 !kill 2 23:39:05 Hello, World! 23:39:07 Process 2 killed. 23:39:09 GARR 23:39:12 It worked :P 23:39:34 :-) 23:39:52 I don't think it just took that long, I think the buffers didn't flush properly >_> 23:39:57 I wonder why 23:39:59 !roll 23:40:03 You rolled a 4 23:40:04 Works, but g_bf doesn't 23:40:57 *shrugs* 23:41:01 OH 23:41:03 Of course. 23:41:07 It didn't output a \n 23:41:12 !bf_txtgen Hello, World!\n 23:41:23 !bf_txtgen \a 23:41:26 !ps 23:41:31 2 ihope: bf_txtgen 23:41:33 3 GregorR: undaemon 23:41:35 4 GregorR: bf_txtgen 23:41:35 !kill 2 23:41:37 5 ihope: bf_txtgen 23:41:39 6 ihope: ps 23:41:41 Process 2 killed. 23:41:49 40 +++++++++++++[>+++++++>>><<<<-]>+.+++++. [39] 23:41:49 Woah, undaemon is running? >_O 23:41:59 !kill 3 23:42:00 Eep! 23:42:01 Process 3 killed. 23:42:03 OK, one sec, have to check undaemon. 23:42:09 137 ++++++++++++++[>+++++>+++>++++++++>+++++++<<<<-]>++.>>>+++.<----..+++.<++.------------.<+++++++++++++++.>>.+++.------.>-.<<+.<+++++.>>++. [424] 23:42:25 Oh, I see the problem. 23:42:52 ...So, wait, where's my \a? 23:43:14 It only parses \n :P 23:43:20 :-) 23:43:37 !reload 23:43:46 !daemon roll glass file://glass/dice.glass 23:43:57 You rolled a 3 23:44:16 !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 !g_bf ++++++++++++++[>+++++>+++>++++++++>+++++++<<<<-]>++.>>>+++.<----..+++.<++.------------.<+++++++++++++++.>>.+++.------.>-.<<+.<+++++.>>++. 23:44:54 !show 1 23:44:58 Heheh, it actually showed \n :P 23:45:11 So clearly it isn't doing what I though :P 23:45:24 !undaemon g_bf 23:45:25 !kill 2 23:45:29 Hello, World!\n 23:45:31 Process 2 killed. 23:45:49 Anyway, feel free to add daemons *shrugs* 23:45:50 Can I !bf_txtgen .....................................................................................................................................................................................................................................................................................................................................? 23:46:19 Umm ... 23:46:22 Yeah, but it won't do anything ... 23:46:54 :-) 23:49:35 One more fix ... 23:49:37 !kill 1 23:49:41 Process 1 killed. 23:49:42 !reload 23:50:00 !daemon roll glass file://glass/dice.glass 23:50:05 !ps d 23:50:08 1 GregorR: daemon roll glass 23:50:11 2 GregorR: ps 23:50:14 !undaemon roll 23:50:16 Process 1 killed. 23:50:20 Cool :) 23:50:21 !daemon roll glass file://glass/dice.glass 23:50:28 OK, all is right int he world. 23:50:30 *in the 23:50:40 You rolled a 1 23:53:42 * GregorR wonders what else would work well in daemon mode. 23:54:09 Some sort of game ... 23:54:25 Hmm... 23:55:06 ihope: Did the log help you learn Glass at all, btw? :) 23:55:41 I think so, 23:58:49 -!- blahm has joined. 23:58:52 -!- blahm has left (?). 23:58:59 BLAHM! 23:59:05 He's in and he's out. 23:59:08 Just like that. 23:59:09 :-) 23:59:09 BLAHM! 23:59:17 He's out and about. 23:59:20 He's like that.