00:00:00 --- log: started forth/09.09.28
00:34:12 --- quit: DrunkTomato ()
00:36:11 <gogonkt> howto dynamic calls a word? for example, string ." table-foo", call word table-foo 
00:36:53 <gogonkt> I want call word table-foo, dynamic
00:44:12 <I440r> im not sure im following you
00:44:32 <I440r> you want to call a word whose name is expressed between the quotes?
00:44:39 <I440r> ans has evaluate. horrible word
00:44:47 <I440r>  ," blah" evaluate
00:44:49 <gogonkt> yes
00:45:01 <I440r> in the above instance the word blah is executed
00:45:15 <I440r> : foo " blah" evaluate ; or something
00:45:20 <I440r> which i say is MORONIC
00:45:23 <I440r> : foo blah ;
00:45:24 <I440r> dun
00:45:41 <I440r> if you knew the name of the word you wanted to execute at compile time you should have compiled its XT
00:45:45 <I440r> not a string with its name
00:45:57 <I440r> if you dont know the name of the word until RUN time thats different
00:46:05 <gogonkt> mh
00:46:50 <gogonkt> I wanted execute at runtime
00:46:59 <I440r> ok it will be executed at run time
00:47:17 <I440r> what you want to do is searchj for the word name at run time (something taht should be done at compile time if you can)
00:47:22 <I440r> then execute its xt
00:47:43 <I440r> if you know the NAME of a word AT compile time. COMPILE ITS XT lol
00:47:56 <I440r> dont compile a string with its name in it and then evaluate taht string
00:47:59 <I440r> thats sillyness
00:48:17 <I440r> but if you want to execute a word whose name you dont know at compile time.... thats different
00:48:35 <gogonkt> word-name in 'stack' and want execute word named 'word-name'
00:48:43 <I440r> for instance you might have a game where the user can input different strings.  the things the user is inputting is a WORD name
00:48:51 <I440r> " north [enter]"
00:50:35 <gogonkt> a little bit confuse @@
01:04:30 <gogonkt> I writing a CJK IME, conversion user typing to CJK word when typing
01:17:50 --- part: jauaor left #forth
01:29:02 --- quit: f[x] (Read error: 110 (Connection timed out))
02:06:47 --- quit: I440r ("Leaving")
02:14:12 <ASau> gogonkt: where possible use ['] ' EXECUTE instead of EVALUATE
02:14:51 <gogonkt> what is diference between?
02:15:47 <ASau> EVALUATE uses dictionary search, while EXECUTE executes already resolved word.
02:17:17 --- join: ams` (n=ams@mail.kreditor.se) joined #forth
02:17:32 <gogonkt> RTFM now , chacpter of string, cell,,,
02:22:34 --- join: f[x] (n=user@95.132.224.86) joined #forth
02:23:34 <gogonkt> ASau: when user type something and press enter, conversion typing to other. is that use define typing-name words a good way?
02:23:57 <gogonkt> - -b
02:26:51 <gogonkt> dinner.
02:52:11 --- join: GeDaMo (n=gedamo@212.225.115.96) joined #forth
02:58:51 --- quit: f[x] (Read error: 60 (Operation timed out))
03:21:10 --- join: neceve (n=ncv@unaffiliated/neceve) joined #forth
03:31:17 --- quit: nighty__ ("maison")
04:25:37 --- quit: GeDaMo ("Leaving.")
04:50:36 --- quit: neceve (Remote closed the connection)
04:52:18 --- join: jauaor (n=araujo@gentoo/developer/araujo) joined #forth
04:52:37 <jauaor> :)
04:58:15 --- join: f[x] (n=user@95.132.154.113) joined #forth
04:59:05 <jauaor> http://paste2.org/p/441539
04:59:11 <jauaor> new example
05:00:42 <gogonkt> mh
05:01:59 <ASau> This isn't Forth.
05:02:13 <jauaor> oh no ... 
05:02:22 <jauaor> a small language I write
05:02:40 <ASau> This belongs to Smalltalk more.
05:03:08 <jauaor> hah, it gives you the impression of some Smalltalk? :P
05:03:12 <gogonkt> not a forth
05:03:17 <ASau> Yes.
05:03:20 <jauaor> it does take ideas from Smalltalk :)
05:03:31 <ASau> Definitly Smalltalk rather than Forth.
05:03:44 <jauaor> but i uess it shares lot more with Forht .. since it is a stack based language with RPN
05:03:51 <jauaor> errr
05:03:52 <ASau> Not at all.
05:04:07 <ASau> "@d4->T->y" isn't RPN.
05:04:23 * jauaor needs to get use to this keyboard protector
05:04:44 <jauaor> ASau: @d4->T->y 
05:04:47 <jauaor> is an object
05:05:02 <jauaor> it is not an operation
05:05:02 --- join: neceve (n=ncv@unaffiliated/neceve) joined #forth
05:05:22 <ASau> It is definitly infix notation.
05:05:30 <jauaor> no
05:05:36 <jauaor> but
05:05:36 <ASau> You need infix parser for it.
05:05:40 <jauaor> no :)
05:05:42 <jauaor> See
05:05:47 <jauaor> In the language
05:05:58 <jauaor> many things "look" and "feel" like infix
05:06:03 <jauaor> but all you see there is RPN
05:06:09 <jauaor> I did this on purpose
05:06:10 <gogonkt> why another language 
05:06:15 <ASau> Where's in Forth so much infix?
05:06:15 <jauaor> why not? :P
05:06:25 <jauaor> ASau: this is a new language
05:06:39 <ASau> Sure, and it is far from Forth.
05:06:40 <jauaor> and as I said, it shares the stack based and RPN features
05:06:42 <ASau> It is Smalltalk.
05:06:55 <jauaor> you can say that .. if you feel it so :)
05:07:05 <ASau> By your words, C is stack based.
05:07:09 <jauaor> I am actually mixing lot of languages styles here
05:07:18 <gogonkt> :D
05:07:21 <ASau> Look, there's clear notion of stacked activation records.
05:07:35 <gogonkt> it smalltalk clone
05:07:40 --- quit: neceve (Remote closed the connection)
05:07:40 <jauaor> I still don't release any paper about the language
05:07:47 <ASau> Oh, and "++" and "--" operations :)
05:07:50 <jauaor> I guess I should .. to clarify if possible
05:08:03 <ASau> Yeah, C is close to Forth. :)
05:08:05 <jauaor> but it is a stack based language in its all meaning :)
05:08:13 <ASau> It is stack-based and has RPN.
05:08:22 <jauaor> what?
05:08:54 <jauaor> mm..
05:09:04 <jauaor> all you see there is done using RPN and Stacks only
05:09:14 <jauaor> it is a stack-based language
05:09:34 <ASau> I don't see any code in your example, which is stack based in Forth/PostScript/POP-11 sense.
05:09:35 <jauaor> (programming language paradigm definition)
05:09:50 <ASau> The way you use "stack-based" is the same as in C.
05:10:19 <jauaor> ASau: this code is actually to show the Struct and OO capabilities of the language
05:10:30 <jauaor> and yes, it does hide the RPN
05:10:37 <jauaor> I did this on purpose
05:10:42 <jauaor> but it only uses RPN
05:10:42 <gogonkt> to much toys a year
05:10:47 <jauaor> hah
05:11:13 <ASau> Listen, Smalltalk uses stack as well.
05:11:16 <gogonkt> too much wheels too
05:11:25 <ASau> This doesn't make it _stack-based_.
05:11:35 <ASau> Oh, well.
05:11:39 <jauaor> I know, I am taking Smalltalk as a model too for the language
05:11:48 <ASau> And message sending is clearly postfix.
05:11:50 <jauaor> it is actually good you see it like some kind of Smalltalk
05:12:12 <ASau> This doesn't make Smalltalk similar to Forth anyway.
05:12:20 <ASau> And definitly doesn't make it stack-based.
05:12:27 <jauaor> well, this is not smalltalk
05:12:29 <jauaor> like i said
05:12:32 <jauaor> it is a new language
05:12:32 <ASau> Sure.
05:12:40 <ASau> There're other Smalltalk-like languages.
05:12:42 <ASau> E.g. Slate.
05:12:46 <jauaor> aha
05:12:48 <gogonkt> why not add libary to smalltalk, a better way :)
05:13:36 <jauaor> ASau: as I said, when I say stack-based, I mean the programming paradigm
05:13:44 <jauaor> this language follows such a paradigm
05:13:52 <ASau> This language doesn't follow it.
05:14:00 <jauaor> why not?
05:14:00 <ASau> It is clear to see from your example.
05:14:10 <ASau> Check other stack based languages.
05:14:18 <ASau> PostScript, POP-11, Cat, Joy.
05:14:21 <jauaor> why not?, and you actually understand my example? :)
05:14:35 <ASau> Because there's no open stack in your example.
05:14:38 <jauaor> gogonkt: because I wanted to do certain things different from the ground
05:15:00 <jauaor> ASau: see, you really don't know
05:15:00 <ASau> And this is the main distinctive thing of stack-based languages.
05:15:02 <jauaor> ....
05:15:16 * jauaor really needs to write a doc about it soon
05:15:17 <gogonkt> ok, belive what you blive :)
05:15:20 <jauaor> you know Kevo?
05:15:28 <jauaor> ASau: you know Kevo?
05:15:51 <jauaor> so far, I only can send you to read docs about it, since I don't write mines yet
05:15:54 <jauaor> :)
05:15:58 * jauaor gets more caffeine 
05:16:04 <ASau> No, but it doesn't live in stack-based area.
05:16:16 <jauaor> hah
05:16:41 <gogonkt> belief
05:16:50 <ASau> Not in this area.
05:17:11 <jauaor> The whole are is a stack ... and all you see there are ... stacks
05:17:14 <jauaor> yet again
05:17:25 <jauaor> it doesn't look likek so :)
05:17:50 <gogonkt> hoho
05:17:56 <jauaor> I did it on purpose, and it is all there .... it is all clear once you know it is there
05:18:07 <ASau> jauaor: you can see the stack in C, and it is there.
05:18:21 <ASau> You don't have free access to it,
05:18:27 <ASau> and this is why C isn't stack-based.
05:18:31 <jauaor> but from an outsider look, it might seem like another kind of language, I know your confusion ASau , and I take it as good you see it as a Smalltalk
05:18:39 --- quit: f[x] (Read error: 145 (Connection timed out))
05:18:43 <jauaor> ASau: you have free access here
05:18:49 <jauaor> you just can't figure out it 
05:18:54 <jauaor> you don't know the language
05:18:58 <jauaor> :)
05:19:08 <ASau> I know the language as far as your examples show it.
05:19:14 * jauaor hopes to get some doc soon up
05:19:26 <ASau> If your example doesn't show open stack, blame yourself.
05:19:38 <jauaor> yes, but i guess you need to read some docs too .... before jumping at such a conclusions :P
05:19:52 * jauaor admits he is trying some "weird" stuff here
05:20:02 <jauaor> man .. I am going to get rid of this keyboard protector
05:20:02 <ASau> "Description: Kevo is a prototype-based object-oriented language for Macintosh."
05:20:08 <ASau> Nothing stack-based.
05:20:19 <gogonkt> your example cant show me, your docs can?
05:20:25 <jauaor> ASau: yeah it is, check further
05:20:41 <ASau> jauaor: show me the code.
05:20:41 <jauaor> gogonkt: well, at least for ASau to clear his questions
05:20:52 <jauaor> ASau: the code of what?
05:21:06 <ASau> The code, which proves that your language is stack-based.
05:21:21 <jauaor> I just did
05:21:26 <ASau> No, you didn't.
05:21:26 <jauaor> it is all there
05:21:28 <jauaor> yeah
05:21:30 <jauaor> http://paste2.org/p/441539
05:21:38 <ASau> This is the same way C uses stack.
05:21:42 <gogonkt> ok, forget it
05:21:46 <ASau> It doesn't make C stack-based.
05:22:13 <jauaor> ASau: C uses formal parameters for functions ... mm.. see, I am talking about the stack-based language definition 
05:22:26 <jauaor> not about the stack computer science concept
05:22:29 <ASau> What is your definition then?
05:22:32 <jauaor> don't you know the diference?
05:22:45 <jauaor> A stack-oriented programming language is one that relies on a stack machine model for passing parameters. Several programming languages fit this description, notably Forth, RPL and PostScript, and also many Assembly languages (but on a much lower level).
05:22:50 <jauaor> that simple one
05:22:52 <jauaor> .......
05:22:55 <ASau> Wrong definition.
05:23:11 <jauaor> why?
05:23:12 <ASau> If it doesn't provide _open_ stack, it isn't stack-based.
05:23:16 <gogonkt> j#
05:23:26 <jauaor> ASau: what do you mean with open stack?
05:23:32 <ASau> Because it can pass parameters in heap-allocated records.
05:23:40 <ASau> and have same success.
05:23:45 <gogonkt> @d4->T->x $2 push <-- you mean this is 'stack based'?
05:24:33 <jauaor> gogonkt: there, @d4->T->x is an object , pushed into the main Stack , and then $2 is pushed into such an object
05:24:34 <ASau> "Open stack" is what the stack is in POP-11, Forth, PostScript, which established the field.
05:24:39 <ASau> Direct access.
05:24:46 <gogonkt> - -b....
05:24:51 <jauaor> ASau: good, it is the same in my language
05:24:59 <ASau> "swap", "drop", "roll" to manipulate stacked items.
05:25:04 <jauaor> correct
05:25:17 <jauaor> it's how it works here too
05:25:29 <ASau> Without checking, if it crosses some boundary.
05:25:34 <gogonkt> - -b...
05:25:42 <ASau> It may work that way, but it isn't in the language.
05:25:57 <ASau> And that's why the language is _not_ stack-based.
05:26:09 <jauaor> ASau: and that is pretty much what implies the simple stack-based definition i pasted ... since you can properly do that with an open stack 
05:26:24 <jauaor> ASau: and i am telling you, it is there in the language
05:26:30 <ASau> You can do it with open stack, but it isn't _in_ the language.
05:26:35 <jauaor> just like forth, postscript ....
05:26:38 <ASau> Show me the code.
05:26:46 <jauaor> the code of the interpreter?
05:26:47 <ASau> Where's any stack operation there?
05:26:56 <ASau> No, in your pasted code above.
05:27:08 <gogonkt> ASau: get some sleep or coffe, dont waste time...
05:27:13 <jauaor> all the operations you see there are occurring inside Stacks
05:27:19 <ASau> gogonkt: It's working day here.
05:27:26 <gogonkt> :)
05:27:28 <jauaor> everything is either a Stack or an object, for example, read what I said to gogonkt 
05:27:33 <ASau> jauaor: yes, and that's the point _inside_ stacks.
05:27:35 <jauaor> about the @d4 line
05:27:37 <ASau> You don't have open stack.
05:27:46 <jauaor> I do
05:27:52 <ASau> It's all happenning behind the curtain.
05:27:56 <jauaor> the main execution environment is an open stack
05:27:58 <jauaor> no
05:28:00 <gogonkt> he dont know what is stack based language
05:28:04 <ASau> And that's why the language is _not_ stack based.
05:28:21 <jauaor> why not?
05:28:30 <jauaor> it has the so called open stack you say
05:28:36 <ASau> No, it isn't.
05:28:43 <jauaor> hah
05:28:45 <ASau> Your code doesn't have any stack operation.
05:28:49 <jauaor> hah
05:28:52 <jauaor> it does 
05:28:56 <gogonkt> forget "stack based"
05:28:58 <ASau> Where's it?
05:28:58 <jauaor> hah
05:29:04 <jauaor> ASau: All of them!
05:29:05 <jauaor> hah
05:29:08 <ASau> One line, please.
05:29:15 <jauaor> I am just mixing plenty of stuff here
05:29:25 <jauaor> ok, this one:
05:29:27 <ASau> dup dup * +
05:29:29 <ASau> ~~~ ~~~
05:29:35 <ASau> two stack operations here.
05:29:41 <jauaor> % ^$->T->Xop +
05:29:42 <gogonkt> no stack based in you code, pls
05:29:46 <jauaor> % is dup
05:29:53 <jauaor> there you have the line
05:29:56 <jauaor> hah
05:30:10 <jauaor> ok, i see, you just want a traditional example
05:30:17 <jauaor> just that the language is not traditional
05:30:19 <jauaor> :P
05:30:24 * jauaor really needs to write docs
05:30:35 <ASau> And other operations
05:30:36 <ASau> ?
05:30:38 <jauaor> hah
05:30:44 <jauaor> I will write the docs soon :)
05:30:53 <jauaor> & is swa
05:30:55 <jauaor> err
05:30:57 <jauaor> & is swap
05:31:08 <jauaor> you can also use "swap"
05:31:18 <jauaor> but I am also adding op shortcuts
05:31:29 <jauaor> and you can do stuff like: 
05:31:30 <ASau> Fine.
05:31:32 <jauaor> &%&&%&
05:31:45 <jauaor> swap dup swap swap dup swap
05:31:54 <gogonkt> @@
05:31:56 <jauaor> hah
05:32:01 <jauaor> just don't abuse it
05:32:02 <jauaor> :P
05:32:09 <ASau> Why not?
05:32:09 <jauaor> but it comes in handy sometimes
05:32:24 <ASau> This makes your language stack-based bastard.
05:32:28 <jauaor> hah
05:32:37 <gogonkt> i can add swap dup swap swap dup swap to c or smalltalk too
05:32:44 <jauaor> my language inherit from many other languages ... so :P
05:32:51 <jauaor> gogonkt: nice :)
05:33:10 * jauaor is taking ideas from smalltalk too
05:33:18 <ASau> yes, and it shows.
05:33:27 <gogonkt> but that cant made it be a stack based language, you know?
05:33:30 <ASau> Your language is much closer to Smalltalk than to Forth.
05:33:38 <jauaor> let me show qsort
05:33:47 <jauaor> wanna see qsort?
05:33:53 <gogonkt> no
05:34:12 <jauaor> it shows more "traditional" stack operations
05:34:13 <ASau> Are we going to see Smalltalkish qsort?
05:34:23 <jauaor> since you just want traditional stuff ;)
05:34:46 <gogonkt> traditional Smalltalkish qsort ~~
05:34:58 <jauaor> but I admit, I am doing many things on purpose here .. one of them ... to "look" and "feel" different than the rest of the stack-based languages
05:38:31 <jauaor> http://paste2.org/p/441559
05:38:34 <jauaor> quicksort
05:38:37 <jauaor> for all the fans
05:38:39 <jauaor> haha
05:52:53 <gogonkt> jauaor: no monkey in your code
05:53:52 <jauaor> it is not monkey-based
05:53:54 <jauaor> :P
06:16:42 <gogonkt> s" ä½ " type ä½  ok
06:17:00 <gogonkt> but s" ä½ " chars dump 808C1F0: E4 BD A0                 -                           ...
06:17:03 <gogonkt> ok
06:17:38 <gogonkt> how dump utf8 string?
06:17:41 --- join: nighty__ (n=nighty@x122091.ppp.asahi-net.or.jp) joined #forth
06:20:46 <ASau> Ask our standardizers.
06:21:05 <ASau> They believe they know everything and can do everything fine with UTF-8.
06:22:36 <gogonkt> oh
06:23:44 <gogonkt> who is our standardizers?
06:26:52 <gogonkt> found in sources
06:35:30 --- join: ahelon (n=hmm@unaffiliated/ahelon) joined #forth
06:35:58 --- quit: nighty__ (Client Quit)
06:48:53 --- join: calin (n=calin@95.76.17.31) joined #forth
06:59:38 --- quit: jauaor ()
07:12:08 --- join: segher (n=segher@84.105.60.153) joined #forth
07:23:04 --- join: GeDaMo (n=gedamo@212.225.115.96) joined #forth
07:26:28 --- quit: calin (Read error: 104 (Connection reset by peer))
07:33:27 --- join: nighty__ (n=nighty@x122091.ppp.asahi-net.or.jp) joined #forth
07:45:00 * madgarden is back (gone 11:38:56)
07:46:04 --- quit: nighty__ (Client Quit)
07:58:26 --- quit: ASau ("off")
08:11:13 --- quit: mathrick (Read error: 110 (Connection timed out))
08:21:34 --- join: f[x] (n=user@95.133.206.109) joined #forth
08:55:01 --- join: tathi (n=josh@dsl-216-227-91-166.fairpoint.net) joined #forth
09:11:29 --- join: I440r (n=me@c-69-136-171-118.hsd1.in.comcast.net) joined #forth
09:21:54 --- join: Snoopy_1711 (i=Snoopy_1@dslb-088-068-192-193.pools.arcor-ip.net) joined #forth
09:33:31 --- join: ASau (n=user@83.69.227.32) joined #forth
09:33:57 --- join: kar8nga (n=kar8nga@jol13-1-82-66-176-74.fbx.proxad.net) joined #forth
09:39:42 --- quit: Snoopy_1611 (Read error: 110 (Connection timed out))
10:42:56 --- join: pgas (n=user@pdpc/supporter/active/pgas) joined #forth
11:00:57 --- join: mathrick (n=mathrick@87.58.113.80) joined #forth
11:10:28 --- nick: Snoopy_1711 -> Snoopy_1611
12:15:57 --- join: dandersen (n=dkcl@metabug/dandersen) joined #forth
12:16:51 --- nick: dandersen -> dkcl
12:18:35 --- quit: mathrick (Read error: 145 (Connection timed out))
13:25:08 --- join: neceve (n=ncv@unaffiliated/neceve) joined #forth
13:25:29 --- join: mathrick (n=mathrick@130.226.70.177) joined #forth
13:27:11 --- quit: dkcl ("leaving")
13:29:24 --- quit: pgas ("/quit")
13:33:27 --- quit: f[x] (Read error: 145 (Connection timed out))
13:48:39 --- join: Snoopy_1711 (i=Snoopy_1@dslb-088-068-192-193.pools.arcor-ip.net) joined #forth
14:00:12 --- quit: GeDaMo ("Leaving.")
14:05:33 --- quit: Snoopy_1611 (Read error: 110 (Connection timed out))
15:05:18 --- quit: kar8nga (Read error: 104 (Connection reset by peer))
15:19:38 --- quit: neceve (Remote closed the connection)
15:30:18 --- join: ENKI-][1 (n=weechat@c-71-234-190-248.hsd1.ct.comcast.net) joined #forth
15:30:18 --- quit: ENKI-][ (Read error: 104 (Connection reset by peer))
15:38:44 --- nick: ENKI-][1 -> ENKI-][
15:46:12 --- join: jauaor (n=araujo@190.38.49.150) joined #forth
15:46:52 <jauaor> hello :)
15:54:49 <tathi> hi
16:33:12 --- quit: tathi ("leaving")
16:47:40 --- nick: Snoopy_1711 -> Snoopy_1611
16:57:11 --- quit: ahelon (Read error: 101 (Network is unreachable))
17:18:48 --- join: nighty^ (n=nighty@210.188.173.245) joined #forth
17:33:14 --- join: newcmr (i=5811c0af@gateway/web/freenode/x-lamjqjyykupehnwo) joined #forth
17:34:13 <newcmr> hi, I've been told that forth is one of the pilar languages of programming... What's in your opinion the best introductory book?
17:38:29 --- quit: madwork (Read error: 110 (Connection timed out))
17:46:47 --- quit: jauaor ()
17:47:10 --- join: schmx (n=marcus@sxemacs/devel/schme) joined #forth
17:47:12 --- quit: schme (Read error: 104 (Connection reset by peer))
17:55:32 <I440r> newcmr, theres really not much in the way of books out there. thers starting forth which is old but is still a good place to start
17:55:37 <I440r> then therse thinking forth
17:55:40 <I440r> both by leo brodie
17:55:56 <I440r> there are also alot of forth tutorials available
17:55:56 <newcmr> ok, thanks I440r 
18:01:00 --- part: newcmr left #forth
18:05:20 <segher> the books by elizabeth rather are nice
18:05:49 <segher> much more modern, as well
18:25:16 <I440r> pity about them being ans tho eh? }:)
18:28:39 <segher> imnsho, there is nothing wrong with ISO Forth.  don't use the features you don't like, duh
18:28:58 <I440r> that would acount for about 99% of the standard :P
18:29:02 <I440r> and i already DONT :P~
18:29:10 <segher> i understand your position though, i'm appalled at some of the proposed stuff for 200x
18:29:34 <I440r> the ans standard is an immensly complex solution to a very simple problem
18:29:36 <segher> like, character constants, seriously?
18:29:42 <segher> no
18:29:51 <segher> the standard is very very simple imo
18:30:12 <I440r> postpone is WAY more complex than compile and [compile]
18:30:19 <I440r> catch throw is an abomination. its HORRIBLE
18:30:22 <segher> did you ever look at some other language standard?  :-)
18:30:34 <segher> throw is great, heh
18:30:40 <I440r> the ans standard team refused to define NOT because there were already two conflicting definitions for it
18:30:52 <segher> yeah, so?
18:30:56 <I440r> ONE of them is a dumbass BROKEN definition. the other one was fixed in the 83 standard
18:31:23 <segher> 0= is useful.  INVERT is a good name.  alias NOT to it if you want.  what is the problem?
18:31:31 <I440r> 0= is a good word
18:31:38 <I440r> it is a test for equality with ZERO
18:32:07 <I440r> NOT is NOT 0=
18:32:24 <segher> NOT is TRUE XOR
18:32:32 <segher> well, INVERT is
18:38:56 --- join: Al2O3_ (n=Al2O3@c-24-9-43-112.hsd1.co.comcast.net) joined #forth
18:48:01 --- quit: Al2O3 (Read error: 110 (Connection timed out))
18:48:02 --- nick: Al2O3_ -> Al2O3
20:17:22 --- quit: gogonkt ("leaving")
20:17:42 --- join: gogonkt (n=info@59.38.200.29) joined #forth
20:46:26 --- join: jauaor (n=araujo@190.38.49.150) joined #forth
20:49:41 <jauaor> :)
20:52:56 <gogonkt> interesting http://ronware.org/reva/wiki/Help
20:53:50 --- quit: gogonkt ("leaving")
20:54:06 --- join: gogonkt (n=info@59.38.200.29) joined #forth
21:25:20 --- join: w7tek (n=w7tek@knowlton.dsl.xmission.com) joined #forth
21:43:15 --- quit: segher ("This computer has gone to sleep")
22:27:39 --- quit: ASau ("off")
22:53:49 --- join: neceve (n=ncv@unaffiliated/neceve) joined #forth
23:06:04 --- join: f[x] (n=user@95.133.173.19) joined #forth
23:59:59 --- log: ended forth/09.09.28