00:00:00 --- log: started forth/05.10.12
00:02:45 --- quit: JasonWoof ("off to bed")
01:13:37 --- quit: Raystm2 (Read error: 104 (Connection reset by peer))
01:16:06 --- join: Raystm2 (n=Raystm2@adsl-69-149-55-17.dsl.rcsntx.swbell.net) joined #forth
02:49:21 --- quit: Snoopy42 (zelazny.freenode.net irc.freenode.net)
02:50:02 --- join: snoopy_17 (i=snoopy_1@dslb-084-058-154-247.pools.arcor-ip.net) joined #forth
02:50:02 --- join: Snoopy42 (i=snoopy_1@84.58.154.247) joined #forth
02:53:15 --- quit: Snoopy42 (Read error: 145 (Connection timed out))
02:53:24 --- nick: snoopy_17 -> Snoopy42
04:07:23 --- quit: OrngeTide (Read error: 110 (Connection timed out))
04:40:35 --- join: segher (n=segher@blueice2n1.de.ibm.com) joined #forth
05:01:29 --- join: aardvarx (n=folajimi@shell2.sea5.speakeasy.net) joined #forth
05:02:31 <Robert> Hi.
05:05:05 <aardvarx> Howdy.
05:10:21 <Quartus> Hi aardvarx.
05:11:23 <aardvarx> Morning, Quartus.
05:34:36 --- quit: aardvarx ("XFCE panel borking up... will restart X to ameliorate the issue...")
05:45:05 --- join: aardvarx (n=folajimi@shell2.sea5.speakeasy.net) joined #forth
05:56:53 <aardvarx> Quartus, did you get any of my messages?
05:56:59 <Quartus> Just a ping.
05:57:13 <aardvarx> Ah. Okay.
05:57:15 <Quartus> I've been out of the office for a day or so.
05:57:32 <Quartus> What's up?
05:57:56 <aardvarx> I was just poring over the code you gave me...
05:58:18 <aardvarx> I guess I need to understand how arrays work in Forth before I can proceed.
05:59:06 <Quartus> They work the same way they do in C -- you allocate a bit of memory, point to the start of it, and then calculate offsets into it.
05:59:19 <aardvarx> However, I noticed that the code only shows a 2-symbol list; is that correct?
05:59:39 <Quartus> The example  is       2 generate-greek-sequences    as I recall, isn't it?
05:59:56 * aardvarx checks...
06:00:44 <aardvarx> 2 generate-all-greek-sequences
06:01:13 <Quartus> Ok. So change that to 3, or 6, or whatever you want.
06:01:16 <Quartus> Or 1.
06:01:28 <aardvarx> Whoa.
06:02:33 * aardvarx flabbergasted...
06:03:05 --- join: PoppaVic (n=pete@0-1pool74-225.nas24.chicago4.il.us.da.qwest.net) joined #forth
06:03:22 <PoppaVic> G'day
06:05:27 <aardvarx> Quartus, you're not too crazy about "Starting Forth", right?
06:06:18 <PoppaVic> It's very old, and targets a major for-pay compiler, AND is not the best way to learn.
06:06:27 <Quartus> It's unfortunately bound to an outdated model of Forth.
06:08:07 <aardvarx> Is there any resource you can recommend for learning about arrays with FOrth?
06:08:18 <Quartus> Well, there's this channel right here.  What part is confusing you?
06:09:50 <aardvarx> Is 'allot' a "word" in Forth?
06:09:56 <Quartus> Yes, a Standard word.
06:09:58 <PoppaVic> yes
06:10:13 <aardvarx> How is it used for array declaration?
06:10:25 <aardvarx> I've heard of malloc in C...
06:10:36 <aardvarx> is it comparable to the malloc function?
06:10:38 <Quartus> Well, the way you state that question suggests that you think arrays are some kind of built-in data type.  They aren't, as such.
06:10:57 <Quartus> ALLOT is somewhat comparable to malloc, but it works within an already-allocated buffer of data space that Forth provides.
06:11:06 <PoppaVic> malloc is less like allot than alloca is
06:11:37 <aardvarx> Quartus, yeah I remember you or someone else had mentioned that you get to make your own rules in Forth.
06:11:37 <Quartus> For the purpose of my 'array' word, ALLOT is the word that sets aside the space for the array, yes.
06:12:43 <aardvarx> Sounds like handing a toddler a plugged-in table saw.
06:12:50 <Quartus> What does?
06:13:40 <aardvarx> Build your own data type.
06:13:59 <Quartus> It's not a data type.  It's just a particular way of accessing a range of memory.
06:14:08 <aardvarx> Oh.
06:14:55 <PoppaVic> Think of the idea as multiple-times more powerful than a 'typedef' and closer to a 'class'
06:15:15 <Quartus> It's not so different in C.  The a[] notation is syntactic sugar for the same offset calculation that's contained in the DOES> part of the 'array' word.
06:15:35 <aardvarx> Perhaps the best thing for me to do at this point is to just go line-by-line...
06:16:06 <Quartus> aardvarx, I'd recommend you go word-by-word.  Figure out what each word does, and then see how they fit together; then, later, delve into the mysterious internals of each word.
06:16:55 <aardvarx> No variable declarations?
06:17:09 <Quartus> I don't believe I had to use any variables in that piece of code, no.  There's a constant declaration.
06:17:23 <aardvarx> It looks like you just went in spraying...
06:17:27 <aardvarx> ** ( n1 n2 -- n1**n2 )
06:17:33 <Quartus> Though the word 'declaration' isn't quite right, for Forth.  You're not declaring it; you're creating it.
06:17:36 <Quartus> spraying?
06:18:38 <aardvarx> No declaration == no introduction.
06:18:41 <Quartus> ** is the name I chose for a word that raises one integer to the power of another.  You may know it under another name, but that's the one I'm familiar with from other languages.
06:19:04 <Quartus> What do you mean by 'no declaration'?
06:19:49 <PoppaVic> "prototype"?
06:19:55 <aardvarx> In C one might declare an index before using it.
06:20:11 <aardvarx> Here, no introduction is needed.
06:20:19 <Quartus> Oh. Ok. I thought you meant you felt something was missing.
06:20:39 <Quartus> That code is as well-factored as I can manage, and I believe it to be largely self-explanatory, but I didn't put a lot of effort into comments and explanation.
06:21:24 <aardvarx> It looks almost like English :P
06:21:34 <Quartus> Are you being sarcastic?
06:21:45 <aardvarx> \ Place a1 n1 as counted string at a2:
06:21:51 <Quartus> That's a comment.
06:22:02 <aardvarx> Wow.
06:22:10 <aardvarx> I thought comments began with #
06:22:11 <Quartus> \ denotes a comment line.
06:22:17 <Quartus> Not in Forth.
06:22:24 <aardvarx> For sure.
06:22:29 <Quartus> For sure.
06:22:51 <Quartus> ( comment )  is another form of Forth comment.
06:23:07 <aardvarx> Very nice!
06:23:29 <PoppaVic> you can define new forms ofcomment, too
06:23:37 <aardvarx> How about the ? symbol?
06:23:41 <Quartus> For instance, : ** ( n1 n2 -- n1**n2 )   begins defining a word named **.  By convention, there's a ( ) comment right after it that shows what arguments it takes on the stack, and what it leaves behind.
06:23:44 <Ray_work> Morning, men!
06:23:58 <Quartus> aardvarx, the ? in what context?
06:24:01 <aardvarx> Morning, Ray_work.
06:24:10 <aardvarx>  ?dup if  over swap 1 ?do  over *  loop  nip  else  drop 1  then ;
06:24:46 <Quartus> ?dup is a word.
06:24:49 <Quartus> so is ?do.
06:24:57 <PoppaVic> hi ray
06:25:02 <Quartus> Forth words can begin with or contain symbols.
06:25:10 <Quartus> Hi Ray_work
06:25:22 * Ray_work running late but glad to be here :)
06:26:18 <Quartus> aardvarx, I can see you're going line-by-line. Let me again recommend word-by-word.  There's only a dozen-odd words in that source, understanding what they do at a high-level will give you an overall understanding of the program much faster than going line-by-line.
06:26:32 <segher> a name in forth can contain any character, except whitespace
06:26:59 <Quartus> For instance, ** takes two numbers on the stack, and raises the second-most to the power of the top-most.
06:27:40 <Quartus> place and place,  are commonly-found Forth words that I've defined here for clarity.  Gforth already has 'place' itself.
06:28:44 <aardvarx> How about a Forth-dictionary? Is one available online?
06:29:07 <segher> aardvarx: google for "dpans"
06:29:09 <Quartus> The Standard is available online, as a hard-core kind of reference -- http://quartus.net/dpans
06:29:23 <Quartus> It'll tell you what words are Standard and what aren't, but it isn't a teaching text.
06:29:24 <segher> what quartus says :-)
06:29:53 --- join: tathi (n=josh@pdpc/supporter/bronze/tathi) joined #forth
06:29:55 <aardvarx> Thanks, Quartus.
06:30:15 <Quartus> 'array' is another commonly-found word.  It defines a new word that points to an array of cells.  The new word also automatically calculates item indexes.
06:30:53 <Quartus> Can you guess what  24 constant #greek  does?
06:32:49 <aardvarx> It has all the symbols?
06:33:15 <tathi> try again :)
06:34:02 <Quartus> No, the next line,   #greek array greek     creates up the array that points to the symbol names. 
06:34:12 <Quartus> 24 constant #greek       does something much simpler than that.
06:34:40 <aardvarx> Isn't that more like a declaration?
06:35:25 <Quartus> Kind of.  But Forth doesn't have declarations.  It has definitions.
06:36:15 <Quartus> 24 constant #greek       doesn't 'declare' #greek as a constant with the value 24.  It defines it.  It creates a new word (function) which places 24 on the stack when it is used.
06:36:24 <PoppaVic> The closest (afaik) that Forth comes to a "decl" is a defer'red word
06:36:34 <aardvarx> These "definitions" expire once the program completes though, right?
06:36:39 <Quartus> aardvarx, yes.
06:36:42 <Quartus> They don't hang around.
06:36:55 <Quartus> Once you exit Gforth it returns to its original configuration.
06:38:33 * aardvarx suspects that Quartus is belaboring the point because this is more than just semantics... more like a paradigm shift.
06:39:02 <Quartus> aardvarx, yes.  Every word in Forth has an action associated with it; none of them are just declarations.
06:39:23 <aardvarx> action???
06:39:26 <aardvarx> O_o
06:39:34 <Quartus> a Forth variable is actually a small function that returns its own address that points to an alloted section of memory private to it.
06:39:39 <aardvarx> Isn't greek a variable?
06:39:53 <Quartus> A Forth constant is actually a small function that places a specified value on the stack when it is run.
06:39:55 <PoppaVic> stack sources/sinks, modifiers, etc
06:40:04 <Quartus> greek is an array, aardvarx.
06:40:27 <Quartus> Greek is a small function that calculates offsets into its alloted region of memory.
06:40:57 <aardvarx> Wow.
06:41:26 <aardvarx> An *array* that is also a *function* ???
06:41:28 <Quartus> You can think of it in object-oriented terms, if that helps.  Every word has a method.
06:41:44 <aardvarx> Quartus, sounds better.
06:42:07 <PoppaVic> and, words can create new words with method-extension/variants
06:42:10 <Quartus> aardvarx, the way I conceptualize it, the array is actually the region of memory with the values stored in it.  The word 'greek' is the specific entry point for the method associated with the array.
06:42:34 <Quartus> The object-oriented ideas don't help me conceptualize any of this, but if you're coming from there, they may help you.
06:43:19 <aardvarx> I have done very little in the way of OOP, but I have read quite a bit on the subject matter...
06:43:22 <Quartus> 'array' is what is called a 'defining word' in Forth.  It creates a new word, or function, if you will, with a default method that is specified in the DOES> part of 'array'.
06:43:37 <aardvarx> I see.
06:43:59 <Quartus> #greek array greek      defines a new word named 'greek', allocates 24 (the value of #greek) cells for it, and assigns it a default method that auto-calculates item addresses.
06:45:25 <aardvarx> Isn't #greek something like a #define statement?
06:45:40 <PoppaVic> '#' has a twisted implication
06:45:58 <Quartus> No.  Forth words can contain symbols.  '#greek' is just shorthand for "number of".  It's as valid a Forth word as foo, or aardvarx, or whatever you like.
06:46:10 <aardvarx> I see.
06:46:45 <Quartus> Because the value 24 cropped up several times in the code, I created a constant named (effectively) "number-of-greek', with the value of 24.
06:46:58 <aardvarx> That's why ?dup and ?do are valid Forth words as well?
06:47:01 <Quartus> Right.
06:47:11 <Quartus> Good programming practice is to name your constants, if they're used in more than one place.
06:47:19 <aardvarx> Agreed.
06:48:12 <Quartus> There is very little syntax in Forth.  A word's name can contain any symbol except a space.
06:48:27 <aardvarx> Lethal.
06:48:44 <Quartus> .-++~@aardvarx!76 is valid Forth word (not a good one, but a valid one).
06:48:55 <aardvarx> Lethal.
06:49:01 <Quartus> Flexible.
06:49:03 <tathi> No, flexible.
06:49:07 <aardvarx> Heh.
06:49:07 <tathi> :)
06:49:26 <PoppaVic> also, 1, 2, 3, 4, 8, and -1 - can all be 'words'
06:49:28 <Quartus> You can go up to 31 characters in a name, more in some systems.
06:49:46 <aardvarx> Looks to me like a language that is rather limited in what it will NOT let you do!
06:49:54 <aardvarx> :P
06:49:58 <Quartus> Yes,  42 constant 3    is perfectly valid Forth.  Thereafter in the program, 3 will have the value of 42, which is seldom useful but may illustrate the point. :)
06:50:23 <aardvarx> O_O
06:50:35 <aardvarx> Say it ain't so!
06:50:39 <Quartus> It's so.
06:50:58 <PoppaVic> It's a bit irksome, but apparently it takes more time to create a number then it does to lookup and run a word/const
06:51:17 * aardvarx nods head in disbelief...
06:51:18 <Quartus> It's not good practice to redefine numbers to be different values, obviously, and I've never actually seen it done, but it could be.
06:51:28 <Quartus> 42 constant 3       3 . -> 42
06:51:48 <tathi> aardvarx: just because it CAN be used badly doesn't mean it's a bad thing.
06:51:49 <aardvarx> Incredible... Well, let's keep it moving, shall we?
06:51:56 <PoppaVic> oh, maybe on an ebcdic box or sumpin'
06:52:06 <tathi> just that you have to be careful with how you use it.
06:52:24 <Quartus> I think we were down to '#greek array greek'.
06:52:39 <PoppaVic> Also, bear in mind: creating your own wordlists or vocs is not remotely a "bad thing"
06:52:48 <Quartus> The next three words are, if you like, additional methods for operating on the array, specific to our purpose of storing Greek symbol names.
06:53:32 <Quartus> greek-symbol  parses a name, stores the name in the next highest location in dataspace as a counted string, and then places the address of that counted string in the greek array.
06:53:52 <aardvarx> Even though greek-symbol was never defined?
06:54:05 <Quartus> greek-symbol is defined right there, under #greek array greek
06:54:15 <Quartus> : greek-symbol ( n "name" -- )  here swap greek !  bl word count place, ;
06:54:58 <aardvarx> I'm trying to reconcile _swap_ with ( x1 x2 -- x2 x1 )
06:55:13 <Quartus> What do you mean?
06:55:42 <aardvarx> According to http://quartus.net/dpans/dpans6.htm#6.1.2260, they are one and the same.
06:55:50 <Quartus> Again, I strongly recommend you first look at the code in terms of what each definition does, as a black-box.
06:55:55 <PoppaVic> who "they"?
06:56:17 <aardvarx> _swap_ and ( x1 x2 -- x2 x1 )
06:56:28 <PoppaVic> the latter is just a stack-comment
06:56:32 <Quartus> You're mis-reading the Standard.  SWAP is a Standard word.  ( x1 x2 -- x2 x1 ) is a comment, an informal notation that indicates what it does.  SWAP swaps the location of the first two stack items, so if it's   1 2 going in, it's 2 1 coming out.
06:56:49 <aardvarx> Please excuse me.
06:57:04 <aardvarx> I have to be at a meeting soon.
06:57:10 <Quartus> They're called 'stack diagrams', and you can leave them out completely without affecting how the program runs.  They're documentation.  They have the format of (  before -- after  ).
06:57:15 <PoppaVic> Properly, "D( x1 x2 -- x2 x1)" reads better
06:57:36 <Quartus> Not to me.
07:14:44 --- join: sproingie (i=foobar@64-121-2-59.c3-0.sfrn-ubr8.sfrn.ca.cable.rcn.com) joined #forth
07:15:56 <PoppaVic> Hi sproingie 
07:18:49 <sproingie> mornin
07:19:01 <PoppaVic> What's shakin', sproingie ?
07:30:41 <sproingie> nada, just reading intel manuals
07:31:29 <PoppaVic> I'm closing in on my core goal. *sigh* Painful. Any ideas about wtf a "string" really means and if we could use a stack?
07:32:16 <PoppaVic> I keep thinking a "string" is no more than a concept/struct/array that should nearly be opaque
07:32:53 <sproingie> string is an ordered and bounded collection of chars
07:33:08 <PoppaVic> "chars" itself is flexible
07:33:09 <sproingie> how that's implemented is of course up to you
07:33:13 <PoppaVic> right
07:33:22 <sproingie> it's possible to have no char type and only have strings of length 1
07:33:46 <sproingie> still has to retain that ordered property
07:33:51 <PoppaVic> Sounds to me like we may benefit from an opaque-type/handle
07:34:22 <sproingie> strings arent opaque though, not if they're useful
07:34:35 <sproingie> you can index a string 
07:34:45 <PoppaVic> methods/handlers are invaluable, yeah
07:35:24 <sproingie> char isn't really opaque either
07:35:37 <PoppaVic> sproingie: as soon as you diddle with unicode or utf8, it becomes beneficial to consider the handle/opaque - and indexing becomes a pain - or a method.
07:35:49 <sproingie> you want some way of translating chars to and from ordinals, such as codepoints
07:36:12 <PoppaVic> right. I'm beginning to think of 'byte' and buffer or array - and associated handlers/vtables
07:36:21 <sproingie> indexing in utf8 is O(n), that's why utf8 sucks as an internal type
07:36:47 <sproingie> if you deal mostly with streams like plan9 does, utf8 makes more sense
07:36:54 <sproingie> (utf8 was invented for plan9)
07:37:43 <PoppaVic> yah, it looks to me a lot like a "string" of (whatever) is nearly as bad as using a LL as an [array]
07:37:50 <sproingie> i wouldnt think bytes, though it can't hurt to be able to translate strings to and from raw bytes
07:38:10 <sproingie> which admittedly isn't "pure" but it's useful
07:38:16 <PoppaVic> well, I'm thinking of space, and THEN type/class/whatever
07:39:16 <sproingie> strings just have some abstract properties.  think of which ones you want to support, then the implementation will write itself
07:41:00 <sproingie> utf16 is usually used as an internal datatype.  tho i can't figure out how that's indexed either, since technically it's variable width too
07:41:05 <sproingie> what with surrogate pairs
07:41:41 <sproingie> it's possible surrogates and combining marks are actually considered distinct chars
07:41:46 <PoppaVic> I'm pretty well sure that using asciiz is about as high as the dict/interp should run, and maybe letting folks extend that to utf8/unicode for i/o - but not the dict.
07:42:10 <PoppaVic> yeah, gcc uses wchar_t (which is 32bit)
07:42:34 <sproingie> which suggests that they're not distinct
07:42:38 <sproingie> i only know about utf8
07:43:00 <sproingie> and not even that much about unicode.  stuff like normalization is foreign to me
07:43:22 <PoppaVic> Me too. I've avoided it for nearly 30 years
07:43:39 <sproingie> i think if you're going to support unicode, you may as well support unicode identifiers
07:43:41 <PoppaVic> ..and, from the look of it all: it's not going to clear up anytime son
07:43:50 <PoppaVic> soon
07:43:54 <sproingie> let people write words in chinese if they want
07:43:59 <PoppaVic> right
07:44:22 <PoppaVic> However, you then end up with dictionaries and souce that will never, ever port
07:44:34 <PoppaVic> source
07:44:37 <sproingie> sure it'll port, that's what unicode is for
07:44:53 <PoppaVic> no: the SOURCE would need to be unicode
07:44:55 <sproingie> 'course no one but a chinese speaker will be able to understand it
07:44:59 <PoppaVic> right
07:45:10 <sproingie> but that's the programmer's prerogative
07:45:15 <PoppaVic> yep
07:45:25 * sproingie has some examples of gauche scheme that are in japanese
07:45:33 <PoppaVic> eww
07:45:39 <sproingie> since the developer of gauche is japanese
07:46:03 <PoppaVic> glyphs and runes strike me as quite painful - for console-i/o
07:46:15 <sproingie> it's actually not even unicode, it's euc
07:46:43 <sproingie> tho it looks like he's converting to unicode
07:47:23 <sproingie> interestingly, that's what plan9 cals chars.  Runes
07:47:26 <PoppaVic> hmm.. OK, let's switch subjects.. How do const and "literals" differ, below the interface?
07:47:50 <sproingie> in forth terms?  never quite understood it myself
07:47:59 <PoppaVic> Seems to me that a 'lit' is the same as a 'const' - just lower, embedded
07:48:04 <sproingie> const is a variable, a pointer to a value, whereas a literal is just a value itself
07:48:43 <PoppaVic> ahh, but not really: you'd have to embed a code/interp plus the value for the 'literal'
07:48:43 <sproingie> i guess not really a variable, it's a word that returns a value 
07:48:48 <PoppaVic> right
07:49:16 <sproingie> literal's like an unnamed const
07:49:32 <PoppaVic> so, except for the interactive/human-interface: they are const - right, it's unnamed, just "inline"
07:49:47 <PoppaVic> interesting.
07:50:21 <sproingie> in the interpreter there should be no difference between "123" and "literal 123" 
07:51:21 <PoppaVic> ahh "compile-only" flag on 'literal', ala' Gforth
07:51:38 <sproingie> in the compiler, it's the difference between emitting instructions to push 123, and just spitting a 123 into the output stream (which better map to an instruction or be somewhere where you're putting data)
07:52:06 <PoppaVic> right-right
07:52:08 <sproingie> i could be totally wrong here, but i think that's the difference
07:52:16 <PoppaVic> Interesting.
07:53:28 <sproingie> literal's a compile-only word in gforth
07:53:37 <PoppaVic> right, said that
07:53:53 <PoppaVic> it's making life... Interesting
07:54:01 <sproingie> i think some forths make it state-smart
07:54:03 <sproingie> rf does
07:54:28 <PoppaVic> I've been hard-awork trying to write my pseudo-asm opcodes for a stack-machine, as tathi suggested.
07:58:11 <sproingie> basic stack juggling ops like push pop swap, integer ops ... really the core words of forth pretty much *are* those opcodes
07:58:47 <PoppaVic> yep, although I've surpassed that. Right now, I'm considering "strings" and "handles"
07:58:58 <sproingie> ah, operations on datatypes
07:59:16 <PoppaVic> yeah, to do any IO we need to have some sort of interface
07:59:19 <sproingie> you planning on doing manifest types?  that would be a departure from traditional forth
07:59:29 <PoppaVic> "manifest"?
07:59:36 <PoppaVic> core-types?
07:59:37 <sproingie> where data carries a type field with it
07:59:54 <PoppaVic> ahh, the 'ra' (relative address) will, yes
08:00:22 <sproingie> possible to support both, actually.  have polymorphic instructions that dispatch to the proper "micro-ops" if you will
08:00:59 <PoppaVic> I'm trying to mentally reconcile byte, short, cell,  - and combos - with "keep this shit relocatable and bigendian.
08:01:00 <sproingie> so to add the top two items of the stack, you call ADD, which unboxes the types, figures out their types, and if they're both ints, say, then it calls ADD.INT
08:01:11 <sproingie> if they're both floats, it calls ADD.FLOAT
08:01:11 <PoppaVic> ahh
08:01:13 <sproingie> etc
08:01:31 <PoppaVic> yer about 1 step beyond me for the time being, although I'ddiscussed this a few weeks ago
08:01:49 <sproingie> that way if you get fancy and add static typing later on, you can emit unboxed types and typed instructions 
08:02:00 <sproingie> and never change the VM
08:02:02 <PoppaVic> http://rafb.net/paste/results/1wh0Sc93.html
08:02:27 <PoppaVic> the current file is just the OPCODES/payload - not a "real pseudo-assembler"
08:06:04 <sproingie> what's the EMBED column show?
08:06:18 <PoppaVic> bytes embedded following opcode
08:06:54 <PoppaVic> data/payload/attrib - whatever
08:07:12 <sproingie> ah, immediate operands for most ops?
08:07:18 <sproingie> kind of VLIW-ish
08:07:43 <PoppaVic> this is all "immediate", in that these would be operators for the pseudo-asm
08:08:21 <PoppaVic> So, these are what the "cpu" would step-thru (above any true asm/cpu)
08:11:53 --- quit: madwork (Read error: 104 (Connection reset by peer))
08:19:29 <sproingie> argh, i'm in chapter 4, "Data Types"  in the intel manual
08:19:36 <PoppaVic> heh
08:19:39 <sproingie> i need a "IEEE Floating Point For Dummies" book
08:19:44 <PoppaVic> It ain't pretty
08:20:05 <sproingie> i think i'll just gloss over the gory details of floating point
08:20:11 <PoppaVic> I wish I'd been able to cart/store/save all my cpu manuals
08:20:28 <PoppaVic> Yeah, since you can't rely on IEEE
08:20:29 <sproingie> most of 'em you can just download for free
08:21:09 * sproingie actually has a AMD64, but intel's manuals are more detailed
08:21:10 --- join: madwork (n=foo@derby.metrics.com) joined #forth
08:21:15 <PoppaVic> oh, man: I had thick trees on Intel and Zilog and Motorola in the Long Ago
08:30:06 <PoppaVic> hmm.. sproingie: you've prolly got more experience than I - Is embedding an ASCIIZ string in asm typical? Or, does the code use a ptr to an area with constants?
08:32:08 --- part: segher left #forth
08:55:03 <PoppaVic> humph-humph
08:55:13 <PoppaVic> Patterns, pretty-patterns..
08:59:59 --- nick: Raystm2 -> nanstm
09:29:42 --- quit: PoppaVic ("Pulls the pin...")
10:11:00 --- join: virl (n=hmpf@chello062178085149.1.12.vie.surfer.at) joined #forth
11:05:16 --- join: aum (n=aum@60-234-156-82.bitstream.orcon.net.nz) joined #forth
11:36:08 --- quit: aum ()
13:00:48 --- quit: aardvarx ("Time's up...")
14:35:36 --- join: crc (i=crc@pool-70-110-167-115.phil.east.verizon.net) joined #forth
14:36:12 <Robert> Hi, crc.
14:36:46 <crc> hi Robert
15:02:31 --- join: JasonWoof (n=jason@pdpc/supporter/student/Herkamire) joined #forth
15:02:31 --- mode: ChanServ set +o JasonWoof
15:44:11 <JasonWoof> anybody know spanish?
15:44:32 <JasonWoof> there's a word that means "very small" which is something like "pokito"
15:44:50 <JasonWoof> I'd like to know the spelling
15:44:53 <JasonWoof> and confirm the meaning
15:50:09 --- nick: nanstm -> Raystm2
15:51:39 <Raystm2> hi
15:51:41 <Robert> Hi.
15:51:51 <Robert> (and sorry, JasonWoof... I know no Spanish)
15:52:08 <Raystm2> paquito
15:52:16 <Raystm2> sorry
15:52:19 <Raystm2> piquito
15:53:36 <Robert> You speak Spanish well, Ray? :)
15:56:03 <JasonWoof> thanks
15:59:19 * Raystm2 works with Hispanics, daily, buy no, I wouldn't call myself fluent.
16:00:48 <Raystm2> Robert: hehe I barely speak English. :)
16:02:14 * Robert should learn Spanish one day
16:02:21 <Robert> A lot of people speak it...
16:02:31 <Robert> Not so much here as in the americas though.
16:02:50 <Raystm2> True. I, as well, need very much to learn.
16:02:59 <Raystm2> I got a cd...
16:03:11 <Raystm2> 9 langs on it.
16:09:22 * Robert has IRC. Almost all languages going on here. :)
16:09:27 <Robert> And the Wikipedia.
16:40:08 --- join: snoopy_17 (i=snoopy_1@dslb-084-058-151-233.pools.arcor-ip.net) joined #forth
16:43:21 --- join: nizchka (n=Nizchka@e184173.upc-e.chello.nl) joined #forth
16:44:05 <Robert> Hi.
16:45:03 <nizchka> leave
16:45:19 --- part: nizchka left #forth
16:46:10 <Robert> Heh.
16:47:33 --- quit: Snoopy42 (Nick collision from services.)
16:47:39 --- nick: snoopy_17 -> Snoopy42
16:47:39 --- nick: Snoopy42 -> snoopy42
16:58:35 <Quartus> Hey all.
17:00:02 <Robert> Hi, Quartus.
18:19:13 <Raystm2> hi Quartus :)
18:19:20 <Quartus> What's up?
18:19:34 <Raystm2> I'm up. 
18:19:57 --- nick: Raystm2 -> R-tab
18:21:27 <R-tab> hehe /me just thought of that nick typing your Quartus and thinking that when I greet you, I always say "hi Q-tab" rhyming with "IQ-tab"
18:21:49 <Quartus> Heh.
18:21:52 <R-tab> Wish I had an IQ-tab. :)
18:22:52 <R-tab> Will you be my IQ-tab?
18:22:53 <R-tab> :)
18:23:15 <Quartus> Best offer I had all day, sadly. :)
18:23:19 <R-tab> ahahahah
18:23:47 <R-tab> Well then, let me pick your brain?
18:24:46 <R-tab> How much forth does it take to say you've suddenly crossed the line from nothing but machine, and then you code that last return and you suddenly have forth?
18:25:28 <Robert> That's deep
18:25:29 <R-tab> The nipple end of the cone of forth possibility. 
18:26:24 <Quartus> How much Forth?  Depends on how you define "Forth".  I consider it an interactive incremental compiler with a dictionary, memory, stack, and multi-precision arithmetic operators.
18:27:20 <Quartus> There's an arguable number of words that are required before you're at launch -- you need to be able to create new definitions in the dictionary, for instance.
18:27:21 <R-tab> but it takes a finite number of words coded to provide all that, so what's that, another layer of abstraction, or is it forth, the words to build all that you mentioned.
18:28:13 <Quartus> There's the Forth that exists with an empty dictionary -- it's a couple of stacks, an empty dictionary, a region of memory, and an interpreter.
18:28:24 <R-tab> okay. 
18:28:43 <R-tab> that is the event horizon?
18:28:54 <Quartus> There's a minimal set of words (you can argue about which ones, but it's not a huge number) that allow you to access those facilities more-or-less completely.
18:29:20 <Quartus> Some subset of CORE. Call it 30 words, give or take a fair margin.
18:29:29 <R-tab> Acceptable.
18:29:33 <R-tab> :)
18:29:35 <Robert> Hmm...
18:29:51 <Robert> I should see how many words I used in my minimal compiler.
18:29:54 <Quartus> That's where you've got Forth, as far as I'm concerned.
18:30:36 <Robert> 34
18:30:39 <R-tab> the bones of 4th
18:30:54 <Robert> That's the compiler + what's needed to support it.
18:31:14 <R-tab> 34 well defined, well chosen words.
18:31:27 <Quartus> Give or take.
18:31:31 <R-tab> And a forth chip, it's built to do that mechanically?
18:31:38 <Quartus> Right.
18:31:56 <R-tab> only extensible in software.
18:31:57 <tathi> well, a chip wouldn't have the dictionary stuff, presumably.
18:32:08 <Quartus> Right, it'd have the pre-dictionary VM.
18:32:32 <R-tab> so the forth rides on top of a VM that allows you to extend the bones?
18:32:47 <R-tab> you could add a bone?
18:32:52 <Quartus> That's the nature of what is usually called a "Forth chip", sure.
18:32:55 <R-tab> if there was a bone
18:33:08 --- quit: tathi ("leaving")
21:25:39 --- quit: sproingie (Connection timed out)
21:53:16 --- quit: virl (Remote closed the connection)
23:59:59 --- log: ended forth/05.10.12