07:58:42 --- log: started retro/06.06.25
07:58:42 --- join: clog (n=nef@bespin.org) joined #retro
07:58:42 --- topic: 'RetroForth: You. Forth. The Machine.'
07:58:42 --- topic: set by ChanServ on [Sat Jun 24 21:11:36 2006]
07:58:42 --- names: list (clog neceve arke Snoopy42 @Raystm2 docl crc_ thin [Shain] nighty_ crc Cheery @ChanServ)
08:04:48 <docl> whups, figured it out. forgot to dup before c!
08:04:55 <docl> : input here dup repeat key dup 32 =if 2drop ;then swap 1+ tuck c! again ;
08:08:43 <docl> or (I suspect this could be simplified)
08:08:45 <docl> : input 0 here dup repeat key dup 32 =if 2drop swap ;then swap 1+ tuck c! rot 1+ -rot again ;
08:16:55 <docl> this is more readable:
08:16:56 <docl> : input here 1 repeat key dup 32 =if drop tuck - 1+ swap ;then rot 1+ tuck c! swap 1+ again ;
08:18:26 <docl> : input here 0 repeat key dup 32 =if drop tuck - swap 1+ ;then rot 1+ tuck c! swap 1+ again ;
08:19:46 <docl> cool, I'm at the top of the logs :P
08:59:08 <thin> docl: what are you coding?
09:14:39 <docl> a multi-line parse word
09:15:07 <docl> hiya thin
09:31:18 <docl> also trying to make a chording reader
09:35:27 --- join: snoopy_1711 (i=snoopy_1@dslb-084-058-177-126.pools.arcor-ip.net) joined #retro
09:44:23 <crc> good afternoon
09:53:37 --- quit: Snoopy42 (Read error: 110 (Connection timed out))
09:53:45 --- nick: snoopy_1711 -> Snoopy42
09:59:37 <crc> docl: I did a factored out version, though it is longer
09:59:38 <crc> http://paste.lisp.org/display/21722
10:04:47 <docl> cool!
10:05:32 <crc> if you want, I can do a version of that using the case words to allow more flexibility (I was beginning to work on that already...)
10:07:04 <docl> that would be good
10:08:35 <crc> http://paste.lisp.org/display/21722#1
10:08:52 <crc> in a case approach, break exits the word, with tail call elimination
10:09:31 <crc> there is a tiny bit more overhead with this, but not much. And if you want to track cr/lf, it'll be a lot cleaner than with if/then approach
10:51:15 * crc has added some bugfixes to the netbsd port
11:12:39 <crc> a question: should I change [[ ]] to allow it to be used at the interpreter level?
11:22:22 <crc> pro: doing so would allow for some loops and conditionals to be performed without defining a full word
11:22:47 <crc> con: it would make it significantly more complex
11:28:47 * crc is actually impressed with the ram use of the version of FireFox 1.5 built from pkgsrc. It is using an average of 96mb ram with 20 tabs.
12:07:29 <thin> heh, firefox works a lot better in windows than linux, like two windows of 30 tabs each before i notice a slowdown 
12:07:58 <thin> and this is on my slowass comp 300mhz/256mb ram
12:34:47 <docl> hmm. I'm not entirely clear on how [[ and ]] work yet. but it seems like loops and conditionals from the interpreter would be nifty.
13:49:26 --- join: swalters (n=swalters@dt080n87.tampabay.res.rr.com) joined #retro
14:32:32 --- join: virl (n=virl@chello062178085149.1.12.vie.surfer.at) joined #retro
14:37:52 <Raystm2> Thank you crc! :)
14:38:07 <virl> hi all
14:38:09 <virl> ping
14:38:14 --- quit: nighty_ (Read error: 104 (Connection reset by peer))
14:38:24 <Raystm2> hi virl :)
14:39:05 <Raystm2> are you up late night?
14:40:15 <virl> yeah, in half an hour it's midnight
14:40:30 <Raystm2> Are you working on something?
14:40:41 <virl> no, I'm not
14:41:26 <Raystm2> Me neither.
14:42:44 <virl> something I'd like todo in the future is a workshop about retroforth.
14:43:37 <Raystm2> Great idea, I would gladdly join. There is much i'd like to learn about it.
14:47:04 <virl> it will be a workshop for forth noobs
14:47:47 <Raystm2> A boon for a noob.
14:48:44 <virl> a boon? what's a boon?
14:49:04 <Raystm2> a gain.
14:49:10 <Raystm2> a plus.
14:49:12 <Raystm2> value
14:49:39 <virl> ok.
14:50:16 <virl> so you think after colorforth.info that you are a noob, or how should I interpret that?
14:51:33 <Raystm2> I'm pretty good, I think, at understanding the simplicity of colorforth. Retroforth has more to concider. Vocabularies, Locals, Vectors, Aliased words, it goes on much like that.
14:51:58 <Raystm2> also library bindings...
14:52:14 <Raystm2> I've done such things in c but have yet to really grasp how forth does such things.
14:53:15 <Raystm2> I still have to learn about how to drive devices properly, even in colorforth.
14:53:17 <virl> ah, ok.
14:54:07 <virl> well, and I don't know how to drive them in colorforth or generally.
14:54:29 <Raystm2> I also need to learn how to create and drive a large database.
14:54:34 <docl> vectors, locals, and aliases are really simple
14:54:47 <Raystm2> I realize it has to do with word hiding...
14:55:29 <docl> vectors are a spot at the beginning of a word where you can easily put a jump to a different word.
14:56:12 <virl> and that gets reassigned.
14:56:18 <docl> it's 5 bytes long: 1 for the instruction, 4 for the address of the word you are jumping to.
14:56:32 <virl> docl, was it you who is working on a lisp in retro?
14:56:34 <docl> the address of a word is called the "xt" or execution token
14:56:40 <Raystm2> 1 for the instruction? the instruction name?
14:56:43 <virl> or was tathi?
14:56:52 <virl> oh I forget such things easily.
14:56:54 <docl> I was trying to
14:57:00 <docl> but didn't get very far
14:57:07 <virl> well why?
14:57:18 <docl> Raystm2, the asm instruction for a jump
14:57:28 <Raystm2> 1 for the jump instruction? and 4 for the address to jump to.
14:57:41 <docl> *nod*
14:57:48 <Raystm2> e something i think
14:58:27 <docl> virl, the parsing on retro is a bit too closely integrated to modify easily. I've been working on that lately
14:58:44 <docl> yeah, $e9 I think
14:59:24 <docl> if the vector is empty (the default) it's $9090909090 I think
14:59:36 <Raystm2> yes.
14:59:38 <Raystm2> nop
14:59:44 <Raystm2> x5
14:59:49 <docl> right
15:00:02 <docl> a very simple mechanism, really
15:00:12 <Raystm2> yes.
15:00:30 <Raystm2> could be used to great power i think.
15:00:33 <docl> you could put the vector anywhere in the word, as long as you knew it's exact offset. it's just easiest to do it at the front.
15:00:39 <Raystm2> awesome magic.
15:02:27 <Raystm2> You could litterally have a one word application that was all just previous definitions of the very same word. I think.
15:02:30 <docl> locals are just the same as regular words, but their names are erased from the dictionary right after they are used
15:02:36 <docl> right
15:03:21 <virl> $90 is nop? whoho... I'm getting always problems with those numbers.
15:05:34 <docl> the loc: function saves the address at the end of the dictionary, then ;loc restores it. the names and dictionary data defined between them are overwritten next time you make a word.
15:08:00 <docl> the top of the dictionary (which is a heap just like any other memory area) is pointed to by a variable called "last". this is used by the interpreter, "words" etc. so any words at a higher address aren't going to show up, and will soon get overwritten.
15:08:43 <docl> last @ <- top element of dictionary
15:08:57 <docl> last @ @ <- second to top element of dictionary
15:10:34 <Raystm2> last carries a pointer that is a pointer to the second to last element on the dictionary, or did you mean last + @?
15:11:25 <docl> last is a variable, @ gets it's value
15:11:46 <docl> that will be an address, so you can apply @ to it as well
15:11:53 <docl> it's a linked list
15:13:04 <docl> there's some brief data above the address at "last @", which the accessor words like :name will show
15:13:32 <docl> the pointer is the beginning of the word's dictionary definition
15:15:03 <docl> last @ @ last !  <- makes the dictionary shorter by one word
15:15:41 <docl> the value of last = the beginning of the top word on the dictionary
15:16:02 <docl> also is the pointer to the previous word in the dictionary
15:16:22 <docl> you can exploit this to hide words without really deleting their dictionary data
15:17:08 --- join: nighty_ (i=nighty@sushi.rural-networks.com) joined #retro
15:17:45 <docl> last @ @ @ @ last @ !  <- hides the two words above the top one, by pointing to the fourth word instead of the second
15:18:24 <docl> you could actually change the whole dictionary order around if you wanted to :)
15:20:58 --- quit: Cheery ("Leaving")
15:22:57 <docl> anyhow, removing them from the top is trivial, and frees up memory in the dictionary
15:25:07 <docl> last @ list ! : foo ." blah" ; : bar .s ; list @ last ! <-- makes words, then deletes their dictionary info
15:26:00 <docl> an alias is simply making more dictionary info for the same word, using it's xt.
15:26:24 <docl> ' words <-- leaves the xt of words on the stack
15:26:35 <crc> docl: in your mention of vectors above, the default vector is now $e900000000
15:26:49 <crc> a jump to the next instruction, 0 bytes ahead 
15:27:03 * docl updates his mental database
15:27:27 <crc> I changed it in 9.1 to simplify the workings considerably
15:27:48 <docl> alias foo <-- puts whatever is on top of the stack as the xt address for a new word named foo
15:28:36 <docl> so now if you look up foo in the dictionary, it's :xt value is identical
15:28:54 <docl> ' foo ' words <-- identical values
15:31:45 --- mode: ChanServ set +o crc
15:32:13 <docl> any questions?
15:32:55 * crc would like to mention that using alias is more efficient than doing : foo bar ; to create a word
15:33:14 <crc> ' foo alias bar    ( this takes *no code space* )
15:33:19 <docl> right. the colon-define makes a brand-new xt
15:33:24 <crc> : foo bar ;    ( this takes 5 bytes of code space )
15:34:37 <docl> also in that case: ' foo ' bar <-- different values 
15:34:48 <crc> true
15:36:54 <docl> last @ :xt <-- same as ' foo if foo is the most recently defined word
15:37:38 <docl> no wait, sorry
15:37:53 <docl> last @ :xt @
15:38:53 <docl> Raystm2, how does colorforth handle dictionary data?
15:41:18 <Raystm2> Thanks docl, I will chew this over and over.
15:41:39 <Raystm2> crc: that new vector jump, dang clever sir.
15:42:26 <Raystm2> colorforth has a two part dictionary, macro and forth, and each part is 2 peices, names and addresses.
15:42:56 <Raystm2> the name is the same depth in the names part as the address is in the address part.
15:43:10 <Raystm2> so a find of a word returns the address depth automatically.
15:43:46 <Raystm2> this dual dictionary provides for all of the word 'classes'.
15:43:50 <docl> ahh, ok. so it's not all in a row like in retro
15:43:54 <crc> no
15:44:04 <crc> there are actually 3 parts to the c4th dictionary
15:44:18 <crc> a) a counter storing the number of defined words
15:44:33 <crc> b) an array of names
15:44:38 <crc> c) an array of addresses
15:44:54 <docl> nice simple arrangement
15:45:32 <Raystm2> okay, but that's split between a macros and forth area of each array.
15:45:43 <Raystm2> macros are search first, obviously.
15:46:05 <crc> yes, there is a slit between the dictionaries. Retro used to have this as well, before word classes were added
15:46:57 <docl> c4th's setup seems like it might be easier to visualize (rows 3 columns wide) than retro's
15:47:25 <Raystm2> there is room for adding a limited number of macros and forth words and it sometimes becomes neccesary to rearrange an image to add more .
15:47:29 <crc> retro has more columns
15:47:44 <crc> 128 macros, and 512 forth words in the original
15:47:49 <Raystm2> yes.
15:48:31 <crc> docl: I have experimented with an array based dictionary model in retro, but I haven't been satisfied with the results yet 
15:49:11 <Raystm2> this resource becomes limited with each variable, which has information in each of the macros and forth dictionaries.
15:49:36 <Raystm2> I
15:49:54 <Raystm2> I've read recently  where Chuck is removing the green variable.
15:50:07 <Raystm2> He say's it's not used, but i've used it.
15:50:14 <Raystm2> maybe incorrectly.
15:52:21 <crc> I tend to think that a colorforth could be done with one dictionary, adding a single extra array storing the word class ("color") for the word to use by default
15:52:48 <Raystm2> there seems to be a natural progression when working with colorforth, from using variables until you understand your structure, then moving everything into an array that handles all of your data.
15:54:37 <docl> yeah arrays rock
15:55:27 <crc> my biggest issue with using an array for the dictionary is how to determine the maximum required length for word names
15:56:34 <docl> hmm. you could just cap it at 8 bytes and make people be creative :P
15:57:35 <docl> 4 bytes is often plenty
15:58:11 <crc> I would want more than 8 bytes :)
15:58:25 <crc> My longest names at present run about 12 bytes
15:59:10 <docl> hmm. words like #-of-blocks
15:59:34 <crc> yes
16:00:27 <crc> as I (and others) start exploring higher-level languages like python and lisp in forth, longer names are needed 
16:01:00 <docl> maybe you could have multiple levels somehow
16:01:26 <Raystm2> or a parser delimiter that is automatically added and subtracted from names as necessary.
16:01:38 <docl> the basic forth being limited to 8 bytes, longer names go in a different dictionary
16:01:48 <crc> then you get back into search order issues
16:02:03 <crc> as with ANS vocabularies :(
16:02:27 <docl> ' frabjous alias foo
16:02:59 <docl> whups, too short of an example
16:03:15 <docl> ' frobnicate alias foo
16:03:58 <crc> ' frobnicate (somehow change the active dictionary) alias foo
16:03:58 <docl> hmm. if called as frobnicate it's still going to take longer.
16:04:23 <crc> I moved to word classes primarily to get away from multiple dictionaries
16:05:31 <docl> : bar ~ frobnicate baz ; <-- temporarily changes dictionary to speed up frobnicate
16:06:15 <docl> hmm. once compiled, there's no search order issues anyway.
16:06:43 <crc> you would also be relying on a "lookup" that can handle various name lengths in multiple dictionaries 
16:07:25 <crc> from my pov, it just seems to move complexity to other areas of the system
16:07:59 <Raystm2> I guess in colorforth, the prepacking of words allows for a word name extention flag.
16:08:29 <Raystm2> the only time i see that fail is when typing to the screen all caps.
16:08:56 <Raystm2> the all caps mechanism doesn't recognise the extention and types them lowercase.
16:09:04 <crc> Raystm2: that would still neccesitate find/mfind having more support code to deal with the longer names when an extension flag
16:09:11 <crc> is found
16:09:15 <Raystm2> agreed.
16:09:42 <Raystm2> while the word is unpacking, it doesn't return untill all of the extention is parsed.
16:11:02 <Raystm2> BUT find and mfind dont bother with the extentions in colorforth and your word name differences must come in the first 28 bits.
16:11:30 <Raystm2> a simple rule to follow.
16:12:38 <Raystm2> but you can fit as many as 5 chars in the first 28 bits.
16:12:42 <crc> again though, it's simple enough until it has to deal with an extended name
16:12:53 <crc> where does the rest of the name get placed?
16:12:55 <Raystm2> 3 is plenty, or so says Chuck.
16:13:14 <Raystm2> no mfind and find don't bother with the extention.
16:13:22 <Raystm2> just the first 'word' of a word.
16:13:24 <crc> 3 is plenty for smaller applications. Try interfacing with external libraries and see how quickly that fails to apply :)
16:13:31 <Raystm2> hehe ya
16:13:44 <crc> Raystm2: 3 would view *all* gtk functions as the same
16:13:46 <Raystm2> only pack and unpack deals with word lenght.
16:14:02 <Raystm2> length even.
16:14:04 <Raystm2> ya.
16:15:40 <Raystm2> but your ffi would be different with 3 letter names. I assume a table where each funtion is numbered, then you could have as many functions as you could build out of all of the letters digits and punctuation in 3 place combinations. littereally thousands.
16:16:08 <docl> you'd need sub-words. gtk.win.opn
16:16:21 <Raystm2> ya.
16:16:26 <crc> then you make lookup even more complex
16:18:18 <docl> hmm. if a word is of a certain type, it contains a dictionary
16:18:43 <crc> it still just seems like trying to hide the complexity of a linked list with variable length entries to me
16:21:39 <docl> I would like a sub-word feature like that, in any case.
16:22:08 <crc> I may add that at some point
16:22:14 <crc> but I would layer it through word?
16:22:27 <crc> possibly along with the prefixes I was considering for variables....
16:24:46 <docl> well, I don't think you'd want to see every single sub-word when you type words. maybe words.complete :)
16:25:04 <crc> it'd be paired with the vocabulary model I use
16:25:11 <crc> e.g., asm words ^
16:25:23 <crc> switch to asm, do words, then return to the main dictionary
16:25:48 <crc> asm.LODSD,  access LODSD, from the asm vocabulary (if there is no asm.LODSD, defined in the main dictionary)
16:26:06 <docl> neat
16:26:25 <docl> can asm double as a regular word while also being a vocabulary?
16:26:44 <crc> no
16:26:49 <crc> vocabulary names are words
16:27:06 <crc> in 9.2, I think they will have a special .vocab class
16:27:10 <docl> I bet I could get around that :P
16:28:03 <docl> i.e. make it so they only work as a voc if you use a dot
16:28:52 <docl> hmm. with a .main or .start it would be fine for the oop look anyway.
16:30:15 <docl> with a convention of ending vocs with a dot, it would look oop-ish already
16:51:05 <docl> voc: myobj.
16:51:05 <docl> myobj. : main ." main!" ; ^
16:51:05 <docl> : test myobj. main ^ ;
16:51:37 <crc> that's not a bad idea
16:58:59 --- quit: ChanServ (ACK! SIGSEGV!)
16:59:37 <crc> docl: I'll suggest doing that in the wiki page on vocabs
16:59:46 --- join: ChanServ (ChanServ@services.) joined #retro
16:59:46 --- mode: irc.freenode.net set +o ChanServ
17:02:54 <docl> cool :)
17:05:42 <crc> http://retroforth.net/wiki/?id=Vocabularies
17:05:51 <crc> at the bottom, see the tip :)
17:08:46 <crc> I will likely add the tip-div stuff to the markups in the wiki backend soon
17:11:08 <docl> neat
17:13:00 * crc will be making vocabularies more reliable in 9.2 (e.g., ^ with no open vocabulary will not cause a crash)
17:13:21 <docl> that will be good
17:13:41 <crc> 9.2 will be a very nice release :)
17:14:12 <docl> yeah, lots of stuff coming together :)
17:14:13 * crc can now include the assembler and retrospect to allow more development options
17:16:18 <crc> If I can, I will also redo the GTK bindings completely
17:17:56 <crc> a lot of current stuff will be doable in oneliners if my ideas pan out
17:24:17 <crc> docl: do you have any thoughts on prefixes for variables?
17:24:20 <crc> e.g., 
17:24:23 <crc> @foo  =  foo @
17:24:26 <crc> !foo  =  foo !
17:24:33 <crc> as a shorthand notation?
17:27:18 <docl> hmm, interesting thought.
17:27:46 <Raystm2> crc: you read what I said about that, earlier today?
17:31:13 <docl> you're only saving one space. might be worth it though, if it increases readability.
17:31:37 <docl> kind of warns the reader of the reason the variable is being accessed, as well as telling them it's a variable
17:32:40 --- join: jas2o (n=jas2o@144.138.54.232) joined #retro
17:33:22 <crc> Raystm2: no, can you repeat for me please?
17:36:50 <Raystm2> I said something along the lines that...
17:37:13 <Raystm2> After looking over b18chess again, to rewrite in retro and isforth...
17:37:27 <Raystm2> I found that i used the very convention that you mentioned the other day.
17:37:31 <Raystm2> There were reasons.
17:37:41 <crc> cool
17:37:48 * crc will work on this then
17:37:55 --- part: jas2o left #retro
17:37:55 <crc> I have to run to the store, bbl
17:38:00 <docl> see ya
17:38:05 <Raystm2> when you create a ! or @ you tend to do this locally around the word you are working on.
17:38:09 <Raystm2> okay see ya.
17:38:35 <Raystm2> later as the app grows you find it convenient to collect these words in one area of the app.
17:38:49 <Raystm2> this is necessary to keep from re-inventing things.
17:39:11 <Raystm2> also to redefine memory and arrays as the factoring process develops.
17:39:27 <Raystm2> its easier to find these words if the ! or @ comes first.
17:39:32 <Raystm2> they line up nicely
17:39:47 <docl> that makes sense
17:41:12 <Raystm2> these are words that you might eventually like to combine.
17:41:29 <Raystm2> into an array interface.
17:45:07 <Raystm2> as for b18chess, I think that there might not be that much to do to convert it to retroforth.
17:45:25 <Raystm2> mainly the save-file handling which is set up for gforth and win32forth.
17:46:17 <Raystm2> does retroforth have case, of, endof with a default action?
17:46:25 * Raystm2 checks
17:46:47 <Raystm2> oh and leave.
17:49:23 <docl> hmm. it has a case, but I haven't used it yet
17:51:27 <Raystm2> oh yea and I used ' do ' in the original.
17:51:37 * Raystm2 would like to change this to for/next.
17:52:27 <Raystm2> the code i use for the display/save loop is also way to large of a definition and needs to be better factored.
18:21:37 --- quit: nighty_ (Remote closed the connection)
19:05:22 <crc> back
19:05:33 <crc> <value> switch
19:05:41 <crc> <value> case: ... break
19:05:44 <crc> <value> case: ... break
19:05:48 <crc> default action
19:06:03 <crc> (case) variable  stores the check value
19:06:06 <crc> break exits the word
19:06:18 <crc> you can insert default actions between cases
19:06:20 <crc> <value> case: ... break
19:06:24 <crc> action...
19:06:25 <crc> <value> case: ... break
19:06:28 <crc> action...
19:06:28 <crc> <value> case: ... break
19:06:32 <crc> default action
19:06:37 <crc> this is valid in retro's model
19:25:57 <crc> New markup: ^paragraph^
19:26:08 <crc> this puts paragraph in the black box
19:26:20 <crc> (or whatever the CSS "hint" class is set to
19:29:51 <crc> and now off to bed. goodnight and I should be here tomorrow
20:20:26 <Raystm2> good night.
21:13:32 <docl> : tack >r 2dup + r> swap c! 1+ ;
21:13:32 <docl> : input pad 0 repeat key dup 10 =if drop ;then tack again ;
23:01:15 --- mode: ChanServ set +o arke
23:59:59 --- log: ended retro/06.06.25