00:00:00 --- log: started retro/06.11.04
00:23:49 --- part: forther left #retro
01:11:16 --- join: Cheery (n=Cheery@a81-197-19-23.elisa-laajakaista.fi) joined #retro
01:43:31 --- join: neceve (n=claudiu@unaffiliated/neceve) joined #retro
06:00:04 --- join: erider (n=erider@unaffiliated/erider) joined #retro
07:12:24 --- join: snoopy_1711 (i=snoopy_1@dslb-084-058-145-229.pools.arcor-ip.net) joined #retro
07:20:38 --- quit: Snoopy42 (Read error: 145 (Connection timed out))
07:20:45 --- nick: snoopy_1711 -> Snoopy42
07:58:43 <crc> good morning
07:58:58 <erider> good morning crc
07:59:29 <erider> I'm fighting myself day and night about should I use retro or gforth 
07:59:52 * lukeparrish has been showing erider how to do arrays
08:01:25 <erider> I have forth on my palm and I can port code from gforth relatively easy to Quartus forth on my palm but crc you retro is so interesting that I can't stop playing with it 
08:01:41 <erider> I really like the syscall word 
08:04:17 <virl> you get a warm and fuzzy feeling, right?
08:04:41 <erider> yes 
08:04:57 <erider> virl: how about you 
08:08:42 <virl> about me? well, I would really like to have a free coding webspace for a non-forth project. hmm.. or a one which is cheap and it's hoster is around the corner.
08:26:51 <Cheery> Warm and fuzzy. heh. :)
08:51:33 <crc> virl: what requirements do you have for the webspace?
08:52:24 <virl> not much, only for dumping a darcs repo 
08:53:22 <crc> SDF might work for that... http://sdf.lonestar.org/index.cgi?welcome
08:54:35 <virl> ah, cool :-)
08:54:39 <lukeparrish> yeah sdf (freeshell) is good
08:55:40 <crc> I can also give you some space on the rx-core.org server if you want
08:56:19 <Quartus> hey
08:56:26 <crc> hi Quartus
09:11:25 <lukeparrish> hi crc
09:18:20 <virl> lukeparrish, so you have an account?
09:18:33 <lukeparrish> on sdf? yeah
09:18:54 <lukeparrish> I paid the $12 lifetime subscription
09:19:14 <virl> oh.. well..
09:20:25 <lukeparrish> but you can get a free shell to start. anything that might be useful to spammers is disabled until you pay $1 though.
09:20:39 <virl> I don't know if I could as a sdf user put a darcs repo on it and then getting or putting a patch through an url
09:20:56 <lukeparrish> hmm. not sure their policy on that.
09:21:08 <lukeparrish> you need a darcs repo on the internet?
09:21:12 * crc sends his patches over email, not through a URL
09:22:03 <virl> Probably I need to do that
09:22:53 <lukeparrish> crc: I liked having the glossary.txt file available in retro, for easy reference. is it the same as extensions/help.data?
09:24:25 <crc> I think it's pretty similar
09:24:44 <crc> help.data was built from the glossary in the current handbook
09:26:57 <lukeparrish> erider was wondering about file I/O and I was trying to figure out where to point him at
09:27:17 <crc> file I/O will be changing significantly soon
09:27:30 * crc is working to bring over the file words from RxForth
09:27:38 <Quartus> huzzah!
09:28:17 <lukeparrish> cool. although I liked the old way :)
09:28:37 <crc> that can be rebuilt over the new words easily enough
09:28:39 <Cheery> Oh yeah, I remember I should've sent you that file today crc.
09:28:48 <virl> how comfortable is it for you crc to distribute your patches by email?
09:29:31 <crc> it's not bad. I actually prefer it, since I can accept patches from anyone, review them before applying, etc
09:34:11 <erider> crc: do you know that my current rx doesn't run on my 64bit side of linux 
09:37:23 <crc> rx is a 32-bit app; but it should run if it can find the 32-bit libraries
09:45:13 <Cheery> crc: I sent it a while ago.
09:45:33 <Cheery> Btw. I just realised a funny idea.
09:45:53 <erider> rx runs on the 32bit side that I got 
09:46:38 <Cheery> what if indentation would be done by an expected size of stack? ie. that amount of spaces how much there is stuff in stack.
09:46:52 <Cheery> plus. maybe, traditional indentation. :)
09:47:20 <Cheery> Ie. if you'd have a word... lets say square.
09:48:01 <Cheery> : square ( x -- x^2 )
09:48:01 <Cheery>    dup * ;
09:48:07 <Cheery> you'd indent it this way.
09:48:22 <Cheery> but if you'd have rot (three incoming values.
09:48:54 <Cheery> : rot ( x y z -- z x y )
09:48:54 <Cheery>      -rot -rot ;
09:49:01 <Cheery> you'd indent that this way.
09:49:42 <Cheery> structure indent + expected stack amount
09:50:44 <Quartus> Ambiguious. Can't tell if the indentation is for one, or the other.
09:51:02 <Cheery> I wouldn't say.
09:51:25 <Cheery> there is no negative values in stack-size
09:51:37 <Quartus> Nor in structures.
09:51:58 <Quartus> Perhaps you could differentiate the symbol used.  Of course then you're only a hair away from putting a stack diagram on each line.
09:52:08 <lukeparrish> : rot ( x y z -- y z x )
09:52:08 <lukeparrish> ( x y z ) -rot -rot ;
09:52:18 <Cheery> hehe. :) oh well.
09:52:28 <Quartus> : rot ( x y z -- y z x )
09:52:36 <Quartus>   -rot -rot ( x y z -- y z x ) ;
09:52:40 <Quartus> Kind of redundant. :)
09:53:29 <lukeparrish> hmm. I think the thought here is putting a sign of the available stack on the left side. possibly could have an aesthetic appeal.
09:53:52 <Quartus> My strong preference is for one-line definitions with seven +/- two words/idiomatic-phrases that require no internal documentation.
09:53:58 <Cheery> gah, I remember rot was burying.
09:54:20 <lukeparrish> rot=dig  -rot=bury
09:54:27 <Quartus> No, goes the other way.  It's ( x y z -- y z x ).  -rot is ( x y z -- z x y )
09:54:42 <Cheery> yes, I just tested it with rx.
09:54:46 <lukeparrish> Cheery: same number of letters
09:54:52 <lukeparrish> er chars
09:54:57 <lukeparrish> since - isn't a letter
09:55:16 <Cheery> hmm.
09:55:37 <Cheery> I guess I go and rename them dig and bury.
09:55:44 <lukeparrish> ' rot alias dig
09:55:49 <Quartus> Generally you'll see : -rot  rot rot ;  as rot is the more commonly-found primitive.
09:55:49 <Cheery> They've fucked up enough.
09:55:50 <lukeparrish> ' -rot alias bury
09:56:20 <lukeparrish> Cheery: well that's what I did, then I got tired of it and went back to the normal way. but now I remember :)
09:56:32 <Cheery> why did you get tired of it?
09:57:05 <lukeparrish> hmm. reading others' code it was always still rot/-rot.
09:57:15 <Cheery> hm.
09:58:10 <Quartus> That's the thing. Spend the couple of minutes to associate the common name with the expected behaviour, and you can read other people's code, and they can read yours.
09:58:53 <lukeparrish> yeah. mneumonics are cool though.
09:59:08 <lukeparrish> the painlessness of learning they can grant is really nice.
09:59:09 <crc> Cheery: I got the vm.py, thanks
09:59:20 * crc forwarded on something he's working on as well
09:59:26 <Quartus> bury and dig are not without ambiguity themselves.
09:59:55 <Cheery> Hey crc, thanks!
09:59:56 <lukeparrish> true. but they're good enough for differentiation in my mind.
10:00:06 <Cheery> I look into it. :)
10:00:21 <lukeparrish> e.g. dig could go as deeply as you want it to. I'd use that instead of pick (or was it roll that does that?
10:00:24 <lukeparrish> )
10:00:33 <crc> some of the stuff I sent may be of use in your work, though it's written in C
10:00:39 <lukeparrish> yeah it's roll. pick makes a copy
10:00:49 <Cheery> crc: well, timlarson has written his stuff in C as well.
10:00:57 <Cheery> I think he'll find it very useful.
10:01:05 <crc> good
10:01:54 <Quartus> lukeparrish, you shouldn't be using PICK or ROLL, no matter what names you assign them.
10:02:08 <lukeparrish> true
10:02:31 <Cheery> pick or roll?
10:02:33 <lukeparrish> but it's good to know what the heck they are.
10:02:42 <lukeparrish> pick is roll with a copy.
10:02:45 <lukeparrish> er dup
10:03:39 <lukeparrish> : pick dup >r roll dup r> swap >r -roll r> ; I think would do it
10:03:57 <Quartus> gah. I've never seen -roll anywhere.
10:04:06 <lukeparrish> well I can make that too :/
10:04:20 <Quartus> Pick is usually implemented as a direct memory read from stack memory, though there's also a simple recursive definition for both it and roll.
10:04:23 <lukeparrish> or I think I can
10:04:34 <lukeparrish> it would be like I picture as "bury"
10:05:01 <Quartus> From the rf ANS layer:
10:05:01 <Quartus> : pick  1+ cells sp@ + @ ;
10:05:01 <Quartus> : roll  ?dup if swap >r 1 - recurse r> swap then ;
10:05:55 <lukeparrish> cool
10:06:21 <lukeparrish> recurse is the same as "roll" would be in that context?
10:06:46 <Quartus> I don't follow.
10:06:55 <lukeparrish> sorry
10:07:17 <lukeparrish> does recurse go to the beginning of the function it's called in?
10:07:20 <Quartus> oh, you mean self-referentially?  Yes, recurse recurses into the current definition.
10:07:23 <Cheery> crc: basically it seems like a replica from rxforth, but made entirely in C?
10:07:55 <Quartus> Standard definitions aren't findable until the definition is complete.
10:08:07 <lukeparrish> ah, I see.
10:08:40 <lukeparrish> I *think* retro's are.
10:08:52 <Quartus> They are.  One benefit of using RECURSE is that it allows nameless recursive words.
10:08:58 <lukeparrish> : loop foo bar baz loop ;
10:09:18 <lukeparrish> nice
10:09:41 <lukeparrish> :: foo bar baz recurse ; I'd imagine
10:09:48 <lukeparrish> sweet
10:10:06 <lukeparrish> of course you'd want an if; in there somewhere I'm sure
10:10:37 <Quartus> seems likely :)
10:10:40 <lukeparrish> :)
10:11:08 <Quartus> Hey! So saying, I've discovered a bug in the rf-ans layer, in that recurse doesn't work properly in nameless words, as it's supposed to.  I'll fix that.
10:11:33 <lukeparrish> endless loops are only so entertaining. although... I have a program with an endless loop that I use to display subliminal messages.
10:12:15 <lukeparrish> has select-syscall'd delays
10:12:56 <lukeparrish> I wonder how to get keypresses during those. I should look into that.
10:14:19 <timlarson> crc...
10:14:26 <timlarson> we are working on a syntax like this:
10:14:51 <timlarson> ['this is a string [-and this is a nested comment in the string] that is pretty short]
10:15:00 <timlarson> [=this is some code]
10:15:09 <timlarson> [\this escapes to the parser]
10:15:12 <timlarson> etc.
10:15:33 <timlarson> your toka/bootstrap code reminds us of this :)
10:16:43 <Cheery> the [ controls parser state, which affects how parser behaves. later letter tells how parser state changes.
10:18:22 <timlarson> ['this is a [=['string]$]] outstr
10:18:28 <timlarson> this would output: this is a string
10:19:08 <lukeparrish> wait, what's $] do? or is that a typo?
10:19:08 <Cheery> in our syntax, ( ) works very similar way to your [ ] quotes. But we are considering compiling all the time.
10:19:10 <timlarson> the $ appends the string indicated by the pointer on top of the stack to the string currently being built.
10:20:17 <timlarson> lukeparrish, you can think of $ like an outstr that writes (appends) to a string instead of writing to stdout.
10:20:31 <lukeparrish> kinda like . in php?
10:20:43 <timlarson> yeah, kinda
10:21:30 <lukeparrish> [=...] is for putting code within a string, and ['..]$ is the code that appends a string.
10:21:39 <lukeparrish> this could work out to be a cool web page maker.
10:21:52 <timlarson> that's the idea :)
10:22:20 <timlarson> that was the motivation for coming up with this syntax
10:22:22 <lukeparrish> fairly simple to pick up, not whitespace dependant.
10:22:51 <timlarson> and for generating code in itself and in other languages
10:23:08 <lukeparrish> I'd imagine code not already in ['...] is counted as [=...] by default?
10:23:13 <timlarson> yes
10:23:31 <lukeparrish> ok. so not as demanding of parens as regular lisp
10:24:25 <erider> hi timlarson
10:24:29 <timlarson> right, and I plan to have list handling, probably via [,item1,item2,item3...]
10:24:33 <timlarson> hi erider 
10:24:35 * lukeparrish notes that with some creative manipulation of the >in pointer, parse could do some pretty powerful stuff along these lines.
10:27:32 <erider> timlarson: what you plan today 
10:28:17 <timlarson> getting the quad query language far enough along to support function "naming" and extending the base set of words.
10:32:16 <crc> Cheery: I keep the interpreter around because I like it
10:32:42 <crc> at this point I could switch to a compile/run cycle, but see no real reason to
10:32:50 <Cheery> Why do you like it?
10:33:30 <crc> for quick and dirty tests, it's handy
10:34:07 <crc> when I implemented this, I started with just an interpreter, debugged most of the initial words, then built the compiler
10:34:07 <erider> very true thats what C lacks
10:34:46 <crc> I could drop the interpret mode, but I see it as being useful in the future, when I explore other approaches to compilation 
10:35:57 <Cheery> you mean interactive mode?
10:36:21 <crc> no
10:36:31 <crc> I won't eliminate interactivity in the environment
10:37:12 <Cheery> oh. Now I'm totally lost. :) I thought you meant that.
10:37:13 --- join: nighty_ (n=nighty@sushi.rural-networks.com) joined #retro
10:37:27 <Cheery> or wait, you said "I won't"
10:37:55 <lukeparrish> hmm. interpret vs. interactive. I guess you could do without interpreting, just making words and executing one at a time.
10:38:02 <Cheery> The thing is about having different modes for interpretting and compiling.
10:38:10 <crc> lukeparrish: freeforth does that
10:38:13 <lukeparrish> i.e. don't do anything until it's all been factored into one word
10:38:16 <lukeparrish> cool
10:38:30 <lukeparrish> actually that might be a better idea
10:38:42 <lukeparrish> it removes some of the ambiguity from the language.
10:38:45 <crc> lukeparrish: http://christophe.lavarenne.free.fr/ff/
10:38:47 <Cheery> Do we need to have those different modes?
10:38:58 <crc> Cheery: it depends
10:39:08 <crc> you may not want to compile everything
10:39:27 <Cheery> having that state variable requires that you implement classes two different ways, first state off and then state on.
10:40:00 <crc> though not having it means that you still have to decide how to defer/allow actions
10:40:11 <crc> e.g., a word that inlines something else
10:40:25 <Cheery> hmm.
10:40:34 <Cheery> yep. I guess so.
10:40:54 <crc> you really just shift things around
10:42:04 <crc> in Toka, I'm haven't had to think too much about this. For named words, there are essentially two classes: .quote and .macro (not directly visible)
10:42:11 <crc> and .data
10:42:13 <crc> so three
10:42:23 <crc> (others exist, but are only used by the primitives)
10:43:05 <crc> .macro is used for words that should only be run during compilation; those that inline other things. All other words are .quote
10:43:14 <crc> data structures are .data
10:43:35 <Cheery> yes, I noticed that.
10:44:01 <Cheery> Assuming I've understood the existing thing about word classes.
10:44:29 <crc> I have plans to fold almost everything, including primitives, down to those three classes
10:45:49 <Cheery> ... .quote checks if compiling state is happening, if it does, it puts that call into certain place, if not, it invokes it.
10:46:26 <Cheery> .. .data checks same, except it puts the value into certain place and if not, it leaves it into stack.
10:46:41 <crc> yup
10:46:56 <crc> .macro invokes the quote if compiling, ignores it otherwise
10:47:04 <Cheery> yep.
10:47:35 <Cheery> if you'd make it compile all the time, these would change next way:
10:47:46 <Cheery> .quote would always compile call into certain place.
10:47:56 <Cheery> .data would always put the value as literal into certain place.
10:48:02 <Cheery> and macro would always invoke.
10:48:11 <Cheery> ie.
10:48:51 <crc> however the end result (from the programmer's perspective) is the same
10:48:55 <Cheery> ' compile is .quote
10:48:55 <Cheery> ' literal, is .data
10:48:55 <Cheery> ' execute is .macro
10:49:08 <Cheery> yes, of course.
10:49:57 <Cheery> but there's a difference, word classes doesn't need conditions, therefore complexity lies on the level user changes more rare.
10:50:28 --- quit: virl (Remote closed the connection)
10:50:49 <crc> the interpreter itself though would have to keep track of it's heap then, and also references to it
10:51:28 <crc> (in my interpret/compile model, the interpreter has no heap)
10:52:06 <Cheery> It seems there is no allot anymore.
10:52:09 <Cheery> in toka.
10:52:16 <Cheery> but there is heap -variable.
10:54:33 <Cheery> I were thinking of chance that it'd copy the compiling results elsewhere from heap.
10:54:56 <crc> there is no single heap in toka
10:55:16 <Cheery> where does it compile?
10:55:17 <crc> all memory (for quotes, variables, etc) are dynamically allocated
10:55:32 <crc> each quote has it's own heap
10:55:44 <Cheery> cool!
10:56:15 <crc> this will eventually allow for at least basic garbage collection to take place if/when I decide I need it
10:58:08 <Cheery> I guess I should read that toka code through and test different choices myself.
10:58:26 <Cheery> I guess then I would understand the best why there is need for that tiny funny variable. :) 
10:58:48 <crc> temporary quotes (not nested/named) will eventually be purged automatically to keep memory use to a reasonable level
10:59:21 <crc> named words that are not used could be purged as well
11:11:42 <Quartus_> how will you know that a defined word won't, at some later point, be called?
11:12:00 <crc> I don't
11:12:26 <crc> at present I am not planning to purge named words or allocated data, just temporary quotes
11:12:59 <Quartus_> in quartus forth I only abandon unused words when generating a stand-alone app, as words either appear in the call tree, or they don't.
11:15:50 <Quartus_> I suppose you could have a word that discarded everything not in a given call-tree -- to be called explicitly by the programmer.
11:16:19 <Quartus_> like --  ' foo keep-only
11:17:58 <crc> that would be a good idea
11:18:43 <Quartus_> could be general garbage-collection, but manual rather than automatic.
11:20:44 <lukeparrish> seems like if you keep code stored in a text buffer as it is written, you can simply clear the heap and re-compile it. but since it's compiled already keeping it as such is something of a time saver.
11:21:02 * lukeparrish may be confusing IDE with compiler issues
11:21:55 <Quartus_> I think you are.
11:22:25 <lukeparrish> hmm. why do we need GC if we have a good IDE?
11:22:39 <crc> lukeparrish: gc != ide
11:23:14 <crc> e.g., my experiment has no single heap; each new quote/word is dynamically allocated
11:23:35 <lukeparrish> if you quit and restart, that's a (admittedly very crude) form of GC...
11:23:35 <crc> quotes that are made and used once can be discarded after use
11:23:35 <crc> that's what gc is for
11:24:02 <crc> true to a point
11:24:43 <crc> if your app creates a bunch of quotes that it uses briefly while building the full program, then you still have that garbage after a restart
11:24:57 <Quartus_> throwing the computer out and buying a new one is a form of GC, arguably a bit crude.
11:25:04 <lukeparrish> :)
11:25:44 * crc will add a simple, manual gc soon (which will require quotes to be explicitly marked as temporary)
11:27:02 * erider vanishes 
11:27:19 <crc> other things are higher priority right now though
11:31:57 <Quartus_> I just pasted this in #forth: http://www.cs.utexas.edu/users/EWD/transcriptions/EWD00xx/EWD28.html
11:32:05 <Quartus_> it's from 1962.
11:34:34 <Quartus_> it's Dijkstra describing a two-stack postfix programming language that's closer to Forth is now than Moore's early versions were.
11:36:06 <timlarson> hehe, just like some forths: "In particular, the question of storage allocation will remain untouched."
11:36:57 <Quartus_> Forth dealt with storage allocation from the early NRAO versions.
11:40:27 --- quit: nighty_ ("Disappears in a puff of smoke")
12:27:21 --- join: forther (n=forther@c-67-180-209-27.hsd1.ca.comcast.net) joined #retro
13:20:02 --- quit: Snoopy42 (Read error: 145 (Connection timed out))
13:27:50 --- quit: neceve (No route to host)
13:59:54 --- join: nighty_ (n=nighty@sushi.rural-networks.com) joined #retro
14:02:18 --- quit: lukeparrish (Read error: 110 (Connection timed out))
14:10:05 --- join: lukeparrish (n=docl@74-36-211-202.dr01.hmdl.id.frontiernet.net) joined #retro
14:10:05 --- mode: ChanServ set +o lukeparrish
14:31:35 <lukeparrish> Cheery: I read your post about suffixes on the rxforth group.
14:32:27 <lukeparrish> I agree 100% that 1000b looks better than %1000, but the trouble is that b is a hex numeral.
14:33:06 <lukeparrish> so hex 11b is not the same as 11b when in decimal mode
14:38:54 <lukeparrish> and don't get me started on 2b or !2b :P
14:53:38 * erider reappears 
14:53:46 <lukeparrish> yay
14:58:33 --- join: virl (n=virl@chello062178085149.1.12.vie.surfer.at) joined #retro
14:59:13 <lukeparrish> hi virl 
14:59:27 <virl> hi lukeparrish 
15:00:00 * crc has basic gc working now
15:00:32 <lukeparrish> cool!
15:02:03 <crc> you have to explicitly mark quotes/data for gc; gc is called when the garbage collection list is filled or if you manually invoke it via 'gc'
15:14:52 <Raystm2> Neat!
15:28:26 <Cheery> lukeparrish: :)
15:28:27 <Cheery> :D
15:28:34 <Cheery> I didn't realised that.
15:28:46 <Cheery> But I think it'd look so much better really.
15:29:14 <lukeparrish> yeah
15:32:42 <lukeparrish> hmm. you could make modes that you enter and the syntax rules change.
15:32:53 <lukeparrish> suffix: ... ;suffix
15:33:32 <lukeparrish> then when that mode is going, you can't switch out of the decimal base, and the suffixes work
15:33:49 <Cheery> Or a different language.
15:33:52 <Cheery> Whatever. :)
15:33:57 <lukeparrish> true :)
15:34:15 <lukeparrish> basically it permits a rewrite of the language without losing the old one.
15:34:22 <Cheery> The beauty in forth is that it is sustainable for this kind of usage; change of syntax and using those things together.
15:34:59 <Cheery> ie. crc:s work is totally from opposite direction than some done in keow. But still hitting same thing in parallel.
15:35:53 <lukeparrish> well, computers inherently let you do that, and forth lets you close enough to the computer to do so.
15:36:28 <Cheery> yeh, I've been thinking the reason being in some that kind of thing...
15:36:29 <Cheery> I'm going to sleep.
15:36:49 <lukeparrish> ok
15:36:52 <lukeparrish> l8tr
15:37:01 --- quit: Cheery ("Download Gaim: http://gaim.sourceforge.net/")
18:05:57 --- quit: virl ("Verlassend")
19:06:16 --- quit: Quartus_ ("used jmIrc")
19:10:36 --- join: Quartus_ (n=Quartus_@209.167.5.2) joined #retro
19:43:24 --- quit: Quartus_ (Read error: 104 (Connection reset by peer))
19:49:40 --- quit: erider ("I don't sleep because sleep is the cousin of death!")
22:52:06 --- quit: forther (Read error: 104 (Connection reset by peer))
23:03:15 --- join: forther (n=forther@c-67-180-209-27.hsd1.ca.comcast.net) joined #retro
23:46:33 --- quit: forther (Read error: 110 (Connection timed out))
23:59:59 --- log: ended retro/06.11.04