00:00:00 --- log: started forth/01.10.19
00:20:35 --- quit: I440r ()
03:17:03 --- quit: MrReach (Read error to MrReach[209.181.43.190]: Connection reset by peer)
03:18:21 --- join: MrGone (mrreach@209.181.43.190) joined #forth
07:17:03 --- join: smordech (bronko@A8218.pppool.de) joined #forth
07:17:07 --- part: smordech left #forth
08:09:55 --- log: started forth/01.10.19
08:09:55 --- join: clog (nef@bespin.org) joined #forth
08:09:55 --- names: list (clog MrGone)
11:07:46 --- nick: MrGone -> MrReach
11:14:45 --- join: futhin (thin@h24-66-209-114.cg.shawcable.net) joined #forth
11:14:54 <futhin> howdy
11:14:57 <futhin> (brb)
11:15:00 <MrReach> hihi!
11:17:06 <futhin> back
11:17:16 <futhin> you could've typed it all out while i was gone :)
11:17:23 <MrReach> I've been thinking about how to effeciently incorporate shared libraries into forth
11:17:30 <MrReach> I have been typing
11:18:27 <MrReach> when using an already existing OS, things are pretty much fixed
11:18:55 <MrReach> but there is still some leeway regarding interface
11:19:07 <futhin> hm
11:19:22 <futhin> hm == "i'm here and listening ;)"
11:19:23 <MrReach> I very much like the idea of C header files
11:19:45 <MrReach> but they're syntax doesn't really make sense in Forth
11:20:32 <futhin> in gforth you can do  "require blah.fs"  it's pretty cool
11:20:48 <MrReach> yes, but that doesn't let you into the shared libs
11:21:05 <MrReach> glibc, for example ... which gforth uses extensively
11:21:41 <MrReach> the fact is, were gforth not written in C, getting to glibc would be a nightmare
11:22:25 <futhin> ture
11:22:26 <futhin> true
11:23:14 <MrReach> I was thinking that using a lib should be as simple as ...
11:23:36 <MrReach> NEEDS blah.4th  ALSO blah-words
11:24:28 <MrReach> then one could do ...
11:24:46 <MrReach> : test 1 2 blah-func1 . ;
11:25:39 <MrReach> that's pretty close to ANS, too
11:26:57 <MrReach> (ANS doesn't have NEEDS, and it's non-trivial)
11:29:19 <MrReach> you are obviously quite busy ... sorry for disturbing you.
11:35:32 <futhin> woops
11:35:57 <futhin> you annoyed at me for being away? 
11:36:07 <MrReach> fustrated
11:36:11 <futhin> yeah
11:36:20 <MrReach> It's hard to find someone to talk forth to, as you well know
11:36:30 <futhin> yep yep yep.. but i'm on your icq list :)
11:36:35 <MrReach> and this channel has been somewhat empty for several days
11:36:44 <futhin> yeah 
11:37:01 <futhin> well geez, i started playing on the mud that i440r plays on and got distracted from my higher goals heh
11:37:12 <MrReach> heh
11:37:24 <futhin> plus there's some midterms coming up
11:37:45 <MrReach> I440r would probably say that using shared libs is *EVIL* ... and that all needed functions should be coded in Forth
11:37:58 <MrReach> ah! forgot you were in school
11:38:07 <futhin> heh :)
11:38:29 <futhin> shared libs are probably evil ;)    we should rid the world of C and make everything coded in forth
11:38:54 <MrReach> heh ... you go ahead and try to recode the XWindow system so that it's "right"
11:39:14 <MrReach> not me, I want to accomplish other things in my life.
11:39:17 <futhin> heh
11:40:15 <futhin> i'm thinking more of an os 
11:40:27 <MrReach> yes, I know you do
11:40:36 <futhin> i don't really like linux or windows
11:40:44 <MrReach> that's why I thought you might be interested in the interface to shared libs
11:41:11 <futhin> why?  an os would be coded from scratch in forth .. :)
11:41:20 <MrReach> of course
11:41:35 <MrReach> but that doesn't mean you want everything under the sun loaded all the time
11:42:06 <MrReach> fonts, for example ... you only need the ones you're using to be in memory
11:42:07 <futhin> ture
11:42:08 <futhin> true
11:42:12 <MrReach> (and maybe not even then)
11:42:20 <futhin> eh?
11:42:25 <futhin> and not even then?
11:42:53 <MrReach> if an application seldom writes to the screen ... no reason not to unload the font and reload it when you need it
11:43:18 <futhin> yeah
11:43:24 <MrReach> but that should be a descision of the library, with influence by the application
11:43:33 <MrReach> not the sole responsibility of the application
11:43:41 <futhin> so we're talking about how forth can have libs
11:43:51 <MrReach> that's what I was thinking about
11:44:18 <MrReach> although I was thinking more along the lines of how the interface LOOKS, rather than how it works
11:44:29 <MrReach> I was thinking along the lines of current OSs
11:44:57 <MrReach> Windows, XWindows, Linux, BSD, etc
11:45:11 <futhin> notify
11:45:15 <futhin> oops
11:45:17 <MrReach> they all look pretty much the same, programming wise
11:45:32 <futhin> yeah
11:45:38 <MrReach> a Forth OS would probably use a similar mechanism
11:47:40 <futhin> hm
11:48:01 <futhin> NEEDS blah.4th ALSO blah-words ??
11:48:17 <MrReach> yes, which part confuses you?
11:48:51 <MrReach> NEEDS ?
11:48:55 <MrReach> ALSO ?
11:48:57 <MrReach> both?
11:49:24 <MrReach> neither of then is ANS, if you're checking
11:49:55 <futhin> gforth has NEEDS  i think
11:50:13 <futhin> but
11:50:16 <futhin> how does it work
11:50:22 <MrReach> which part of the fragment confuses you?
11:50:29 <MrReach> how does NEEDS work?
11:50:44 <futhin> NEEDS blah.4th refers to the file and ALSO includes the specific word from the file ??
11:51:13 <MrReach> no, ALSO duplicates the top item in the search order
11:51:40 <futhin> huh?
11:51:47 <MrReach> VOCABULARY <name> creates a dictionary wordlist
11:52:09 <MrReach> when the interpreter is search for words ...
11:52:23 <MrReach> it uses a a "search order" to find them
11:52:32 <MrReach> the top wordlist is searched first
11:52:42 <MrReach> then the next to top, and so on
11:53:21 <MrReach> in *MOST* forths, the result of executing the name of a vocabulary is to REPLACE the top item in the search order with it's own wordlist
11:53:46 <futhin> hmm
11:54:22 <MrReach> so NEEDS might load 100 words, but in their own wordlist, where they are out of the way
11:54:45 <MrReach> they are innaccessible until the vocab is put into the search order
11:54:53 <futhin> cool
11:55:25 <MrReach> ALSO would duplicate the top search order item, then blah-words replaces the top item with its own wordlist
11:55:56 <MrReach> so, if the search order had been "Forth Assembler" ...
11:56:15 <MrReach> it would then become "Forth Assembler blah-words"
11:56:49 <MrReach> none of this changes the voculary that you are currently defining new words for
11:57:09 <MrReach> (which doesn't HAVE to be in the search order, btw)
12:00:37 * MrReach sighs.
12:01:03 <futhin> hmm
12:01:04 <futhin> what
12:01:16 <futhin> i don't know what to say heh
12:01:38 <futhin> what's the problem, is it not a workable idea?  is it not the way to do it
12:01:39 <MrReach> I'm just rying to think my way through this
12:01:57 <MrReach> well, when importing large libraries
12:02:10 <MrReach> I'd like the interface to be stored in binary form
12:02:25 <MrReach> so that there isn't a BUNCH of text parsing to be able to use it
12:03:09 <MrReach> also, turnkey apps don't NEED the dictionary info, which is far larger than the code itself
12:04:07 <futhin> yep
12:04:36 <MrReach> so, for each lib that we want to access, there's two files to be loaded into mem
12:04:52 <MrReach> 1. the forth code needed to access each routine
12:05:08 <MrReach> 2. the dictionary to specify where to find the code words
12:05:25 <MrReach> #1 should be able to function w/o having to load #2
12:06:13 <MrReach> incidently, these are EXCELLENT places to use the word "slurp" that I had given to you earlier
12:06:50 <futhin> hmm.. but what happens if the forth code needs to access a routine that's not loaded?  how is #1 going to be able to function w/o loading #2 ??
12:07:24 <MrReach> #1 has to have enough info in it to load a shared object and access its routines
12:07:58 <futhin> how does it have that info?
12:08:13 <futhin> the info comes from #2 at some point right?
12:08:46 <MrReach> linux and wondows both use a function with the same paramaters to load a shared object ... in Linux it's called "uselib" and on windows it's called "loadlib"
12:09:11 <MrReach> they both have the params ( a-zname -- hdl )
12:09:30 <MrReach> a-zname is a null-terminated string of the library file to be loaded
12:09:57 <futhin> what does the a-z in a-zname mean?
12:10:27 <MrReach> then, to find a particular procedure, Windows uses GetProcAddress
12:10:43 <MrReach> a-z means "address of ASCIIZ string"
12:11:37 <MrReach> and I forget the linux version of GetProcAddress, but it also has the same parameters as windows
12:12:08 <MrReach> those params are ( hdl a-zProcName -- adr | 0 )
12:12:37 <futhin> uselib sounds better than loadlib
12:12:43 <futhin> in the naming of it
12:12:45 <MrReach> the hdl is the handle returned by LoadLib
12:13:03 <MrReach> ok, I don't care how they're named in the various OSs
12:13:11 <MrReach> jst so long as they are available
12:13:21 <futhin> i care about how its named ;)
12:13:34 <MrReach> they would be named something else in Forth
12:13:39 <MrReach> those are the C names
12:15:11 <MrReach> I wrote an interface for Win32Forth once, it used ONLY lib: ( a-str u-cnt -<name1>- -- ) ... and proc: ( a-str u-cnt -<name2>- -- )
12:15:44 <MrReach> it worked MUCH better than the Win32Forth stock interface
12:16:11 <MrReach> because, with win32forth, the system loads ALL libs and finds ALL procedures at startup
12:16:26 <MrReach> if a .DLL is missing, Win32Forth borks
12:17:07 <MrReach> it also tries to load the .DLL as soon as you tell it that it exists
12:18:28 <MrReach> the interface I wrote never loaded the library until one of its functions was called, and never search for the address of a procedure until it was actually invoked
12:19:03 <MrReach> also, a lib could be unloaded at any time
12:19:18 <MrReach> which you can't do with win32forth
12:19:37 <MrReach> Zimmer really had his head up his ass when he wrote that interface
12:19:44 <futhin> heh
12:20:25 <MrReach> brb
12:27:04 <MrReach> back
12:27:40 <MrReach> my wife is supposed to pick me up in 3 mins to go out to one of her clients
12:27:55 <MrReach> I'll bet she forgets, and I get to be pissed off at her.
12:28:43 <futhin> heh
12:28:52 <futhin> why does she want you to meet her client?
12:29:26 <MrReach> her client is an old friend of my family
12:29:37 <MrReach> I haven't seen him in the better part of a year
12:29:39 <futhin> ahh
12:30:01 <MrReach> I thought it would be nice to drop by and say "hello" ... but he lives 40 miles from here
12:30:16 <MrReach> so I was going to ride with my wife
12:30:36 <futhin> ah
12:31:14 <futhin> i've got this really cool and grandoise idea, but i'll wait and see if you are going to stick around so i can tell it heh :)
12:31:43 <MrReach> go ahead, I give it 3 chances and 10 that she shows up to pick me up
12:32:38 <MrReach> at 14:45 pacific, I'll call her at her clients and chew her out
12:32:46 <MrReach> ooops 13:45
12:33:25 <futhin> why chew her out?  just be like "you forgot me, have fun, i'm on irc talking to futhin, haha" :P 
12:33:43 <MrReach> something like that
12:34:00 <MrReach> because we had made plans, which she forgot
12:35:31 <futhin> well i'm guessing that she forgets more often than once in a blue moon?
12:35:35 <MrReach> if she's not here in 1/2 hour, then she's not coming
12:35:53 <MrReach> I only ask once in a bleu moon
12:36:20 <MrReach> like I said, I haven't seen Carl is just about a year
12:36:43 <MrReach> (I am the godfather of his great granddaughter)
12:38:49 <MrReach> I think Windows .EXEs are way cool because you can store all SORTS of data in them (as resources) and retrieve it at runtime
12:39:06 <MrReach> (that's much harder with ELF binaries)
12:39:24 <futhin> the basic idea: collaborative editor in forth.   extending the idea:  create a collaborative universe for forth coders to get together and code forth.  extending the idea further:  coders and strangers get together on a project and CODE, increasing productivity, completing projects faster
12:40:07 <futhin> i've got some other ideas on how it'll work and how to get all sorts of people in huge numbers to code on 1 project
12:40:12 <MrReach> are you thinking about TeamWave as you write that?
12:40:50 <MrReach> how much interactivity?
12:41:05 <futhin> i'm thinking something better than teamwave.. remember when we tried to write in the postitnote at the same time.. that was annoying..  and since we were writing code, it'd be cooler if we could've run the code there, instead of copying it over to win32forth
12:41:24 <MrReach> indeed
12:41:44 <MrReach> CVS systems work MUCH better for collaborative coding
12:42:03 <MrReach> generally, you don't want to both write code simultaneously
12:42:24 <MrReach> but the postit idea is very good for sharing ideas
12:42:30 <MrReach> (and IRC type chats)
12:43:10 <futhin> but i'm also thinking on another level:  forth coders need to get together and code effectively, in an "informal" way.   if any forth coder, a stranger, can join this interactive collaborative universe and SEE other people coding, and see them talking, they can join in immediately.   this would be great for building a stronger community of forth coders. 
12:43:30 <MrReach> indeed
12:43:33 <futhin> as well as completing projects sooner
12:43:41 <MrReach> also, a decent repository would go a long way
12:43:53 <futhin> imagine a 100 people get onto this interactive universe and boom, the os is done :)
12:44:46 <MrReach> check this out ...
12:45:14 <MrReach> http://webdev.amsystech.com/mlosh/webforth.htm
12:45:16 <futhin> CVS isn't interactive, i want interactive for a number of reasons.   one of the main reasons is that i'm lazy, and other people like I440r are a little lazy too.. but if i see other people coding, and see people talking about the issues, then i'm much more likely to jump in and become productive
12:45:20 <MrReach> here comes Speuler
12:45:48 <futhin> how did you know he was coming?
12:45:59 <MrReach> *** Speuler is on IRC
12:46:06 <MrReach> http://webdev.amsystech.com/mlosh/webforth.htm
12:46:54 <MrReach> whois Speuler is on IRC
12:46:57 --- join: Speuler (schwan@clementine.icafe.spacenet.de) joined #forth
12:46:57 <futhin> mrreach: part of the collaborative universe is to see other people coding at the same time.  people would be able to form programming pairs (extrememprogramming).. 
12:47:16 * Speuler send you greetings
12:47:22 <MrReach> hihi, Speuler
12:47:31 <futhin> howdy speuler
12:47:45 <Speuler> hallo mrreach hello futhin
12:47:51 <MrReach> did you check out that URL? that might be an interesting starting point
12:48:08 <MrReach> for Speuler: http://webdev.amsystech.com/mlosh/webforth.htm
12:48:24 <Speuler> what's that ?
12:48:34 <Speuler> forth plugin ?
12:48:36 <futhin> what about the webforth? i've seen it before..
12:48:39 <MrReach> it's EForth interactive in a Java window
12:49:04 <Speuler> heard about. forth applet, written in java ?
12:49:20 <MrReach> no, don't think it's an applet
12:49:26 <MrReach> think it runs on server
12:49:34 <Speuler> ah
12:49:35 <futhin> it's java
12:50:11 <futhin> it says webforth: java applet..
12:50:53 <MrReach> heh, yes, but when you put an item on the stack, where is that number stored?
12:51:16 <MrReach> is it stored somewhere on MY computer? or is it stored on a stack on the server?
12:51:33 <futhin> your comp..
12:51:36 <futhin> i would expect
12:51:50 <futhin> it's java applet so it's running off your comp
12:51:52 <MrReach> no, I think the Forth is running on the server
12:52:04 <MrReach> and the Java applet is simply a terminal
12:52:13 <futhin> hmm
12:53:33 <futhin> no
12:53:39 <MrReach> you're right
12:53:40 <futhin> i don't think so.. i looked at the code
12:53:47 <MrReach> the forth is local, written in Java
12:54:17 <MrReach> blah
12:54:25 <futhin> so what do you think about my collaborative idea
12:54:43 <MrReach> I like it
12:54:50 <MrReach> I like Teamwave, too
12:54:52 <MrReach> a lot
12:55:09 <MrReach> what platforms would you want to support?
12:56:24 <futhin> forth jobs could even be generated thru the collaborative thing.  the forth coders can be representatives for the company in their respective areas, and the company will just be international, and all the forth coders work on projects online.  the forth coders act as representatives and find projects in their local area and then put it up on the collaborative universe and the coders get paid on the work they do
12:57:06 <MrReach> what platforms would you want to support?
12:57:10 <futhin> linux
12:57:28 <MrReach> just one platform?
12:57:49 <futhin> maybe windows.. but it might not really be necessary to support windows because forth coders can install linux or telnet to a linux server
12:58:09 <futhin> linux would be made first then windows second i'd guess...
12:58:13 <futhin> dunno
12:58:15 <futhin> heh
12:58:17 <futhin> it's just an idea
12:58:28 <MrReach> ok, windowing or text only?
12:58:37 <futhin> i haven't gotten to the stage yet where i'm implementing my ideas :(
12:58:47 * Speuler likes stand-alone forth
12:58:50 <MrReach> of course not
12:59:05 <MrReach> heh, Speuler, no outside OS at all?
12:59:19 <Speuler> no resource hogs around
12:59:22 <futhin> dunno.. probably windowing.. but if it could be done in text and still be effective..
12:59:36 <MrReach> heh, that's a hell of a lot of work to make a socket connection
12:59:56 <MrReach> I don't think it would be nearly as effective in text mode
13:00:01 <futhin> speuler: stick around and eventually we'll have a forth os
13:00:07 <MrReach> couldn't draw figures, for instance
13:00:09 <futhin> and all the drivers necessary
13:00:13 <Speuler> mrreach: true, but the learning effect is immense
13:00:23 <MrReach> HAHAHA!
13:00:37 <Speuler> w/o forth, i'd never have learned to write drivers taken as granted on OS
13:00:40 <MrReach> you're right, I've never written code to bit-bang an ethernet card
13:00:51 <Speuler> i'd love to
13:01:00 <Speuler> never did
13:01:01 <futhin> mrreach: yeah, i suppose we should have stuff for drawing 
13:01:03 <Speuler> almost did
13:01:13 <Speuler> but the scsi stuff kept me busy
13:01:16 <MrReach> I'd *MUCH* rather write my application, and let the hardware take care of itself
13:01:33 <Speuler> writing apps is for application programmers
13:01:47 <MrReach> that is true, and that is what I consider myself
13:01:52 <Speuler> those who use java and basic and the like :)
13:02:05 <MrReach> and Forth, on occassion
13:02:17 <Speuler> let's invent a language, called "noway"
13:02:42 <MrReach> let's not and say we did
13:02:43 <MrReach> or ...
13:02:56 <futhin> mrreach: once we get a decent os (forth os), we won't have to worry about these issues anymore and can therefore get on with coding useful applications
13:03:03 <MrReach> let's extend the nearest available Forth in "noway"
13:03:24 <MrReach> futhin? I code useful applications now
13:03:28 <Speuler> let's shrink it
13:03:37 <Speuler> vocabulary noway    noway seal
13:03:42 <MrReach> heh
13:04:02 <futhin> mrreach: what applications have you coded? how come it's not on the net? where's the source code? :)
13:04:09 <futhin> in forth..
13:04:21 <MrReach> a database of people who steal video tapes
13:04:28 <Speuler> or noway definitions  : bye bye ;
13:04:29 <futhin> heh
13:04:40 <MrReach> with record sharing between sites
13:04:52 <MrReach> will never BE on the net
13:05:21 <futhin> there's not enough forth stuff on the net :(
13:07:13 <futhin> continuing noway definitions  : talk talk-to-the-hand ;
13:07:23 <MrReach> so what have *YOU* put on the net?
13:07:43 <futhin> heh. i'm working on it :)
13:07:50 <futhin> i'm thinking of getting a site at sourceforge
13:07:59 <MrReach> incidently ...
13:08:33 <MrReach> I'm seeing someone making a lot of noise on c.l.f about finally documenting all the words in win32forth
13:08:39 <futhin> hmm
13:08:49 <MrReach> several people look like they're about to join in
13:09:43 <MrReach> I would maintain that it is time to scrap win32forth, and write a cross-platform forth that is a little better organized
13:10:07 <Speuler> gforth is cross-platform ...
13:10:15 <futhin> is it?
13:10:17 <MrReach> yes, it is
13:10:23 <MrReach> VERY cross platform
13:10:30 <MrReach> run on just about anything
13:10:32 <Speuler> and they seem to get the documentation stuff done
13:10:32 <futhin> can i code in sockets in the windows gforth version and simply run my code on linux?
13:10:45 <Speuler> there's even a tutorial in the 0.5 version
13:10:59 <Speuler> futhin: i suppose you can
13:11:00 <MrReach> futhin: well, that's the rub with gforth ... library interface is completely undocumented
13:11:02 <futhin> i440r seems to have some good ideas on a forth 
13:11:22 <Speuler> but i never used the socket stuff in gforth
13:11:35 <MrReach> Speuler: have you compared the documentation of gforth with the documentation of Swiftforth??
13:11:44 <Speuler> should resemble using files
13:12:03 <Speuler> no, i didn't
13:12:12 <MrReach> also, gforth has NO windowing ability whatsoever
13:12:24 <Speuler> (actually, didn't read the gforth docs)
13:12:36 <MrReach> Speuler: Forth, Inc. has outstanding documentation
13:12:51 <Speuler> windowing is for weenies
13:12:59 <Speuler> ahem
13:13:01 <MrReach> I really think they set the bar for doc standards
13:13:02 <Speuler> reading docs too :)
13:13:13 <MrReach> of course, I haven't looked at VFX Forth
13:13:25 <Speuler> don't want to come over as overly provocative of course
13:13:53 <MrReach> damn, you're using IRCII
13:14:00 <Speuler> if i can't use it w/o reading docs, i have to code it myself :)
13:14:04 <futhin> yeah, make forth self-documenting and throw away the docs
13:14:13 <Speuler> what's wrong about ircII ?
13:14:14 <MrReach> If you were using Xchat or such, I could call you a weanie
13:14:47 <Speuler> i love the clarity of text mode
13:15:01 <Speuler> the sober screen design
13:15:01 <MrReach> futhin: wrong ... I want to be able to use someone else's API/Library with an absolute minimum of fuss
13:15:15 <MrReach> heh, and insane key sequences?
13:15:16 <futhin> mrreach: true, i was just yaking :P
13:15:17 <Speuler> gets your attention right where you need it
13:15:21 <futhin> self-documenting
13:15:25 <futhin> was the keyword
13:15:44 <MrReach> yes, I don't mind docs being extracted from soruce files
13:15:59 <MrReach> I just don't want to have to browse source to know how to use it
13:17:22 <futhin> eh.. self-documenting means that the code reads like a document.. means the code doesn't need to be documented
13:17:28 <MrReach> not that I mind reading source, but it distracts from the task at hand
13:17:31 <futhin> i'm not talking about shadow comments, i dislike that
13:17:36 <futhin> s/that/those
13:17:49 <MrReach> no, I was talking about something like auto-doc
13:18:15 <MrReach> where glossary is extracted from source into SGML, then into HTML or nroff or whatever
13:18:29 <MrReach> pdf even
13:19:35 <MrReach> when working on a project that requires sockets, for example, I want to read about the SPI for using sockets, and that ONLY
13:19:43 <MrReach> anything else is a waste of my time
13:19:49 <futhin> forth is capable of being coded in such a manner that it is practically self-documenting
13:20:03 <Speuler> futhin: so they say
13:20:07 <MrReach> self-documenting for the coder, yes
13:20:11 <MrReach> not for the user
13:20:18 <Speuler> futhin: but often, it requires the reader to understand forth
13:20:40 <Speuler> : count   1+ dup 1- c@  ;
13:21:06 <Speuler> : count  dup 1+ swap c@  ;
13:21:24 <MrReach> : count dup c@ swap 1+ ;
13:21:38 <MrReach> ooops, I got the stack backwards
13:21:49 <Speuler> thats   ( addr -- b addr' )
13:21:53 <MrReach> yep
13:22:03 <futhin> chuck moore doesn't like stack comments either
13:22:09 <Speuler> more efficient is  1+ dup 1- c@
13:22:16 <Speuler> less stack activity
13:22:20 <MrReach> : count dup c@ swap 1 chars + ;
13:22:39 <Speuler> how can you code that in a more readable way ?
13:22:50 <MrReach> you're right, fewer words altogether, hadn't thought of that
13:23:34 <MrReach> in any case ...
13:23:51 <Speuler> : chars  ;  immediate
13:23:58 <Speuler> compiles no code
13:24:33 <Speuler> but the compiler must optimize the 1 +  to  inc   ( 1+ )  itself
13:24:36 <MrReach> as someone writing an app ... I ONLY want to see COUNT ( adr -- adr' n ) return adr' the start of the string and n the number of characters in the counted string point to by adr
13:25:11 <MrReach> that's ALL I want to see ... no more
13:25:31 <MrReach> if it doesn't work for some reason, THEN I want to look at the source
13:26:26 <MrReach> funny that the description of the word is 5x the size of the source, and prob 15x the size of the object code
13:26:28 <Speuler> i'm not interested to run it if i can read the source :)
13:26:40 <Speuler> what do i need a computer for anyway ?
13:26:45 <MrReach> beg parden, Speuler??
13:26:58 <Speuler> i don't have a real need for a computer 
13:27:13 <MrReach> except to make your living
13:27:21 <Speuler> xactly
13:27:37 <Speuler> but i guess i could do without computer even for that
13:27:41 <Speuler> well.
13:27:52 <Speuler> i need computer to talk to people who are far away
13:27:53 <MrReach> heh, wouldn't be as much fun    @:^>
13:27:59 <Speuler> true
13:28:28 <Speuler> i want virtual computers
13:28:32 <Speuler> plasma computers
13:28:36 <MrReach> computers are *FUN* ... that is what drives 80% of the ocmputer industry
13:28:40 <futhin> computers are useful for businesses to cut paper costs.. 
13:28:45 <Speuler> ahemk
13:29:08 <Speuler> since computers, use of paper has increased by at least 10*
13:29:16 <MrReach> yes, but we *COULD* do everything that we do for business today on 80386/33s
13:29:20 <Speuler> i don't own a printer
13:29:37 <Speuler> (that's not a cost issue btw)
13:30:02 * MrReach shrugs, "To each his own ... I own three"
13:30:04 <Speuler> but i have a reasonable screen
13:30:33 <futhin> speuler: that is because most businesses and users haven't gone fully digital
13:30:35 <Speuler> btw. i've written windowing routines in forth
13:30:40 <Speuler> some years ago
13:30:45 <Speuler> (text mode windows)
13:30:52 <MrReach> Speuler: large scale or small?
13:30:56 <Speuler> you can display graphics in those text windows too
13:30:59 <MrReach> ok, small scale
13:31:08 <Speuler> pixel graphics !
13:31:09 <futhin> i read "business @ the speed of thought" by bill gates.  it's all about how microsoft has gone fully digital and has saved lots of money.  all the forms are on the intranet, etc
13:31:24 * MrReach nods.
13:31:55 <Speuler> was a project once
13:32:06 <MrReach> Paul Allen has done much research on computers and education
13:32:07 <Speuler> (the graphics, not the windows)
13:32:21 <MrReach> pity his findings aren't more widely published
13:32:32 <Speuler> (windows where to test my memory manager)
13:32:38 <MrReach> heh
13:32:53 <Speuler> i coould visualize proper working :)
13:32:53 <MrReach> Speuler: do you dislike windowing systems like XWin?
13:32:56 <Speuler> no
13:33:10 <Speuler> i dislike the conservative party
13:33:21 <MrReach> heh
13:33:41 <futhin> i dislike X because it activates my bloatphobia
13:34:06 <MrReach> futhin: have you actually written code for either XWin or Winblows?
13:34:24 * Speuler never did
13:34:45 <futhin> no, i've looked at the code and a little bit of my spirit died
13:34:46 <futhin> :P
13:34:59 <MrReach> I wrote some Windows code this week in win32forth
13:34:59 <futhin> a little bit of my spirit died.. boo hooo
13:35:10 <MrReach> next week, I hope to code something similar in gforth
13:35:13 <Speuler> the cpu of my current project has 4 kb of RAM
13:35:15 <MrReach> under XWin
13:35:30 <futhin> 4kb ram, that's the ideal amount.. any more would be excessive
13:35:35 <MrReach> heh, Speuler
13:35:50 <Speuler> yessir ?
13:36:15 <MrReach> just laughing at your restrictions in the context of Windowing OSs
13:36:29 <Speuler> with a former project, i had 80 bytes for the program left :)
13:36:44 <Speuler> (cpu had 192 bytes)
13:36:46 <MrReach> futhin: depends what you need to do ... I couldn't live w/o spreadsheets
13:37:01 <MrReach> I use spreadsheets constantly
13:37:01 <Speuler> most if it used for buffers
13:37:20 <MrReach> good grief ... compiler in ROM?
13:37:25 <Speuler> yes
13:37:26 <futhin> speulers: that sounds cool
13:37:30 <Speuler> fun
13:37:47 <MrReach> very challenging
13:37:59 <Speuler> they told me i couldn't do it
13:38:10 <MrReach> and that raised your hackles?
13:38:28 <Speuler> the ability to upload programs was not part of the specs :)
13:38:42 <Speuler> was a PIC 16x73
13:38:46 * MrReach envisions Speuler growling viciously, "I CAN TOO!"
13:39:09 <Speuler> that's something what indeed can motivate me.
13:39:27 <MrReach> Speuler: two questions for you ...
13:39:31 <Speuler> ga
13:40:15 <MrReach> 1. if there where a cross platform, uniform, windowing Forth, would you use it personally and/or professionally?
13:40:35 <Speuler> i wouldn't knwo
13:40:37 <Speuler> know
13:40:40 <Speuler> depends
13:40:46 <MrReach> forgot the 2nd question, or wrote it into the first
13:40:57 <MrReach> what would it depend on?
13:41:07 <Speuler> whether i'd like the forth
13:41:13 <Speuler> the feel of it
13:41:23 <Speuler> i don't like fpc
13:41:24 <MrReach> erm ... ok
13:41:38 <futhin> fpc seems userfriendly, but i've never really touched it
13:41:46 <MrReach> do you like the "feel" of Win32Forth?
13:42:13 <Speuler> fpc implements the art of writing whole apps from simple words
13:42:14 <futhin> i think they should implement a word called "man" which displays all the core words on the screen..   like in MUF on tinymuck
13:42:19 <MrReach> (yes, I realize that win32forth is an incomprehensible maze, but that is not "feel")
13:42:44 <futhin> i don't really like the feel of win32forth.. it's a bit of a pain to figure out how to do things in it
13:42:57 <futhin> so there's the newbie perspective on it :P
13:43:01 <MrReach> I like the feel ... I hate its organization
13:43:23 <Speuler> pcforth i found quite ok
13:43:28 <MrReach> there is little seperation of windowing functions, for example
13:44:10 <Speuler> i'm also not a huge fan of gforth
13:44:23 <Speuler> but it is reasonable enough
13:44:33 <MrReach> Speuler: what's you're impression of Win32Forth?
13:44:35 <futhin> gforth has very little feel.. it feels like classic forth afaik
13:44:41 <MrReach> gforth is pretty good
13:45:03 <Speuler> winforth turns on my fan
13:45:12 <MrReach> I got *WAY* pissed off when I tried to write a CGI script with gforth, though
13:45:27 <Speuler> i find it too complex
13:45:36 <MrReach> yes, it is too complex
13:45:47 <MrReach> is that a factor in "feel" to you?
13:45:51 <Speuler> it is
13:46:00 <Speuler> lackong transparency
13:46:09 <Speuler> intuitive transparency
13:46:14 <MrReach> or opacity, one way or another
13:46:20 <Speuler> that's what one gets from not reading the docs
13:46:46 <MrReach> heh, what docs? that's the major fault
13:46:52 <futhin> you know what, it is VERY VERY VERY hard for anybody to do things in the simplest manners.   it takes a genius to be simple.   it's hard to be simple while coding, it's hard to create a simple forth  (or they would have done that), etc.
13:47:03 <MrReach> I've ready every bit of documentation, several times, and I'm not much farther ahead
13:47:18 <Speuler> i like to learn about a forth by looking at it with its own tools
13:47:34 <Speuler> or the tools you code for it
13:47:44 <Speuler> i distrust docs
13:47:47 <MrReach> yes
13:47:51 <Speuler> they tend to be wrong
13:48:22 <MrReach> that's why I was saying that if something doesn't work, THEN I want to look at the source code
13:48:29 <Speuler> or at least differ from what they are supposed to document
13:48:43 <MrReach> but not until then
13:48:50 <Speuler> that's why reading the docs is the last resort for me
13:48:57 <MrReach> heh
13:49:16 <Speuler> if i can't get it done other way, then i'll check the docs
13:49:26 <MrReach> in win32forth (and in gforth) ... the source is not very clear
13:49:26 <Speuler> and in the meantime, i learned a lot about the system
13:49:34 <Speuler> probably more than the docs tell me
13:50:40 <MrReach> well, time to call wifey and give her grief
13:50:41 <Speuler> i don't necessarily need the source
13:51:17 <futhin> tell her i said hi :P
13:52:24 <Speuler> what's new ?
13:52:39 <Speuler> in the forth world 
13:52:48 <futhin> no idea
13:53:01 <futhin> go to forth.slashdot.org heh :P   j/k
13:58:31 <futhin> hmm
14:06:30 <MrReach> ???
14:06:57 <MrReach> Speuler: what would make such a forth "feel good" to you?
14:09:17 <MrReach> hello?
14:09:57 <futhin> mrreach: it would feel good to me if 1) the interface was simple, understandable, and userfriendly and intuitive.  2) if it was well-documented  3) if the code was VERY VERY readable.  4) if lots of example code came with the documents.
14:10:25 <futhin> mrreach:  intuitive means something very specific.  it means that i can type help or man and actually get help
14:10:39 <Speuler> ah
14:10:42 <MrReach> that's a pretty good list
14:10:45 <futhin> MUF was pretty cool because you could type man and you got a list of primitives
14:11:06 <futhin> and then you could type man dup   (or some other core word)  and it would give you info on that
14:11:18 <futhin> i think something like that should be available right there in the forth
14:11:19 <MrReach> "intuitive" means that that if you try a command because "it ought to work that way" .... and it's there
14:11:32 <MrReach> futhin: agreed
14:11:42 <MrReach> how about you, Speuler?
14:11:49 <futhin> i would LOVE to be able to type HELP and get help on everything..  all the documentation should be inside forth, part of the forth help system
14:12:09 <Speuler> in elastic i was experimenting with executing words from screen
14:12:15 <MrReach> actually, futhin, I was thinking about how to implement that very thing
14:12:24 <futhin> i don't like win32forth because the help system is a bit confusing and it does lame hyperlinking to dpans and whatever..  
14:12:34 <futhin> all the help should be internal..
14:12:42 <MrReach> not all
14:12:54 <Speuler> execute screen lines, im mean. for help, i could have a word type a few lines (with code), then move the cursor to a line, press enter
14:12:58 <MrReach> a good interface to the help should be internal
14:13:00 <Speuler> that executed that line,
14:13:02 <futhin> don't link to dpans,  include actual help on all the words
14:13:29 <Speuler> i could select "bookmarks", or examples, or open source files
14:13:34 <Speuler> like with a menu system
14:13:40 * MrReach nods
14:13:48 <MrReach> and this would make it "feel good"?
14:13:49 <Speuler> but, the menu system wasn't there at all
14:13:57 <Speuler> it was "intuitive"
14:14:05 <Speuler> at least, i think it was
14:14:24 <Speuler> because you could also extend that system easily
14:14:27 <MrReach> futhin: any reason why "help blah" should not spawn you're web browser positioned to the correct location in the correct file?
14:14:38 <Speuler> the "menu" was a "bookmark" itself
14:14:50 <MrReach> hmmm ... interesting idea
14:15:02 <MrReach> heh, the sort of twisted thing a forth coder would do   @:^>
14:15:12 <Speuler> "bookmark" was an editor, opening a file, jumping to the line where the bookmark was defined.
14:15:15 <futhin> mrreach: it's annoying, and i prefer consistency, and i dislike the dpans format
14:15:17 <Speuler> actually, source locator
14:15:43 <futhin> dpans isn't clear to me when i want to know how to use some word.. it's not very understandable at all :(
14:15:49 <MrReach> futhin: you'd rather that is spewed the text into your current terminal?
14:16:04 <MrReach> futhin: stop berating the format 
14:16:17 <MrReach> and think about how well such a method might or might not work
14:16:36 <MrReach> WHAT is in the web page is up to the author
14:16:38 <futhin> mrreach: yes, i'd rather the text came up on my current terminal
14:16:44 <Speuler> i've put several "help topics" on different function keys
14:16:45 <MrReach> GETTING there is the job of the forth system
14:17:14 <futhin> i liked MUF because it was easy to figure out things, it was easy to get help on.  the help should come up on my current terminal.. webpages are annoying for help
14:17:26 <MrReach> Speuler: is that an indication that those topics are too complex and should be simplified?
14:17:27 <Speuler> how to put an item on a hotkey was in the examples menu too
14:18:01 <Speuler> one key showed the source files. if you moved the cursor to one, it would open it
14:18:18 <Speuler> actually, all it did was listing the source files, pressing the key
14:18:35 <MrReach> futhin: it's relatively easy to spew html to a console terminal, so long as one remembers to limit their markup
14:18:50 <Speuler> (preceded with a character which, when executed, opened the file in the editor
14:18:52 <Speuler> )
14:18:59 * MrReach nods to Speuler
14:19:25 <Speuler> the "howto" section was a bookmark too
14:19:47 <MrReach> this was "elasitc"??? what platform did it run on?
14:20:04 <Speuler> h8/338  h8/30xx  pc
14:20:13 <Speuler> no more ports done
14:20:17 <Speuler> it was a metacompiler
14:20:18 * MrReach spews coffee as he chokes.
14:20:31 <Speuler> but a metacompiler the wrong way around
14:20:37 <MrReach> heh, ok
14:20:55 <Speuler> instead of loading the metacompiler words on a forth system,
14:21:13 <Speuler> you needed the forth words to extend the metacompiler to a forth system
14:21:32 <MrReach> haha! something like ForthCMP?
14:21:32 <Speuler> the kernel metacompiled on its own. no more files needed
14:21:39 <Speuler> (except its sources of course)
14:22:05 <Speuler> forthcmp is a compiler
14:22:10 <MrReach> yes
14:22:23 <MrReach> you have to write the forth system, if you want one
14:22:30 <Speuler> i know cforth. forthcmp was cforth before it became forthcmp
14:22:33 <MrReach> otherwise, you get just your application
14:22:45 <MrReach> that's right, I rmeember you saying that
14:22:52 <Speuler> actually, i know cforth pretty well
14:22:59 <Speuler> worked for years with it
14:23:13 <MrReach> that is somewhat how elastic is?
14:23:13 <Speuler> but no, elastic is different
14:23:19 <MrReach> oh, ok
14:23:32 <Speuler> it is a subset forth, just containing the words for a metacompiler
14:23:43 <MrReach> ok
14:24:06 <Speuler> but by extending it with forth words, you could make a forth from it
14:24:17 <Speuler> it even didn't have a prompt
14:24:22 <MrReach> I think I understand
14:24:25 <Speuler> unless you loaded one
14:24:30 <futhin> mrreach: i think consistency is one of the main things that help userfriendly/intuitiveness.   the interface should stay relatively similar across the forth.   it is distracting and slows down my thinking when i'm interrupted with a new interface that i must adapt to (1 second is an eternity)
14:25:25 <futhin> speuler: elastic sounds cool
14:25:26 <Speuler> elastic was very popular with its users.
14:25:35 <MrReach> futhin: agreed. But which interface are you thinking of when you write that?
14:26:01 <Speuler> the forth extensions weren't quite standard btw
14:26:11 <MrReach> do you mean like "application windows" that have "file" "help" dropdowns, etc?
14:26:31 <Speuler> but you could have chosen to have it compile word complying to the standard of course
14:26:42 <MrReach> Speuler: alastic was before ANS, wasn't it?
14:26:57 <Speuler> yes
14:27:06 <MrReach> wasn't it compat with F83?
14:27:09 <Speuler> no
14:27:17 <MrReach> hmmm ... how odd
14:27:37 <MrReach> futhin?
14:27:50 <Speuler> for example, "expect" had stack effect same as "accept" had in later ANS
14:28:05 <MrReach> ah!
14:28:09 <Speuler> "find" expected string on stack
14:28:19 <Speuler> stuff like that
14:28:22 <MrReach> ALL the characters?
14:28:31 <MrReach> yikes! what a noisance!
14:28:37 <MrReach> nuisance
14:28:40 <Speuler> strings where given as  "string"
14:29:07 <Speuler> i could easily parse input stream to string, and run find on it
14:29:31 <MrReach> yes, though a bit of stack thrashing
14:30:13 <Speuler> whether string is parsed by find, or by another word, calling find, makes no difference on stack
14:30:44 <Speuler> : findword   bl stream find ;
14:31:06 <Speuler> : findword   word find  ;
14:31:09 <futhin> mrreach: i think of different interfaces when i say what i said.  i think of MUF on tinymuck, i think of FPC, i think of how i don't really like win32forth, i think of IDEs
14:31:14 <Speuler> : word   bl stream  ;
14:32:16 <Speuler> same with create.   create only parsed, then called word to create word with name on stack
14:32:23 <MrReach> futhin: what part of each of those do you really like?
14:32:34 <Speuler> semicolon was a deferred word ...
14:32:59 <Speuler> words like   :  and  code:  and the like  set semicolon action
14:33:27 <MrReach> futhin: I, for one, really like the idea of opening independant but integrated tools for working ... like a single-step debugger that runs in a seperate process, or an icon editor
14:33:37 <Speuler> that action set semicolon action to  "unexpected semicolon" error
14:33:53 <Speuler> so i could virtually close everything with  ;
14:33:53 <MrReach> Speuler: good idea, actually
14:34:07 <Speuler> plenty of experiments in elastiv
14:34:08 <Speuler> ic
14:34:18 <Speuler> many of them worked well
14:34:26 <Speuler> lookup:   .....  ;
14:34:30 <Speuler> task:   ....  ;
14:34:47 <MrReach> that's brilliant
14:35:03 <MrReach> maybe I'll implement that with any future object systems that I write
14:35:16 <Speuler> i tried to set unexpected ; action to  \
14:35:22 <Speuler> so i could use it for comments too
14:35:28 <Speuler> that wasn't such a good thing
14:35:35 <MrReach> heh
14:35:39 <Speuler> confusing ...
14:36:04 <Speuler> but  code:  ....  ; was great
14:36:25 <Speuler> code: set ; action to compile  next,  too
14:36:37 * MrReach nods
14:36:56 <MrReach> manual NEXT is a pain, even if it's a macro
14:36:57 <Speuler> code: nop   nop,   ;
14:37:44 <Speuler> i could use ; with non-defining words too
14:37:56 <Speuler> could pair with about everything
14:39:09 <MrReach> one could do ... : test hl forth here INLINE <asm code here> ; hl forth here ;
14:39:22 <Speuler> lookup: name   3 ,  addr1 ,   5 , addr2 ,  ;   3 name  ?dup if execute then
14:39:56 <Speuler> one could, yes
14:40:07 <Speuler> INLINE just needs to redefer ;
14:40:17 <MrReach> I used INLINE .... END-INLINE on my forths
14:40:25 <MrReach> save and defer
14:40:44 <MrReach> because INLINE might be used in something besides colon
14:40:55 <Speuler> my convention was that everything pairing with ; had a : as last char
14:41:07 <MrReach> ok, then ...
14:41:08 <Speuler> INLINE could be an exception
14:41:15 <MrReach> one could do ... : test hl forth here INLINE: <asm code here> ; hl forth here ;
14:41:34 <MrReach> or INLINE>
14:41:58 <Speuler> would need to stack xts then what i didn't do
14:42:12 <MrReach> didn't do?
14:42:24 <Speuler> but ; does not need to know about
14:42:27 <MrReach> oh should have saved, but you didn't?
14:42:47 <Speuler> stacking and restoring could be done by the word re-deferring ; and its deferred action
14:43:36 <Speuler> another advantage was that the defining word - which knows best how to be completed, tells semicolon how to
14:43:48 <Speuler> that keeps related code together
14:43:57 <MrReach> yes ... : INLINE> ;@ >R asm-header also assembler asm-reset [ ; IMMEDIATE
14:44:21 <MrReach> ooops, forgot to defer semi
14:44:48 <Speuler> ' ;inline is ;   
14:44:56 <MrReach> yes ... : INLINE> ;@ >R ['] ;inline is ; asm-header also assembler asm-reset [ ; IMMEDIATE
14:45:11 <Speuler> another "innovation" was:
14:45:15 <Speuler> another header bit
14:45:18 <Speuler> the EXEC bit
14:45:32 <Speuler> w/o, the word would only return its xt
14:45:39 <Speuler> even code and colon words
14:45:46 <Speuler> great for runtime words
14:45:46 <MrReach> hmmmm ... interesting
14:46:08 <Speuler> no more  ['] runtimeword ,
14:46:24 <Speuler> just don't set them executable, and skip the tick
14:46:41 <MrReach> futhin? now is the time to make your voice heard about what a large forth system should or shouldn't be
14:46:45 <Speuler> that was also used for recursive words
14:46:56 <MrReach> oh? how?
14:47:18 <Speuler> RECURSE sets the exec bit
14:47:41 <Speuler> no recurse, and using the word in itself returned its xt
14:47:54 <MrReach> oh, all words were that way??
14:47:56 <Speuler> i.e. redefinitions worked differently
14:48:02 <MrReach> that's VERY odd
14:48:22 <Speuler> : foo   foo . ;
14:48:30 <Speuler> prints its own xt
14:48:34 <MrReach> heh
14:48:59 <Speuler> but, redefs looked like this:
14:49:30 <Speuler> ' foo  : foo  ." new foo"  compile  ;
14:49:37 <Speuler> kind'f weird that
14:49:48 <MrReach> way wierd
14:49:51 <Speuler> ' foo alias oldfoo
14:50:03 <Speuler> : foo ." newfoo" oldfoo  ;
14:50:48 --- join: k (k@d120073.upc-d.chello.nl) joined #forth
14:50:54 <Speuler> hi topaz
14:50:56 <MrReach> greetings, k
14:51:07 <k> hi bl
14:51:07 --- nick: MrReach -> M
14:51:13 --- nick: Speuler -> S
14:51:30 --- nick: S -> Speuler
14:51:31 * M laughs.
14:51:36 --- nick: M -> MrReach
14:51:50 <MrReach> don't forget 'Q'
14:52:01 <Speuler> the james bond one ?
14:52:08 <Speuler> or picard's q ?
14:52:13 <MrReach> actually, I was thinking Star Trek
14:52:32 <MrReach> the obnoxious, omnipotent god-like thing
14:52:56 <Speuler> the arrogant multidimensional guy
14:53:07 <MrReach> heh, yep, that's him
14:53:29 <Speuler> he showed up with jane gateway too
14:53:38 <Speuler> or however her name was
14:53:57 <Speuler> i tried to seduce her once
14:54:04 <Speuler> failed of course
14:54:27 <Speuler> so he actually survived two generations
14:54:38 <MrReach> yes
14:54:49 <MrReach> he'll prob show up in Enterprise, too
14:54:58 <MrReach> the new series
14:55:08 <MrReach> was he ever on DS9?
14:55:09 <Speuler> new series ?
14:55:16 <Speuler> can't remember
14:55:23 <Speuler> haven't seen him in farscape
14:55:43 <Speuler> what new series ??
14:55:57 <MrReach> yes, new series "Enterprise" ... starts with the first launch of a warp-drive ship and proceeds with the acceptance into the Federation
14:56:10 * Speuler 's tv is black/white and about 8 ''
14:56:21 <MrReach> it started about 4 weeks ago
14:56:27 <Speuler> but runs on 12 volts :)
14:56:54 <MrReach> what is "farscape"?
14:57:00 <Speuler> i used a binocular once to watch a program
14:57:06 <Speuler> seriously
14:57:07 <MrReach> HAHA!
14:57:24 <MrReach> audio must not have been important
14:57:26 <Speuler> i tied it to a baseball cap
14:57:33 <Speuler> put that on
14:57:38 <MrReach> oh, on your little one
14:57:49 <Speuler> so the binocular was right in front of my eyes
14:57:56 <Speuler> hands-free :)
14:57:59 <MrReach> heh, wrist-watch TVs
14:58:26 <Speuler> how goes, mr k ?
14:58:35 <MrReach> actually, the new palm-pilots have enough resolution and color to watch TV on
14:58:38 <Speuler> do you have a forth book ?
14:58:56 <Speuler> I'd like a get me an ipaq
14:59:10 <Speuler> pity the screen isn't any bigger
14:59:29 <Speuler> 320x240
14:59:40 <MrReach> not too bad
14:59:48 <MrReach> same as the old C64s
15:00:00 <Speuler> better than cga 4-color
15:00:21 <Speuler> but way off the psion's  640x240
15:00:33 <Speuler> half-vga already
15:00:38 <MrReach> actually, I'd like a comp that straps to my forearm
15:00:42 <MrReach> and flips open
15:01:06 <Speuler> I fancy the foldable keyboard for the ipaq
15:01:10 <MrReach> kinda hard to get in and out of a jacket, though
15:01:39 <Speuler> strap it to your leg
15:01:50 <Speuler> you don't get out of your pants so often
15:01:54 <MrReach> THERE's and idea
15:02:11 <MrReach> and when I do climb out of my pants, I sure don't need a comp handy
15:02:16 <Speuler> run it on body-heat
15:02:58 <MrReach> that would be an engineering challenge, for sure
15:03:51 <Speuler> miniature heat pump, reverse refridgerator. thermoelements won't do
15:03:54 <futhin> heh
15:03:58 <futhin> use chuck's chips
15:03:59 <Speuler> or you would have to produce LOTS of heat
15:04:18 <Speuler> there are miniature gas turbines existing though
15:04:40 <Speuler> and the new methanol fuel cells are promising troo
15:04:42 <MrReach> futhin: if yoiu want to talk about what should or shouldn't be in a forth system ... now is the time
15:04:45 <MrReach> not later
15:04:57 <Speuler> no microsoft logo
15:05:15 <Speuler> no conservative party
15:05:26 <MrReach> hydro fuel cells rock, except for the temps
15:05:40 <Speuler> fuel storage is still an issue
15:05:49 <MrReach> propane is ok
15:06:01 <Speuler> methanol is liquid at room temperature
15:06:06 <MrReach> methane is too, but not as convenient
15:06:07 <Speuler> easy storage
15:06:11 <MrReach> yep
15:06:23 <MrReach> got some sitting on my desk
15:06:24 <Speuler> methane is gas at room temp 
15:06:45 <Speuler> (and sea level pressure)(
15:07:04 <futhin> mrreach: what are you talking about.. are you going to start a forth system?
15:07:10 <MrReach> there is also the issue of "energy density"
15:07:16 <futhin> *start coding a forth system 
15:07:19 <MrReach> futhin: thinking of it
15:07:23 <Speuler> another ? again ?
15:07:37 <MrReach> heh, it's always on my mind
15:07:39 <Speuler> no more standard forth
15:07:58 <MrReach> why's that, Speuler?
15:08:03 <Speuler> some conceptually challenging forth maybe
15:08:19 <Speuler> there are many of those
15:08:32 <Speuler> mr k, i'm actually l
15:08:35 <MrReach> my goals would be cross platform, completeness, uniformity
15:08:45 <Speuler> maybe my nick name confuses you
15:09:04 <Speuler> you are topaz, aren't you ?
15:09:52 <Speuler> i think i forgot to turn of the lights of my bicycle
15:10:07 <Speuler> could need fuel cells for that too
15:11:17 <Speuler> are byte code forths still an attractive option ?
15:11:34 <MrReach> more attractive than they've ever been
15:11:51 <MrReach> more horsepower available for indirections
15:11:54 <Speuler> i was wondering whether i'd try out one of those
15:12:13 <Speuler> after all that java stuff, that's a route to explore
15:12:22 <MrReach> well, actually
15:12:38 <MrReach> most "regular" forths could be called byte-code interpreters
15:12:43 <futhin> bytecode? not direct threaded or what?
15:12:55 <Speuler> once processors are getting to 256 bits, address pointers may not be such a good idea anymore
15:13:06 <MrReach> "bytecode" is the same as "token threaded" forth
15:13:52 <MrReach> a "word" is actually compiled as a token into a lookup table
15:14:22 <MrReach> Speuler: isn't the advatantage of Java its typing system, though?
15:14:53 <Speuler> : count .... ;  and eights of a kilobyte filled with zeroes ...
15:14:58 <MrReach> sorry, futhin, mistyped ...
15:15:12 <MrReach> a "word" is actually compiled as a token which is usually and offset into a lookup table
15:15:38 <Speuler> mrreach: no sure whether i'd call it a advantage, as i had to fight the system frequently
15:15:57 <Speuler> or write workarounds
15:16:05 <MrReach> well, isn't that what set Java apart from TCL or Perl?
15:16:17 <MrReach> (which are both byte compiled nowadays)
15:16:20 <Speuler> that's why java is dying ?
15:16:37 <MrReach> might be
15:17:05 <Speuler> it last stronghold are web applets
15:17:38 <MrReach> yes, those apps that I have on my computer that are written in java REALLY piss me off
15:17:50 <MrReach> ICQ comes to mind immediately
15:18:40 <Speuler> hasn't sun aquired tcl a while ago ?
15:18:40 <MrReach> "I could write that app in 200kbytes with win32forth" ... plus the 400kB runtime
15:18:43 <Speuler> acquired 
15:18:50 <MrReach> Sun invented TCL
15:19:09 <futhin> mrreach: why not stick with direct threaded?  as i understand, direct threaded is the fastest implementation (besides native-code) and is more portable than native-code.
15:19:14 <MrReach> then abandoned it, so it went open source at scriptics
15:19:20 <MrReach> then Ajuba bought scriptics
15:19:40 <MrReach> futhin: I was thinking about doing that
15:20:11 <Speuler> i find itc more elegant
15:20:15 <MrReach> futhin: there are *BIG* advantages to being able to decompile a word
15:20:31 <Speuler> cleaner model
15:20:33 <MrReach> especially when single-stepping
15:20:59 <Speuler> itc = indirect threaded code
15:21:17 <futhin> direct threaded is still 1:1, you can? decompile words in direct threaded model
15:21:27 <MrReach> on some archetectures, itc is faster, on others, dtc is faster
15:21:35 <MrReach> yes, futhin
15:21:39 <Speuler> the concept of putting a pointer in a word, instead of a (cpu dependend) opcode, appeals to me
15:22:58 <futhin> speuler: what architectures is itc faster? and why
15:23:21 <MrReach> you'd have to go look at the benchmarks for gforth
15:23:37 <MrReach> it was Ertl who did the actuall side-by-side comparisons
15:23:45 <Speuler> actually, with the predecessor of elastic, i could compile both stc and itc, and use them intermixed.
15:24:16 <Speuler> so i could choose itc for compactness, and stc for easily connecting to machine code
15:24:27 <MrReach> I think on RISC arch (which now includes the IA64 chips) ... itc was slightly faster
15:25:07 <MrReach> because of the large 1st level data caches
15:25:24 <futhin> stc??
15:25:31 <Speuler> subroutine thread code
15:25:33 <MrReach> stc = subroutine threaded
15:25:50 <Speuler> some people wouldn't call stc forth a forth
15:25:56 <futhin> heh
15:26:00 <MrReach> : test 1 . ;
15:26:30 <MrReach> CODE test CALL literal dw 1 CALL . END-CODE
15:26:43 <MrReach> ooops ...
15:26:51 <MrReach> CODE test CALL literal dw 1 CALL . RET END-CODE
15:27:36 <Speuler> stc is great for interfacing with existing asm routines
15:27:44 <Speuler> no linkage code required
15:28:07 <Speuler> if i'd introduce forth into a system which started out using asm,
15:28:13 <Speuler> i'd opt for stc
15:28:16 <MrReach> also, can run MUCH faster than itc or dtc ... if decent optimizer is employed
15:28:26 <futhin> which of stc, itc, dtc, et cetera would run best on stack architecture like chuck's chips
15:28:38 <MrReach> futhin: doesn't apply
15:28:43 <futhin> ok
15:28:44 <Speuler> forth chips usually use stc
15:29:04 <MrReach> those chips run raw forth, it's kinda hard to describe
15:29:07 <futhin> speuler/mrreach:  which would you pick for a forth os.
15:29:16 <MrReach> huh? which what?
15:29:21 <MrReach> forth chip?
15:29:25 <futhin> no
15:29:28 <futhin> stc, itc, dtc
15:29:40 <Speuler> what cpu is the os supposed to run on ?
15:30:03 <futhin> any
15:30:08 <MrReach> heh
15:30:13 <Speuler> i'd guess itc with native code compilation support
15:30:15 <futhin> the os would be portable
15:30:28 <MrReach> stc is faster on some, slower on others
15:30:33 <Speuler> itc is the most "oo" like
15:30:38 <futhin> speed is important
15:30:51 <Speuler> and native code runs fast
15:31:03 <futhin> speuler: if the os is going to run on different architectures you pick  itc with native code compilation support?
15:31:14 <MrReach> for an OS (who's #1 priority is stability, #2 is effeciency) ... I'd prob go optimized STC
15:31:17 <Speuler> probably
15:31:28 <Speuler> as you can choose to run non-optimized too
15:31:31 <Speuler> but slower
15:31:46 <Speuler> add native code compiler at convenient stage
15:32:02 <futhin> efficiency is speed
15:32:07 <MrReach> yes, an assembler is quite easy to glue on later
15:32:16 <Speuler> often, speed comes from good algorithms
15:32:18 <futhin> how does stability arise from STC?
15:32:26 <MrReach> rethreading the kernel not so easy
15:32:31 <MrReach> it doesn't
15:32:36 <MrReach> effeciency does
15:32:50 <futhin> itc isn't efficient?
15:32:56 <MrReach> not nearly
15:32:59 <Speuler> itc may be more stable:
15:33:09 <MrReach> MAY be
15:33:18 <futhin> from what little i know, stc is slow and cumbersome..
15:33:26 <MrReach> if the optimiser works correctly, neither is more stable
15:33:42 <Speuler> there's less code, and the chance that some memory overwritten by a quirk is lower because the target is not that big
15:33:44 <Speuler> .
15:33:44 <Speuler> .
15:33:45 <Speuler> .
15:33:49 <MrReach> futhin: C produces STC ... and is the fastest, so far
15:33:55 <Speuler> sorry, needed to clean some screen lines
15:34:10 <Speuler> system goes down in 10 minutes
15:34:11 <MrReach> heh, np
15:34:32 <MrReach> ok, coming back?
15:34:43 <MrReach> (just as well, I'd like a shower)
15:34:56 <MrReach> actually, a nice long soak would be just the ticket
15:34:58 <Speuler> still
15:35:17 <Speuler> i tried a "shutdown -c" to see whether my current privs allow me to do so :)
15:35:27 <MrReach> heh, guess they do
15:35:32 <Speuler> (that is  "cancel shutdown :)
15:35:37 <MrReach> oh, -c is cancle?
15:35:43 <MrReach> ok
15:36:09 <MrReach> well optimised STC is lightening fast
15:36:21 <MrReach> far and away faster than any of the threaded forths
15:36:22 <futhin> faster than optimised ITC?
15:36:30 <MrReach> yes
15:36:30 <Speuler> after all, i'm now the system god :)
15:36:54 * MrReach watches Speuler's computer genuflect
15:37:03 <Speuler> must be an automatic procedure i haven't checked out yet.
15:37:06 <MrReach> FAR faster
15:37:09 <Speuler> hehe
15:38:06 <MrReach> for example, in the following code ...
15:38:33 <futhin> wtf..
15:38:38 <futhin> other people said that ITC is the fastest
15:38:41 <futhin> and STC is not
15:38:43 <MrReach> CREATE table 256 allot  : test ( n -- res ) table + @ ;
15:38:54 <futhin> so this is all screwed up.. i'm getting conflicting info
15:39:00 <Speuler> it seems to restart its shutdown
15:39:08 <MrReach> all of test can be optimised to a single machine code instruction
15:39:12 <Speuler> 5 minutes
15:39:37 <Speuler> i've put a job on which cancels shutdown once a second
15:39:40 <MrReach> futhin: I'm talking about OPTIMISED subroutine threaded
15:39:46 <Speuler> lets see whether that sorts any effect
15:40:05 * Speuler just notices he's horribly off-topic
15:40:26 <Speuler> but, just in case, i'll do a preventive goodbye to you
15:40:38 <MrReach> futhin: I once wrote a straight STC forth, and I ran quite a bit slower than DTC on 80386 in 16 bit mode
15:40:44 * k slaps Speuler around with a small 50lb Unix Manual
15:40:59 <MrReach> ah! cool! k lives!
15:41:08 <futhin> compared to OPTIMISED direct threaded..  that's not what other people said.  they said OPTIMISED direct threaded is faster than any other OPTIMISED threaded forths
15:41:13 * Speuler slaps k 20 times on the head with a dead haring
15:41:33 <MrReach> ok, they're wrong ... see my previous example
15:42:05 <Speuler> the unic manual disappears in a cloud of orange smoke
15:42:09 <MrReach> but I suspect we're talking about apples and oranges
15:43:14 <k> oring -c vit
15:43:16 <MrReach> I've seen the output of SwiftForth ... it just doesn't get any tighter ... I couldn't even write code that fast in pure assembler
15:43:50 <futhin> only because you aren't an expert assembly programmer?
15:43:50 <MrReach> because the optimiser in SwiftForth knows more about the processor than I do ... I forget stuff
15:43:56 <Speuler> swiftforth seems to optimize well
15:43:58 <futhin> hmm
15:44:05 <MrReach> even an expert doesn't write perfect code
15:44:05 <Speuler> but cforth / forthcmp isn't so bad too
15:44:16 <Speuler> but it is interpreter versus compiler
15:44:29 <MrReach> the expert will take the longer path to make the code more understandable
15:44:35 * Speuler loves cforth / forthcmp
15:44:46 <MrReach> forthcmp rocked
15:44:51 <Speuler> "hello world" in 70 bytes
15:44:58 <MrReach> never saw programs that ran so fast
15:45:03 <Speuler> print number in arbitrary base in 200 bytes
15:45:10 <Speuler> stand alone code !
15:45:15 <Speuler> (msdos com files)
15:45:23 <MrReach> yep, I remember
15:45:30 <futhin> forthcmp produces hello world in 70 bytes? coooool
15:45:35 <Speuler> i wrote TSRs with it
15:45:39 <Speuler> in less than 1 k
15:45:48 <Speuler> try THAT with C
15:45:49 <futhin> i should look at forthcmp then
15:46:02 <MrReach> it's for MSDOS 3.3 or later
15:46:15 <Speuler> for learning purposes, it is not a good base
15:46:15 <MrReach> not really suitable for todays OSs
15:46:23 <Speuler> more difficult to debug
15:46:28 <Speuler> not interactive
15:46:38 <futhin> heh, so? :P
15:46:39 <Speuler> just source in, executable out
15:46:40 <MrReach> it can compile FPC code
15:46:58 <MrReach> so develop app in FPC, then compile to .COM with forthcmp
15:47:01 <Speuler> supports CP/M and MSDOS
15:47:07 <futhin> that's fine, i don't really use the interactive part .. i tend to code in a editor first
15:47:17 <MrReach> really? didn't know about the CP/M part
15:47:21 <Speuler> has anyone ever heard about CP/M ?
15:47:31 <MrReach> of course, you'd only have to change the primitives library
15:47:41 <MrReach> Speuler: used to run it
15:47:45 <Speuler> pip
15:47:48 <Speuler> hehe
15:47:51 <Speuler> no copy ...
15:48:06 <MrReach> don't remember much about it
15:48:12 <Speuler> systems should turn off very soon now
15:48:27 <MrReach> I was 10th grade when IBM PC introduced
15:48:28 <Speuler> one machine i've shut down manually
15:49:08 <Speuler> just to confuse the people sitting next to it :)
15:49:21 <MrReach> heh
15:49:48 <MrReach> well, I think I'm gonna go soak in the tub for a while
15:49:54 <MrReach> you folks have fun
15:50:01 --- nick: MrReach -> MrGone
15:50:10 <k> speuler tot volgende keer
15:50:18 <Speuler> no it says "machine going down in 15 minutes" again ...
15:50:23 <Speuler> now ..
15:50:39 <Speuler> machine next to me shuts down ...
15:50:55 <Speuler> I'm still running :)
15:51:13 <Speuler>   
15:51:21 <Speuler> 15, 10, 5, 15 ...
15:51:50 <Speuler> i can could claim that the computer is broken, and i have to take it with me :)
15:52:03 <Speuler> k
15:52:09 <Speuler> k ik ben er nog niet weg
15:52:19 <Speuler> de masjien lijkt verder te lopen
15:52:43 <Speuler> hoe was het in de shop ?
15:53:19 <Speuler> half of the machines are down now
15:53:26 <Speuler> the other half still runs ...
15:53:36 <Speuler> what's the time now ?
15:53:37 <Speuler> .
15:53:38 <Speuler> .
15:54:02 <Speuler> shutdown should commence at one o'clock
15:54:24 <Speuler> quarter past ?? is that right ?
15:54:48 <k> sp ik zet ook bij linux.nl (siaa)..
15:55:06 <Speuler> i'll better shut down some of the others before the staff starts to panic
15:56:21 <Speuler> does anyone know how i can shutdown a lot of machines on the network ?
15:56:47 <Speuler> (without logging in to all of them and shutting them down one by one ?)
15:57:10 <Speuler> k: linux.nl sucks
15:57:31 <Speuler> try #linpeople on varley.openprojects.org
15:57:50 <Speuler> they are somewhat more friendly
15:58:20 <Speuler>   
16:00:15 <Speuler> in five minutes it say again
16:00:28 <Speuler> i think it tries to shut them down again and again
16:00:54 <Speuler> (but i have the "cancel shutdown" process still running ...)
16:01:16 <Speuler> do you still hear me ?
16:01:17 <Speuler> .
16:01:17 <Speuler> .
16:01:49 <Speuler> machine next to me, other side, shuts down too
16:01:56 <Speuler> strange
16:02:13 <Speuler> must have a better look at that procedure
16:04:12 <Speuler> lots of beeps around me now
16:04:44 <Speuler>   
16:04:45 <Speuler>   
16:04:56 --- quit: Speuler (Speuler)
16:06:15 --- quit: k (using sirc version 2.211+4KSIRC/1.1)
16:09:13 --- join: Speuler (l@d120073.upc-d.chello.nl) joined #forth
16:09:16 <Speuler> hehe
16:12:42 <Speuler>   
16:12:43 <Speuler> .
16:12:43 <Speuler> .
16:12:44 <Speuler> .
16:13:01 <Speuler> gotto 
16:13:03 <Speuler> go
16:13:06 <Speuler> bye
16:13:10 --- quit: Speuler (Speuler)
17:30:45 --- join: MrReach (mrreach@209.181.43.190) joined #forth
17:41:45 --- quit: MrGone (farmer.openprojects.net niven.openprojects.net)
17:42:29 --- quit: futhin ()
17:58:48 --- join: nate37 (nate@cx83983-d.irvn1.occa.home.com) joined #forth
18:07:27 <MrReach> hiya
19:21:02 <nate37> hi
19:21:25 <MrReach> heh, just standing up to go watch a movie
19:21:34 <MrReach> see you in two hours   @:^>
19:21:39 --- nick: MrReach -> MrGone
19:36:11 --- join: adu (andrew@dsl-64-130-166-225.telocity.com) joined #forth
20:06:21 --- join: I440r (mark4@A010-0088.BLMG.splitrock.net) joined #forth
20:06:26 <I440r> hi ppl
20:07:46 --- quit: MrGone (Ping timeout for MrGone[209.181.43.190])
20:08:35 --- mode: ChanServ set mode: +o adu
20:08:35 --- mode: ChanServ set mode: +o clog
20:08:35 --- mode: ChanServ set mode: +o nate37
20:08:35 --- mode: ChanServ set mode: +o I440r
20:10:12 --- join: edrx (edrx@200.240.18.93) joined #forth
20:10:38 --- mode: I440r set mode: +o edrx
20:10:45 <edrx> hi I440r
20:10:58 <I440r> :)
20:11:01 <I440r> hi dood
20:11:10 <edrx> any news?
20:11:30 <edrx> I've been playing with something that you'd find a Forth heresy
20:11:30 <I440r> not realy
20:11:36 <I440r> hehe
20:11:39 <I440r> whussuat ?
20:12:56 <I440r> ?
20:13:18 <edrx> I wanted a Forth-like language that I could bootstrap with very few lines of code
20:14:16 <I440r> sounds interesting so far
20:15:53 <edrx> and, well, I ended up by doing that in just 80 lines of Lua :))))
20:16:08 <edrx> wanna see a program written in that language?
20:17:11 <edrx> http://angg.twu.net/LUA/yoneda.mflua.html is a demo, http://angg.twu.net/LUA/miniforth.lua.html is the Lua code
20:17:17 <edrx> one minute
20:19:13 --- quit: edrx (Buffer allocation error for edrx[200.240.18.93])
20:19:36 --- join: edrx (edrx@200.240.18.93) joined #forth
20:24:09 <I440r> i looked
20:24:13 <I440r> i dont understand it heh
20:29:40 <edrx> just one minute, I'm talking to a friend that may hire me to give a course... I'll explain it, it's very simple (or at least I hope so :)
20:31:08 <I440r> heh
20:31:12 <I440r> i need a job!!!
20:33:12 --- quit: edrx (farmer.openprojects.net forward.openprojects.net)
20:33:24 --- join: edrx (edrx@200.240.18.93) joined #forth
20:37:13 <I440r> wb :)
20:37:17 <edrx> me too, and mine must be sporadic and pay well... I need money for the first months that I'll spend in montreal
20:37:38 <I440r> i earn 50+ usd per hour when im working
20:37:46 <I440r> i need money to pay mortgage on new house :)
20:38:44 <edrx> 50 usd per hours seems ok
20:38:57 <edrx> unless you got a veeeery big/expensive house
20:39:06 <edrx> but I don't know
20:39:28 <edrx> prices of things are very different in the US and in Brazil
20:40:02 <edrx> hey, lemme try to explain the minimal language...
20:40:05 <edrx> http://angg.twu.net/LUA/yoneda.mflua.html
20:40:22 <edrx> it starts with only one word in the dictionary, "lua-until"
20:41:13 <edrx> and it starts without a bytecode interpreter, without ":", etc
20:41:44 <edrx> the dictionary is just an array that associates to each string a function.
20:42:36 <edrx> and the basic forthish feature of the language is that you can mess up with the pointers that say where we are in the interpretation
20:42:39 <edrx> so
20:42:55 <edrx> the first word of the program, lua-until, is run
20:43:37 <edrx> it runs "getword()" and gets "EOL"; then it runs "getuntildelim("EOL")" and gets everything up to the next EOL
20:43:47 <edrx> and executes that as lua code
20:44:26 <edrx> and that defines a new word in the dictionary: dict["::lua"] = function ...
20:44:43 <edrx> and defines some lua functions that will ve used later
20:45:03 <edrx> after the EOL the first word is exactly the "::lua"
20:45:35 <edrx> when it runs it gets the "%:" using a getword() ("::lua" is like a ":")
20:45:48 <edrx> and then everythign up to the ";;"
20:46:08 <edrx> and after some juggling that defines another word in the dictionary, "%:"
20:46:28 <edrx> that just discards the rest of the line as comments
20:46:47 <edrx> after that we define "pstack" and "p:
20:46:59 <edrx> and then comes a block of "%:", that are comment lines...
20:47:39 <edrx> the we define several other words
20:48:38 <edrx> note that the "p stack"s run p, which parses the next word with getword(), and first prints it literally then prints the resutl of running eval on it...
20:49:07 <edrx> so p "he".."llo" would print first "he".."llo"
20:49:11 <edrx> and then hello
20:49:26 <edrx> or rather "hello"
20:49:43 <edrx> as .. is the concatenation operator of lua
20:49:55 <edrx> well, these are the main features
20:50:52 <edrx> the nicest thing is that it was so chuckmoorishly simple to build the basic system
20:51:13 <edrx> ok, he would never use a high-lvele language for that, but except for that
20:51:26 <edrx> hm?
20:54:18 --- join: futhin (kla@h24-66-209-114.cg.shawcable.net) joined #forth
20:54:30 <futhin> wii
20:54:32 <futhin> woooooo
20:54:41 <futhin> i'm lilakd supper drunk
20:54:45 <futhin> and i'm going to a rave lcub
20:54:46 <futhin> clbu
20:54:48 <futhin> thingie
20:54:49 <futhin> ale34t3gavfsv
20:54:51 <futhin> bye
20:54:53 --- quit: futhin ()
21:08:31 <I440r> sorry im not all here - watching silence of the lambs
21:22:18 --- nick: nate37 -> earth
21:25:28 --- nick: earth -> nate37
21:30:45 --- quit: edrx ([x]chat)
21:49:30 --- quit: adu (Ping timeout for adu[dsl-64-130-166-225.telocity.com])
22:14:57 --- join: MrGone (mrreach@209.181.43.190) joined #forth
22:29:42 --- quit: I440r ()
22:55:01 --- topic: set to '' by ChanServ
22:55:01 --- mode: ChanServ set mode: -o clog
22:55:01 --- mode: ChanServ set mode: -o nate37
23:59:59 --- log: ended forth/01.10.19