00:00:00 --- log: started forth/06.08.02
01:08:14 <Quartus> segher__, here's a version using return-stack manipulations, akin to your code.  Runs under Gforth.  Let me know what you think.  http://pastebin.ca/111269
01:14:35 <segher__> create is a bit clumsy
01:14:42 <segher__> looks okay otherwise
01:14:49 <Quartus> Can you make it less clumsy?
01:15:05 <segher__> not that much, it's al gforth's fault ;-)
01:15:16 <segher__> what is that backpatch line for though?
01:15:18 <Quartus> I'd be interested in any improvements you can suggest.
01:15:53 <Quartus> CREATE words have to leave a dataspace pointer on the stack.  Gforth has shared code and dataspace.  I could pre-calculate the offset but this way is more flexible for any future differences in generated codesize.
01:16:55 <segher__> but the does> in create can take care of that
01:17:05 <Quartus> How, for the dataspace pointer?
01:17:10 <segher__> erm i see
01:17:21 <segher__> gforth is just clumsy, heh
01:17:46 <Quartus> I couldn't see that you were leaving a dataspace addr on the stack at all in the code you posted.
01:18:05 <segher__> that's what my extra r> does iiuyc
01:18:20 <Quartus> iiuyc?  How does it do that?
01:18:59 <segher__> does> compiles a r> in my case
01:19:20 <segher__> the created word calls into that r>
01:19:20 <Quartus> Yes, but how does the dataspace addr get onto the return stack such that a r> would retrieve it when the CREATEd word runs?
01:19:24 <Quiznos> iiyuc == if i understand you correctly
01:19:34 <Quiznos> iiuyc
01:19:38 <segher__> the call leaves that address :-)
01:20:26 <Quartus> A call leaves the next unallocated dataspace address, fixed at the time the word was CREATEd, on the return stack?  I don't follow.
01:20:38 <segher__> a create'd word would look like      <:> <call behind the does> < data...>
01:21:06 <Quartus> I thought you had separate code and data spaces?
01:21:10 <segher__> so when the call is made, the address of "data" will be pushed to the rstack
01:21:15 <segher__> heh no
01:21:37 <segher__> separate name space, in some versions of the engine
01:21:40 <Quartus> If no, then '0 ,' in your CREATE would generate code that would almost certainly crash.
01:21:47 <segher__> but code and data is shared.  too useful :-)
01:22:06 <segher__> quartus: but the does> in create immediately patches it
01:23:19 <Quartus> Ok.  Well Gforth might let me leave a definition unterminated if I really kept at it, but I think the resulting code might be a touch confusing.
01:24:11 <Quiznos> mmm, i just got a revelation of how Partial Evaluation can relate to Proper ReFactoring
01:24:16 <Quiznos> sweet
01:24:34 <Quiznos> separate the (runtime) from the user level word
01:24:39 <segher__> you could have DOES do a POSTPONE ; as well, and then do a CELL+ to justify for that
01:24:58 <Quartus> The longer code has the additional advantage of running in either dtc or itc unchanged.
01:25:33 <segher__> so does mine
01:25:42 <segher__> in STC and BTC as well
01:26:15 <Quartus> Plugging an address directly into a 0 comma'd into the code doesn't strike me as a universally portable technique for code patching.
01:26:47 <segher__> well you might need an ALIGN somewhere
01:27:19 <Quartus> And perhaps a CALL in an STC.
01:28:07 <segher__> well on all architectures i care about, CALL <whatever> fits into a cell just fine
01:28:27 <Quartus> But you still have to build the instruction.  Grabbing a return address wouldn't quite suffice.
01:29:17 <segher__> sure, so have USE handle that
01:30:03 <Quartus> Right, so back to your code not running unchanged, depending on the threading method.
01:30:30 <segher__> not _literally_ unchanged, sure
01:30:41 <Quartus> I was thinking literally, yes. :)
01:31:30 <segher__> if you make USE use COMPILE! (similar to COMPILE,) it's portable still
01:31:57 <segher__> as long as your calls fit in a cell
01:48:08 <Quartus> No amount of shenanigans is getting Gforth to cooperate with having a R> cough up the required dataspace address.  I think Gforth may be doing something too crafty for me to grok at this juncture.  Perhaps I'll have at it again tomorrow.
01:49:52 <segher__> you might have to use the ITC gforth
01:50:06 <Quartus> I can't see that that would matter, but I'll have a look.
01:50:37 <segher__> the dynamic-super-instruction version won't be happy i think ;-)
01:51:12 <Quartus> Still wrong in the itc version.
01:51:37 <Quartus> Wrong in the same direction.  Maybe there's a tail-call optimization going on.
01:56:30 <segher__> perhaps R> stores the address of the calling instruction, instead of that of the next insn
01:57:20 <segher__> erm, not R>, but a function call
01:57:28 <segher__> or "the rstack"
01:57:44 <Quartus> No, that'd be easy to compensate for.  This is pulling up an address that I think is inside the interpreter somewhere when I just test   create foo    foo    at the console.   Different results if I call foo from another word.
01:58:57 <Quartus> So perhaps the manner in which a single word is executed in the interpreter differs from how it is called from within a word.  Gforth oddities?
02:01:03 <Quartus> I think I encountered this once before when trying to do return-stack tricks in Gforth, but can't for the life of me remember what answer I came up with.  Ah well. Tomorrow maybe.
02:01:26 --- quit: arke (Read error: 110 (Connection timed out))
02:05:39 <Quartus> Oh, I see what I'm doing wrong.  A simple misconception.  I'll fix it up tomorrow.
02:05:53 <segher__> :-)
02:24:37 --- join: nighty_ (n=nighty@CPE00119576a9c5-CM0012c90d36fc.cpe.net.cable.rogers.com) joined #forth
02:26:47 --- quit: nighty_ (Read error: 104 (Connection reset by peer))
02:28:10 --- join: nighty_ (n=nighty@CPE00119576a9c5-CM0012c90d36fc.cpe.net.cable.rogers.com) joined #forth
04:30:09 --- join: vatic (n=cturner@pool-162-83-254-201.ny5030.east.verizon.net) joined #forth
05:40:54 --- join: timlarson_ (n=timlarso@65.116.199.19) joined #forth
05:53:43 --- join: PoppaVic (n=pete@0-1pool66-110.nas22.chicago4.il.us.da.qwest.net) joined #forth
05:55:55 --- quit: nighty_ (Client Quit)
06:49:15 --- join: Ray_work (n=Raystm2@199.227.227.26) joined #forth
07:24:14 --- join: nighty_ (n=nighty@66-163-28-100.ip.tor.radiant.net) joined #forth
07:25:17 --- join: I440r (n=mark4@63.163.143.188) joined #forth
08:13:59 --- quit: PoppaVic ("Pulls the pin...")
08:15:38 --- join: PoppaVic (n=pete@0-1pool74-190.nas24.chicago4.il.us.da.qwest.net) joined #forth
08:46:32 --- quit: PoppaVic ("Pulls the pin...")
08:55:13 --- join: PoppaVic (n=pete@0-1pool46-98.nas30.chicago4.il.us.da.qwest.net) joined #forth
09:03:51 --- nick: Raystm2 -> nanstm
09:23:20 --- quit: vatic ("using sirc version 2.211+KSIRC/1.3.12")
09:41:28 --- mode: ChanServ set +o I440r
09:41:58 <Quartus> http://pastebin.ca/112006
10:04:41 --- quit: I440r ("Leaving")
10:34:49 --- quit: PoppaVic ("Pulls the pin...")
10:42:06 --- nick: saon -> gargamel
10:42:48 --- nick: gargamel -> saon
11:21:58 --- join: Quartus_ (n=Quartus_@209.167.5.1) joined #forth
11:24:41 <Quartus_> hey.
11:26:57 <Quiznos> b00!
11:27:41 * juri_ runs & hides.
11:28:01 * Quiznos pokes juri_
11:28:01 <Quiznos> juri_ falls over
11:28:01 <Quiznos> Quiznos runs.
11:28:07 <Quiznos> buwahwahwahwa
11:29:12 <Quartus_> hi juri. How goes the Forth?
11:32:24 <juri_> not very fast. two jobs is not leaving too much time for it. 
11:32:38 <juri_> my 'free time' is eaten up by trying to get my patches into GNU GIFT.
11:33:50 <Quartus_> I am without google. What's GNU GIFT?
11:34:04 <juri_> 'find like image' image recognition software.
11:34:14 <Quartus_> ah.
11:34:18 <juri_> i concider it associative memory.
11:34:22 <Quiznos> wher's google?
11:35:22 <Quartus_> I had occasion to use image colorization software recently; it occurred to me that it might benefit from like shape/texture recognition.
11:40:21 <Quartus_> though that might take the fun out of the process. :)
11:41:32 <juri_> i use gift to sort images based on what the form used was.
12:33:00 --- join: snoopy_1711 (i=snoopy_1@dslb-084-058-109-255.pools.arcor-ip.net) joined #forth
12:37:23 --- quit: Snoopy42 (Read error: 131 (Connection reset by peer))
12:37:28 --- nick: snoopy_1711 -> Snoopy42
12:43:19 --- quit: Quartus_ ("used jmIrc")
13:13:05 --- nick: nanstm -> tiff
13:29:17 --- quit: timlarson_ ("Leaving")
13:36:51 <jcw> Whoever "designed" the original Unix date/time functions should be shot.
13:39:59 <Quartus> Because...?
13:41:21 <jcw> What moron decided that month would be 0..11, while days would be 1..31?
13:41:35 <jcw> Or that localtime day-of-week is 0..6, while strftime is 1..7
13:41:53 <jcw> Or that we need to subtract 1900 from the year in struct tm?
13:42:10 <Quartus> They weren't all designed at the same time by the same people.
13:42:27 <jcw> I'd say the struct tm stuff was.
13:42:31 <jcw> strftime, no.
13:42:43 <jcw> But they had some history to work with, and it only makes sense to be consistent.
13:44:20 <jcw> Although there is %w for strftime(), which is 1..7, as opposed to %u's 0..6.  I'll remove that from the "list of reasons to kill people".
13:46:40 <jcw> Actually, no, I won't.  %u is 0..6, with Sunday being 0.  %w is 1..7, with Monday being 1.  That is not useful.
13:51:49 <JasonWoof> so the only difference is wheday is 0 or 7?
13:52:06 <jcw> 1;
13:53:41 <jcw> Half the real-time clock chips out there represent day of week as 1-7, with 1 being Sunday.  0 usually means it is confused and cannot figure it out (fancy clock chips), or the user has not programmed it (older clock chips)
13:54:32 <Quartus> How does that relate to strftime?
13:54:46 <jcw> And this is relevant since I convert the output of the clock chip to time_t to carry it around.  When I wish to print the values out again, I would like to print the values as they would appear in the registers, not some incorrect strftime() calculated version.
13:55:31 <Quartus> So write a wrapper for strftime and move on with your life. :)
13:56:00 <jcw> yeah yeah yeah.
13:57:49 <Quartus> Or, alternately, write a replacement for strftime, which should be pretty easy.
13:58:37 <jcw> There's probably a dozen ways to solve it.
13:58:46 <jcw> None of them can be started until the problem is suitable bitched about.
13:58:52 <jcw> suitably.
13:59:15 <Quartus> I don't know, Forth programmers usually just solve the problem without extensive bitching.
13:59:57 <jcw> That's because everything has to be written from scratch anyway.
14:00:35 <Quartus> If it's custom functionality you want, you're always writing from scratch, or using (as in your example here) a library you have problems with.
14:02:55 --- join: vatic (n=chatzill@ool-45740b1c.dyn.optonline.net) joined #forth
14:20:59 <Quartus> strftime is one of those 'swiss army  knife' library functions that tries to do everything.  Not very Forth-like.
14:22:57 --- join: Robert (n=robert@unaffiliated/robert) joined #forth
14:26:26 <virl> which library?
14:26:35 <Quartus>  strftime 
14:32:56 --- quit: nighty_ ("Disappears in a puff of smoke")
14:34:52 <Quartus> 40 or 50 format specifiers, it's virtually a programming language of its own.
14:36:29 <JasonWoof> wow
14:36:39 <Robert> Be careful, or someone in here will attempt to implement a Forth using a format string.
14:37:15 <Quartus> I wrote a printf once, pretty straightforward exercise.  Don't think I've ever had occasion to use it since.
14:37:38 <JasonWoof> I wrote a really basic printf sort of thing for creating database queries in forth
14:37:41 <JasonWoof> it's pretty handy
14:38:13 <JasonWoof> just one char for the specifier though
14:38:20 <JasonWoof> no prefix for padding or any of that
14:38:44 <JasonWoof> very useful though. %" encodes the input string with \ before \ and " and surrounds it with quotes
14:39:40 <JasonWoof> so you can write sql like so:   select email from users where name=%"
14:46:37 <Quartus> So kind of a macro string replacement thing.
14:47:28 <virl> printf, pah, that must be a big sequence of ifs
14:48:29 <Quartus> Pretty small sequence to handle the basic specifiers.
14:49:16 <virl> no stringcompares?
14:51:01 <Quartus> I'd have to dig it up.  Character compares.
14:59:29 <Quartus> This is some version of it.  Not the most outstanding code, but it works.
14:59:30 <Quartus> http://pastebin.ca/112398
15:00:34 <Ray_work> oh cool some sort of forth printf.
15:00:46 * Ray_work will have to devour this at home.
15:00:48 <Quartus> That's what it is.  Pass it a format specifier, it consumes items from the stack.
15:00:52 <Ray_work> gnight.
15:01:02 <Quartus> It's not particularly outstanding or complex.
15:01:44 --- quit: Ray_work ("User pushed the X - because it's Xtra, baby")
15:10:22 --- join: I440r (n=mark4@24-177-235-246.dhcp.gnvl.sc.charter.com) joined #forth
15:19:24 --- mode: ChanServ set +o I440r
15:29:32 --- quit: Robert ("leaving")
15:35:11 --- quit: Quartus (Read error: 104 (Connection reset by peer))
15:48:44 --- quit: vatic (Remote closed the connection)
16:00:41 --- join: Quartus (n=trailer@CPE0001023f6e4f-CM013349902843.cpe.net.cable.rogers.com) joined #forth
16:00:41 --- mode: ChanServ set +o Quartus
16:16:49 --- nick: tiff -> Raystm2
16:27:06 --- join: Quartus_ (n=Quartus_@209.167.5.1) joined #forth
16:53:04 --- join: arke (n=arke@pD9E05F80.dip.t-dialin.net) joined #forth
17:03:20 --- quit: yoyofreeman (Read error: 110 (Connection timed out))
17:23:34 --- quit: arke (Read error: 104 (Connection reset by peer))
17:26:00 --- join: vatic (n=chatzill@ool-45740b1c.dyn.optonline.net) joined #forth
17:29:22 --- quit: Quartus_ ("jmIrc destroyed by the OS")
17:30:12 --- join: Quartus_ (n=Quartus_@209.167.5.1) joined #forth
17:30:46 <Quartus_> hey.
17:32:58 <Quiznos> b00
17:42:39 * juri_ hides.
17:43:14 * Quiznos scrambles juri's letters
17:43:30 <Quiznos> ujir
17:43:46 <Quiznos> squart
17:44:05 <Quiznos> squatru
17:54:18 --- quit: vatic ("Chatzilla 0.9.74 [Firefox 1.5.0.5/2006072310]")
17:55:56 <I440r> you can hide but you cant run!
17:56:10 * juri_ hides again. ;)
18:00:39 --- join: nighty_ (n=nighty@CPE00119576a9c5-CM0012c90d36fc.cpe.net.cable.rogers.com) joined #forth
18:02:54 --- quit: Quartus_ ("used jmIrc")
18:05:33 <jcw> Quartus,  can you pastebin an example of how you use your module/public:/private:/end-module words?  Perhaps a file that has two words defined, one public, one private?
18:07:04 <Quartus> sure, hang on
18:07:49 <Quartus> Bear in mind if you go implementing this before you have wordlists, it'll be considerably harder and less flexible.
18:08:17 <jcw> k
18:08:50 <Quartus> http://pastebin.ca/112561
18:09:36 <Quartus> Some subtleties not apparent:  bar will not be findable outside of module foo, but gah will be.  Modules can be nested, and temporarily exposed so that private definitions are findable.
18:09:36 <jcw> Do the public: and private: basically just queue an attribute to be used by : ?
18:10:05 <jcw> Ah, the answer would be 'no', then.
18:10:14 <Quartus> No.  public: and private: change the search order and target wordlist.  This is why implementing wordlists and a search-order first is the right way to do it.
18:11:07 <jcw> Let's talk about wordlists, and how they work, then.  Not the gory details, up a level or two.
18:11:20 <Quartus> Your dictionary now is just a linked list, I assume.  Last defined = first found.
18:11:25 <jcw> Correct.
18:11:27 <Quartus> So if you define foo twice, you will find the second one.
18:11:32 <jcw> Yes
18:11:49 <jcw> Although I did consider the Factor approach of replaceable words.
18:11:58 <Quartus> So you can consider that to be a dictionary that contains one wordlist.  And your system has an unchangeable search-order of that one wordlist.
18:12:10 <jcw> yes
18:12:47 <Quartus> Extend your system so that it has a small stack, or ordered list, of wordlists that it can search, plus one variable that holds which wordlist is the current one that new definitions will go into.
18:13:17 <Quartus> Then extend your dictionary so that words have a new attribute that determine which wordlist they are part of.  Use integers starting a 0 for the first wordlist, 1 for the next, etc.
18:13:36 <Quartus> There are optimizations possible, of course, but that's the gist.  There are a series of words to build that will make this straightforward.
18:14:07 <Quartus> You'll want to enhance your FIND, both the internal and external versions, so that they travel the search-order searching for a matching word in each wordlist in the search-order in turn.
18:14:30 <jcw> What words do we want to create and select wordlists?
18:14:40 <jcw> s/to/to define/
18:15:49 <Quartus> I suggest the Forth Standard search-order words.  Fundamental are GET-ORDER and SET-ORDER.  Here's the wordset itself: http://quartus.net/dpans/dpans16.htm#16.6.1
18:16:17 <Quiznos> in ANS, is the word `set-current:' ?
18:16:23 <Quiznos> with a final `:'?
18:16:36 <Quartus> No :.  SET-CURRENT is a standard word.
18:16:40 <Quiznos> kk
18:17:44 <Quiznos> why or what would be the porpose of the definition, : ;
18:17:55 <Quartus> You want your system to have a default search-order that contains the words available at startup, and to have that search-order reset by ABORT.
18:18:13 <Quartus> Quiznos, what?
18:18:29 <Quiznos> the : follows set-current and then a ;
18:18:48 <Quartus> What are you referring to?
18:18:54 <Quiznos> ok, it's a define of the next token
18:18:58 <Quiznos> weird
18:19:11 <Quartus> What are you talking about, Quiznos?
18:19:29 <Quiznos> muenches emeta.shtml is one long html line and i'm reformatting it manually
18:19:56 <Quiznos> i think i have it properly formatted now
18:20:51 <Quartus> jcw, it's a short wordset: 12 new words in total, and FIND extended.
18:21:24 <jcw> With the non-extended FIND, what's the different between FIND and ' ?  FIND words from a counted string, ' works on the next token?
18:21:36 <Quartus> That's right.
18:22:18 <Quiznos> is compile, a standard word?
18:22:27 <Quartus> Quiznos, http://quartus.net/dpans
18:22:35 <Quiznos> a yes or no works for me
18:22:44 <Quartus> Having you look it up works better for me.
18:22:53 <Quiznos> i'm sqeered :)
18:22:55 <Quiznos> heh
18:23:03 <Quartus> jcw, ' is built on the same internals as FIND, so extending FIND extends '.
18:25:58 <jcw> So (gforth) for example may have 8 (for example) wordlist slots.  There can be more than 8 wordlists, but only 8 can be active at a time.
18:26:37 <Quartus> Right. 8 is a minimum for the allowable length of the search-order.
18:26:56 <Quartus> Quartus Forth has 16 in its current incarnation.
18:28:45 <jcw> 'wid' is a number?  How are word lists assigned actual names?
18:29:09 <Quartus> They remain unnamed in this scheme.  Gforth assigns names by associating the name of the next defined word.
18:29:33 <Quartus> Quartus Forth leaves them unnamed, and uses the named module facility on top of them.
18:29:51 --- join: nighty- (n=nighty@CPE00119576a9c5-CM0012c90d36fc.cpe.net.cable.rogers.com) joined #forth
18:30:01 <jcw> So with get-order, what are these huge negative numbers it's displaying?
18:30:11 <jcw> Well, pushed on the stack.  And .s'ed.
18:30:27 <Quartus> In gforth?
18:30:31 <jcw> Yes
18:30:47 <Quartus> Those would be wids, whatever mechanism gforth uses for them.
18:30:57 <Quartus> Probably addresses of data structures in memory.
18:31:32 <jcw> That's confusing.  Mostly because it seems 'wid' is used to mean different things.
18:31:51 <Quartus> It's a single-cell unique identifier for a wordlist.  How your implementation manages that is up to you.  It can be done very simply.
18:32:15 <Quartus> wid is only one thing, that unique identifying single-cell value.
18:32:44 <Quartus> The system has at least one pre-defined internally, and more are generated using WORDLIST.
18:33:43 <Quartus> They can be as simple as numeric tags that are contained in the header of each word, or as complex as addresses of entire dictionary structures.
18:34:01 <Quartus> I suggest simple to start with.
18:36:39 <jcw> That's taking all the fun out it!
18:37:50 <Quartus> Well, let's say you'll be doing me a kindness as tutor if you start easily. :)
18:40:15 <Quartus> In the appendix of that document there's a definition of a VOCABULARY word that makes a named wordlist that self-attaches to the search-order; that can be trivially built on top of these words.
18:46:36 --- quit: nighty_ (Read error: 110 (Connection timed out))
18:52:47 <jcw> Overall, this doesn't look very complex to implement.  I don't think I'll do it tonight, however.
18:52:55 <Quartus> Ok.
18:53:19 <Quartus> I'll dig up my module source that works overtop of that.
18:58:08 <jcw> Kewl
19:07:12 --- quit: uiuiuiu (Remote closed the connection)
19:07:14 --- join: uiuiuiu (i=ian@dslb-084-056-234-139.pools.arcor-ip.net) joined #forth
19:18:34 --- quit: I440r (Remote closed the connection)
19:35:07 --- nick: Zymurgy_ -> Zymurgy
19:44:09 <JasonWoof> http://img.snapsoid.com/cf/26/1791e307ebf27e142758df4e698b_740.jpg
20:32:50 <Quartus> There's another technician I'd fire. :)
23:10:54 <nighty-> Hi:)
23:12:30 <JasonWoof> howdy
23:12:45 <Quartus> what's up?
23:12:48 <nighty-> any of you guys would be for hire ?
23:12:56 <nighty-> on a project 
23:13:07 <nighty-> remote work is possible
23:13:45 <Quartus> What kind of project?
23:14:08 <nighty-> writing some firmware for a RFID tag and RFID reader
23:14:17 <nighty-> WIFI Tag 
23:14:25 <nighty-> WIFI Reader
23:14:32 <Quartus> Sounds like fun.  
23:15:05 <nighty-> My company is based in Toronto 
23:15:09 <Quartus> I'm in Toronto.
23:15:16 <nighty-> Cool :)
23:15:21 <nighty-> I am in toronto too:)
23:15:33 <Quartus> And available for hire, in fact.
23:15:46 <nighty-> what is your job ?
23:15:51 <nighty-> and skills ?
23:16:03 <nighty-> we are also looking for a rare beast
23:16:10 <nighty-> programmer 
23:16:19 <nighty-> but .net and unix system programming
23:16:27 <Quartus> My software company is called Quartus Handheld Software.  I'm the author of Quartus Forth, the on-board compiler for the Palm OS.  http://quartus.net
23:16:28 <nighty-> usually does not go together
23:16:36 <nighty-> Neat
23:16:42 <nighty-> We have to meet
23:17:12 <nighty-> We also need SIP Phone with Push to Talk function 
23:17:28 <JasonWoof> I can vouch for the quality of Quartus's work
23:17:30 <nighty-> we would like to have a linux phone
23:17:40 <Quartus> Thanks, JasonWoof.
23:17:43 <nighty-> meaning a linux based phone 
23:17:52 <nighty-> WIFI SIP Phone
23:18:07 <Quartus> I've been working in Linux since it fit on one floppy.
23:18:08 <nighty-> none of the phone on the market have this function
23:18:41 <nighty-> Quartus, would you be interested in meeting us
23:18:49 <nighty-> for either/or 
23:19:02 <JasonWoof> I'm very suprised you two live in the same city
23:19:03 <nighty-> the project and/or the available position
23:19:17 <nighty-> JasonWoof, I come from France
23:19:20 <Quartus> Sure.  I'm looking for work and you sound like you have some interesting things going on.
23:19:25 <nighty-> JasonWoof, I just moved over here
23:19:47 <nighty-> I have been head hunted by my current company
23:19:50 <Quartus> JasonWoof, if it's an elaborate ploy to assassinate me, I'll leave word with my next of kin. :)
23:20:02 <nighty-> lol:)
23:20:08 <JasonWoof> heh
23:20:11 <Quartus> I nearly took a job in Paris back in 2000.
23:20:16 <JasonWoof> heh
23:20:25 <nighty-> Quartus, oh 
23:20:30 <Quartus> Headhunted for that, too.
23:20:35 <nighty-> Quartus, I guess we HAD to meet
23:20:37 <nighty-> :)
23:20:40 <Quartus> I guess. :)
23:21:09 <nighty-> it s hot 
23:21:12 <nighty-> here
23:21:20 <Quartus> It is that.  Air conditioning a requirement.
23:21:21 <nighty-> and humid
23:21:37 <Quartus> I thought we'd lose power during the thunderstorm tonight.
23:21:39 <nighty-> I don't have it yet in my appartement
23:21:43 <nighty-> Yes 
23:21:46 <nighty-> we did not
23:22:02 <JasonWoof> I don't have AC at home, so I spent most of the day at the library
23:22:08 <nighty-> I live on St Clair / Bathurst
23:22:15 <Quartus> I'm right downtown near the St. Lawrence Market.
23:22:25 <nighty-> the company is on Laird Drive
23:22:34 <nighty-> Quartus, oh ok
23:22:52 <Quartus> I know Laird.
23:22:56 <nighty-> Quartus, do u hang around #srh ?
23:23:08 <Quartus> No, I don't.  What's that channel about?
23:23:16 <nighty-> Mostly Telco people
23:23:21 <nighty-> ISP 
23:23:37 --- quit: segher__ (Read error: 60 (Operation timed out))
23:23:38 <nighty-> all the telco/isp people from toronto 
23:23:52 <nighty-> since the begining of the net
23:23:53 <Quartus> Not my crowd.  I've spent the last 20 years in various systems roles, but never for a telco or an ISP.
23:23:56 <nighty-> in toronto
23:24:18 <nighty-> Quartus, how much do you know IP ?
23:24:47 <Quartus> As in TCP/IP?
23:24:51 <nighty-> Yes
23:24:55 --- join: segher__ (n=segher@dslb-084-056-164-244.pools.arcor-ip.net) joined #forth
23:24:56 <nighty-> TCP/IP
23:25:09 <nighty-> segher__, guten tag :)
23:25:25 <nighty-> segher__, guten morgen :)
23:25:44 <Quartus> I've been involved in systems architecture and design starting with Token Ring in the late '80s and moving to Ethernet and TCP/IP systems in the 90s, so I understand it well enough I think.  
23:25:58 <nighty-> ok good :) very good :)
23:26:48 <Quartus> I've spent the last 18 months focused on my Forth work; I'd want to brush up on anything specific, but that's no problem.  I am a generalist at heart, but specialize as required.
23:27:55 <Quartus> Anyway, by all means get in touch: I'm Neal Bridges: neal@quartus.net.
23:28:44 <nighty-> oops I just queried you
23:28:55 <Quartus> I didn't feel a thing.
23:29:20 <nighty-> uh ?
23:29:28 <Quartus> Kidding.  :)
23:29:41 <nighty-> u did not get my infos M 
23:29:45 <nighty-> u did not get my infos ?
23:30:00 <Quartus> No, I didn't get anything.  freenode doesn't let you send private messages unless you have registered your nick.
23:30:08 <nighty-> pfff
23:30:22 <nighty-> here it is
23:30:38 <nighty-> <nighty-> here is the address of my company
23:30:38 <nighty-> <nighty-> 33 laird drive
23:30:38 <nighty-> <nighty-> NL technologies
23:30:38 <nighty-> <nighty-> my name is : christophe prevotaux
23:30:38 <nighty-> <nighty-> email: cprevotaux@nltinc.com
23:30:39 <nighty-> <nighty-> phone: 416 425 6559 ext 290
23:30:41 <nighty-> <nighty-> please drop by anytime you want
23:30:43 <nighty-> <nighty-> just call me before
23:30:45 <nighty-> <nighty-> I'll explain what we are doing
23:30:47 <nighty-> <nighty-> and show you around
23:30:49 <nighty-> sorry for the flood guys
23:30:55 <Quartus> Ok, thanks.
23:31:57 <nighty-> I think we should sometime soon
23:32:02 <nighty-> meet
23:32:51 <nighty-> sleep time
23:32:55 <Quartus> Yes, I agree.  I also agree with JasonWoof, it's odd that you should be in Toronto and looking for an embedded Forth programmer in Toronto who is looking for work; I'm probably the only one. :)
23:33:00 <nighty-> got to go to work tomorrow
23:33:08 <Quartus> Ok. I'll be in touch.
23:33:16 <nighty-> thanks 
23:33:30 <nighty-> bye all
23:33:33 <Quartus> Bye.
23:33:34 --- quit: nighty- ("Terminated with extreme prejudice!")
23:33:38 <Quartus> Very odd, that.
23:41:47 <virl> well.. for what actually do you get a forth programmer? embedded stuff?
23:42:23 <Quiznos> this is very strange text
23:42:48 <Quartus> Nowadays -- OpenBoot work, robotics, certain legacy systems, embedded stuff, sure.
23:45:13 <JasonWoof> did he say something about forth?
23:45:21 <JasonWoof> nightly
23:45:33 <Quartus> He didn't, directly.
23:45:52 <JasonWoof> I was not making that assumption
23:46:07 <Quartus> But he was in #forth asking, so I made the tentative assumption.  Could be he's just after the embedded expertise.
23:46:20 <JasonWoof> I've seen him here before
23:46:26 <Quartus> I have too.
23:46:55 <JasonWoof> I hope you can work in forth
23:47:07 <Quartus> That'd be fun.
23:47:08 <JasonWoof> but I'm only giving it 20% chance
23:47:17 <Quartus> I'll have to see what they're up to.
23:47:24 <Raystm2> You have to go where the Forth leads you.
23:47:54 <JasonWoof> well, maybe 20% that they'll want you to, and another 10% that you can convince them to let you do a significant part of it in forth
23:47:58 <Raystm2> Prob'ly not hard to find a job say for a space sup contractor.
23:48:01 <Raystm2> sub even
23:48:28 <Raystm2> hmm, retro doesn't have abs yet.
23:48:32 <Raystm2> i think.
23:48:48 <Raystm2> ya not there.
23:49:14 <Quartus> JasonWoof, I'm happy coding in whatever, really.  But who knows, maybe there's room for Forth in there.
23:49:43 <Quartus> Of course, it may not be a good fit from one side or the other; remains to be seen.
23:49:54 <Quartus> Me and them, I mean.  Not Forth and embedded hardware. :)
23:50:27 <JasonWoof> :)
23:50:41 <Raystm2> Pardon? Can I mask out the sign bit to get abs?
23:50:51 <JasonWoof> Raystm2: no
23:51:06 <JasonWoof> -1 is all bits set
23:51:09 <Raystm2> oh i have to also ya
23:51:13 <virl> ok, then this acknowledges one of my assumptions that forth is perhaps on the beginning of a slow rise.
23:51:29 <Quartus> Your assumption, often stated, is that Forth is dead and that the Standard killed it.
23:51:30 <Raystm2> so I have to also add 1
23:51:47 <Quartus> Raystm2, adding 1 and masking the sign bit will not convert a negative to an absolute value.
23:52:08 <JasonWoof> to flip the sign, you flip all the bits then add one
23:52:13 <virl> well, not really the standard alone but also some side conditions.
23:52:26 <Quartus> The other way of flipping the sign is to negate the value. :)
23:53:05 <Raystm2> but I want abs not negate.
23:53:17 <Quartus> Yes.
23:53:41 <JasonWoof> you can do something silly like this:  : abs 1 over 30 >> 2 & - * ;
23:53:43 <Raystm2> so if 0 < negate ; then
23:53:53 <JasonWoof> oops
23:53:59 <JasonWoof> no, that'll probably work
23:54:07 * JasonWoof tests
23:54:35 <virl> another nice thing is when doing bitmasks with the convention of no bit-holes. you can use the twos-complement to produce the padding. a nice thing, well I stumbled over it somedays ago.
23:54:51 <Raystm2> 0 < if negate then ;
23:55:02 <Quartus> Raystm2, that'll work.  There are other ways to do it too.
23:55:12 <Raystm2> thanks. 
23:55:42 <Quartus> Toss a DUP in front of that.
23:56:04 <JasonWoof> yep, that works. here it is with ans word names: : abs 1 over 30 rshift 2 and - * ;
23:56:57 <Raystm2> ya dup. 
23:57:01 <Raystm2> cool JasonWoof.
23:57:21 <virl> eh.. only 1+ no.. two complement, well I'm just stupid
23:57:44 <Raystm2> that's better then an if because it's mostly register?
23:58:13 <Quartus> Raystm2, an IF is probably faster than JasonWoof's version.
23:58:49 <JasonWoof> probably
23:58:55 <Quartus> And probably easier to decipher when you find it later on. :)
23:59:11 <Raystm2> there is that.
23:59:21 <JasonWoof> mine is 3 ppc instructions
23:59:26 <JasonWoof> but ugly in forth
23:59:29 <Raystm2> no I write stuff that will never get another look. :)
23:59:59 --- log: ended forth/06.08.02