Discussion w/ Chuck Moore on irc.openprojects.net #forth
on Saturday, May 4, 2002.
--------------------------------------------------------------------

<thefox> I haven't done a prototype run since 98 and the only MISC prouction run was MuP21 in 1994 by Dr. Ting.

<futhin> *goshawk`: how did you come to the conclusion that Forth was too complex, and that sourceless programming was your next move?
<chipChuck> Maybe by reading the Forth Standard
<chipChuck> There are Megaforths that try to do everything
<chipChuck> Just like Windows or Unix
<chipChuck> But sourceless code is a dead end. Self-limiting
<chipChuck> colorForth seeks the absolute minimum of overhead.
<chipChuck> Published colorForth is overly complex. colorForth in colorForth will be simple.

<futhin> <AlephNull> Mr. Moore and/or Mr. Fox: Have you ever considered writing a book on forth or computing?
<chipChuck> I lack the patience to write a book. I'll let Jeff

<futhin> futhin: what do you think about FOR NEXT?  is FOR NEXT more efficient & simple?  what about the conflict with the NEXT word used in the inner interpreter in some forths?
<chipChuck> FOR NEXT is much simpler than DO LOOP, especially for hardware implementation.
<chipChuck> Implementation words such as the other NEXT should be invisible
<chipChuck> FOR NEXT runs thru loops backwards. Which is perfectly fine, once you're used to it

<futhin> <wtanksley> Chuck, have you looked at backtracking?  Have you played games like that with the return stack?
<chipChuck> Yes, return stack is a valuable tool
<chipChuck> One use I made of it was to implement infix notation with precedence operators
<thefox> Except that you can't count on it being a return stack in ANS...
<I440r> strike one against ans
<chipChuck> On the other hand, I don't like CATCH THROW

<futhin>  <fare> chipChuck: were you or are you aware of the POP-2 language, that in the late 1960s introduced a double-stack virtual machine with postfix syntax, on top of a successor of which now still exists poplog (a multilanguage system that supports pop-11, prolog, common lisp and ml)
<chipChuck> Not that I recall
<futhin> *Fare: What do you think of high-level strongly-typed variants of forth, such as POP-11, HP RPL, Postscript?
<futhin> (two questions similar to each other..)
<chipChuck> Typing is a crutch for poor programmers
<chipChuck> It's an obstacle for good ones
<MrReach> heh, well said
<chipChuck> Strong typing merely creates errors so that they can be detected
<chipChuck> I have no objections to forth-like languages, or any languages
<chipChuck> Just don't make me use them

<futhin>  <kc5tja> In your ColorForth environment, you mention on your webpage that code is recompiled on the fly, as needed.  Does this happen "in place" and retroactively?  Consider your RDY word in your IDE driver example code.  If we were to change it somehow, and have it recompiled, will that retroactively affect other words which utilize it?  Thanks.
<chipChuck> No. Words must be defined before they're used
<chipChuck> Original Forth, circe 1968, did provide retroactive redefinition
<chipChuck> That means reinterpreting text at execution time. Far too expensive
<chipChuck> But you can always recompile the application whenever you change a definition is uses
<chipChuck> Compile time is really zero

<futhin> <i440r> "words must be defined before they are used" do you discourage the use of defered words ?
<chipChuck> Yes
<chipChuck> But there are some situations when you can't avoid them
<chipChuck> colorForth has several deferred words in the kernel. That's a flaw in the kernel design

<futhin> <jim> Chuck: (about catch/throw)... You don't think that in large systems, it would be nice for higher-level routines to have the option to handle lower-level exceptional conditions?
<chipChuck> That's a hard one
<chipChuck> There shouldn't be errors
<chipChuck> But if a server fails to respond, something must be done
<chipChuck> Must the application anticipate all such problems
<chipChuck> Or can the system somehow cope
<chipChuck> What I do is to mix the low and high-level code into an integrated whole
<chipChuck> Modify the low-level code as necessary for the application
<chipChuck> The notion of levels of code, as in communication protocols, is wrong
<chipChuck> There needn't be so much code to make it necessary

<futhin>  <kc5tja> Are there purely technological reasons why you dislike CATCH/THROW, versus philosophical reasons?
<chipChuck> No. It's a neat solution for the perceived problem
<chipChuck> But when you mess with the return stack, you can create problems
<chipChuck> Robust, reliable code is simple

<futhin> *GilbertBSD: what axioms inspired the early design of forth?
<chipChuck> The data stack came from the Burroughs 5500
<chipChuck> Once I learned to use the stack, everything else followed
<chipChuck> The stack provides name-less temporary storage
<chipChuck> When you have to invent names, imagination fails
<chipChuck> Hence the endless hyphenated words of C
<chipChuck> Likewise in my chip design, most signals are unnamed
<chipChuck> Contrary to VHDL and the like that require them

<futhin> <onetom> Q: what is ur name convention for structure members/field? whats up w nested structures?
<chipChuck> I don't do it that way
<chipChuck> Forth, Inc had data-base structures
<chipChuck> The higher level names set default values
<chipChuck> That is, a file name set the current file
<chipChuck> A record number set the current record
<chipChuck> A field name accesses the current record in the current file
<chipChuck> At no time did you need to concatenate the names
<chipChuck> Though you needed to keep them distinct
<thefox> I would add that as part of the MachineForth training I would cover the concept of using the auto-incrementing instructions as much as possible in such code.

<futhin> <onetom> how do u avoid name clashes between fieldnames in different structures?
<chipChuck> We were designing the database
<chipChuck> So the NAME field was in the same position in all files
<chipChuck> If that's not possible, you need distinct names
<chipChuck> But only in applications that must be resident simultaneously
<chipChuck> That is, those that use multiple files
<chipChuck> When you recompile applications as needed, this is pretty much avoided

<futhin>  *futhin: "Now that you've come up with colorforth and experimented with new ways to code forth, have you discovered any useful things that can be applied to machineForth for a better machineForth?"
<thefox> colorforth is a clearer description of machineforth for one thing.
<chipChuck> New ideas always appear
<chipChuck> But colorForth makes it easy to do work arounds
<chipChuck> For example, IF is a perennial problem
<chipChuck> Should it pop the stack?
<chipChuck> Maybe yes, maybe no
<chipChuck> And that's a hard change to mask
<chipChuck> But, it's simpler to decode instructions if it doesn't
<chipChuck> So that's how it is so far

<futhin>  <i440r> IF and DUP-IF ???
<chipChuck> Having multiple words could help
<chipChuck> But it makes the language more complex, harder to learn
<chipChuck> And doesn't address the underlying hardware issue

<futhin> <i440r> do you think portability is important - or does forths ease/speed of development negate the need for it
<chipChuck> Portability is not important
<chipChuck> Portability is not possible
<chipChuck> Real applications are closely coupled to hardware
<I440r> !
<chipChuck> Change the platform and all the code changes
<I440r> i was hoping you would say that :P
<chipChuck> If it didn't, you wouldn't have changed the platform
<chipChuck> To abstract the problem from the hardware requires massive software like Windows

<chipChuck> That's a permanent tax on all applications to save some one-time programming
<chipChuck> Programmers should object to job-elimination concepts
<chipChuck> Of course, jobs are actually multiplied to deal with the hyper-complex abstraction
<chipChuck> And modern hardware has computers in the displays and disks
<chipChuck> They've already made many interfaces protable
<chipChuck> How many layers of portability are needed?
<tcn> Dealing with Windows is a lousy job, no matter what it pays :)

<futhin>  <jim> ChipChuck: In another question, it was mentioned you are experimenting or otherwise dealing with something called "sourceless programming"... could you elaborate a bit?
<chipChuck> I spent several years writing sourceless code
<chipChuck> This was my first version of OKAD, for chip design
<chipChuck> By this I mean, editing the hex machine code into memory and saving to disk
<chipChuck> If, as I expected, code could be reused the actual machine code would be managable
<chipChuck> But it grew without limit, eventually becoming unmanagable
<chipChuck> And there was another gotcha
<chipChuck> I'd have numbers embedded in the code, without any documentation as to how they were computed
<chipChuck> colorForth embeds expressions and compiles the result as a literal
<chipChuck> But the trace of what that number means, remains

<futhin> <tcn> Do you have romantic notions of fixing the internet and everything, bringing simplicity to the masses? What would it be like?
<chipChuck> Of course
<chipChuck> I see a Forth Markup Language supplementing HTML
<chipChuck> That defines a subnet of users that can read it
<chipChuck> FML is like colorForth - words with tags
<thefox> iTV in colorforth
<chipChuck> More compact, more efficient, more flexible
<tcn> what about communication protocols (IP, TCP, etc..)?
<chipChuck> Eliminates the need for Java
<chipChuck> TCP/IP can't be changed
<chipChuck> But it can be lived with

<futhin> *goshawk`: Do you see your ideas gaining more acceptance and being more fully exploited in your lifetime? If not, what is stopping that from becoming a reality?
<futhin> also
<futhin> question for jeff
<futhin> <jim> Jeff: MachineForth -training-? please elaborate?
<thefox> my ideas are not good enough yet?
<chipChuck> Ideas are memes. They evolve unpredictably
<chipChuck> Memes insinuate themselves untraceably
<futhin> thefox:  sorry, question was <jim> Jeff: MachineForth -training-? please elaborate?
<chipChuck> My ideas have influence, probably as much as they deserve
<chipChuck> Those that achieve prominance are the result of fads
<thefox> ah, I trained new programmers at iTV in MachineForth.  I got pretty good at it.  Not all the programmers were interested, some were hired to write ANS only and were experts in the way they did it.
<thefox> I will make a complete series of videos on machineforth at my website.  I did get a start at it.  over
<chipChuck> Consider the family of languages Fortran, Algol, PLI, Pascal, C
<chipChuck> They're all the same. The currently popular one is random choice
<chipChuck> No. I don't expect to become accepted
<chipChuck> I'll just keep exploring

<futhin> <rob_ert> Do you think forth should be used as a "general purpose language", for everyday software, or does it belong among embedded devices and other specialised systems?
<chipChuck> Forth is the best language for all purposes
<chipChuck> Because it mimics natural language
<futhin> :)
<chipChuck> Defining new words in terms of old ones
<chipChuck> Hiding information on the stacks
<chipChuck> Makes it easy for normal humans to customize their computer
<chipChuck> Will it happen?
<chipChuck> Give me $100M and I'll compete with Gates

<futhin> *goshawk`: Do you believe the open source "movement" had any negative impacts on the acceptance and/or practice of Forth?
* chipChuck thinking
<chipChuck> Forth was open source before open source became popular
<chipChuck> I don't see a negative impact
<I440r> any posative impact?
<chipChuck> I see a decrease in the writing of software
<chipChuck> And an increase in attention paid to integrating software
<tcn> bad news..
<chipChuck> DOD boasts about how much code can be ported from the F22 to the F35
<chipChuck> Maybe 50% of 6M
<chipChuck> So nobody writes from scratch
<chipChuck> Not even Linux drivers
<chipChuck> Forth is the last bastion of DIY
<chipChuck> Open source hasn't hurt or helped that

<futhin> <jim> Chuck: Gates is presently competing with Stallman and Torvalds... if you were at that level, is it Gates that you would be competing with? Do you regret that forth came out into open source?
<chipChuck> I wouldn't compete on a PC platform
<chipChuck> With the 25x, it's a whole new ballgame
<chipChuck> No, I think Forth source is a goldmine
<chipChuck> Ideas should not be secret
<chipChuck> Should not be patentable
<chipChuck> The more people engaged, the better the result

<futhin> <josephMoore> how do you feel about automated production of software (computer driven) and its possible role in replacing future human development thereby replacing the need for language based development
<chipChuck> Computers that program themselves have been a dream for decades
<chipChuck> It hasn't happened yet. Not even a little
<chipChuck> Even if they do, it takes a human to have the insight to change the rules
<chipChuck> Without true AI, I see no prospect
<chipChuck> And even with AI, there has to be a language to express the problem and solution
<chipChuck> Not in my lifetime

<futhin> <mlg> ChipChuck - you mentioned Forth Markup Language (FML). My practice shows that Forth does not make a good language for batch programming (unless you manage to add an interactive window). What sort of interactivity (if any) do you propose for FML?
<chipChuck> FML, like colorForth, would let the user type (steer) while processing in the background
<chipChuck> Batch programming is an obsolete concept?
<chipChuck> Computers are so fast, anything should happen instantly
<chipChuck> But, searching the web
<chipChuck> Don't know. Wait and see. But always something can be done

<futhin> <nothing> Mister Moore: What are your further plans for an integrated forth hardware solution? Would you be interested, money being no concern, to realize such plans?
<chipChuck> Absolutely
<chipChuck> Forth on a Forthchip is an unbeatable combination
<chipChuck> Trouble is, computers are so fast already that C is viable
<thefox> twice the fun
<chipChuck> Yet critics claim problems that cannot be addressed
<chipChuck> Consider weather forcasting
<chipChuck> At some point, chaos limits predictions
<chipChuck> Faster supercomputers are unhelpful
<chipChuck> Perhaps UWB is fertile ground for elaborate processing

------------
15:30:03 <futhin> <joseph> have you ever programmed self mutatable or self replicating system components or even user level applications using forth
15:30:11 <futhin> <joseph> and if so does it offer any advantage over using assembly 
15:30:48 <chipChuck> OKAD, in sourceless code, was self-modifying
15:31:42 <chipChuck> I'd like to optimize the c18 computer, at a layout level
15:32:01 <chipChuck> That would require mutating code
15:32:19 <chipChuck> colorForth is intended to facilitate that
15:32:55 <chipChuck> For example, storing (and displaying) variables in source code means they can easily be changed
15:33:19 <chipChuck> But no, I've not done anything significant

15:33:37 <futhin> steering it back to FML..
15:33:39 <futhin> <geakazoid> Will FML have programmable tag sets like XML?
15:33:46 <futhin> <geakazoid> What work has been done on FML? Is it a project that is being programmed?
15:34:10 <futhin> *tcn* side note: you could write in FML and translate to HTML until everyone's using FML
15:34:06 <chipChuck> Absolutely. Programmable tags
15:34:28 <chipChuck> As in Forth, tags defined in terms of previously defined tags
15:34:43 <chipChuck> Something I sorely miss in HTML
15:34:58 <chipChuck> FML is vaporware, from my perspective
15:35:27 <chipChuck> What it needs is several people who use it to communicate and thereby evolve it
15:36:00 <chipChuck> One more comment
15:36:35 <chipChuck> An FML tag has a distinct color. It is a word that is executed by the editor
15:37:07 <futhin> <John_Peters> Where can we participate in or see some FML activity?
15:37:09 <chipChuck> And ignored by the compiler?
15:37:52 <chipChuck> So it takes advantage of the run/compile/edit distinction
15:38:22 <chipChuck> FML will be on the internet when its time comes. Nothing yet

15:38:37 <futhin> <kc5tja> FML has been mentioned numerous times in this discussion, but yet, no examples of what it'd look like or its structure has been given.  Is this iTV proprietary information?  If not, can an example be posted?  The idea of Forth as a markup language intrigues me much.  Thanks.
15:39:31 <chipChuck> iTv may have precursed the idea, but not really
15:39:56 <chipChuck> When I get TCP and PPP coded, I'll work on a browser
15:40:18 <chipChuck> That browser will translate HTML into FML
15:40:43 <chipChuck> colorForth will interpret the FML to display pages
15:41:18 <chipChuck> When FML is adequate, it can be posted directly and avoid translation
15:41:58 <chipChuck> For example, the purple word  P  could mean the HTML tag <p>
15:42:17 <chipChuck> And so forth
15:42:26 <chipChuck> Simple translation
15:42:38 <chipChuck> Perhaps 2x compression from Huffman coding
15:43:00 <chipChuck> And elimination of those interminable <s and >s
15:43:10 <chipChuck> And the resulting spelling errors

15:43:28 <futhin> *Howerd* Chuck: Is there any difference between FML and a remotely executed Forth program?
15:43:57 * chipChuck thinking
15:44:25 <chipChuck> FML would be a restricted subset for security
15:44:50 <chipChuck> But it's not remotely executed
15:45:03 <chipChuck> You've downloaded the source and executed it locally
15:45:47 <chipChuck> One advantage of a colorForth-enabled web would be ease of sharing code
15:45:52 <futhin> *Howerd* Chuck: perhaps I'm thinking of F-ASP :)
15:45:57 <thefox> It could be the basis for a parallelism on the net.
15:46:00 <I440r> clitnt side instead of server side ? (eek)!
15:46:46 <chipChuck> Sorry, don't recognize F-ASP, so I missed the joke

15:47:12 <futhin> <geakazoid> What work has been done on FML? Is it a project that is being programmed?
15:47:21 <futhin> <geakazoid> I am interested in a programmable tag set that would allow virtual interaction from the user's perspective, would FML have that interactive ability that would replace CGI scripting?
15:47:31 <futhin> i think we'll get off the FML subject after these...
15:47:36 <futhin> got many more questions :)
15:47:36 <chipChuck> I started it with the first colorForth
15:47:52 <chipChuck> Then abandoned it to work on OKAD II
15:48:15 <chipChuck> It's only interesting with the web

15:49:03 <futhin> <GilbertBSD> are there concepts in other programming languages that you admire or is forth the one true language?
15:49:24 <futhin>  <fare> are you familiar with high-level functional programming languages such as lisp, ml, haskell, pop-11, clean ? with logic programming languages such as prolog, mercury, oz?
15:49:32 <futhin> (2 similar questions i think..)
15:49:37 <chipChuck> Yes, FML should allow virtual interaction
15:50:19 <chipChuck> Yes, I'm familiar with LISP, Prolog. Not the others
15:50:35 <chipChuck> When I was developing Forth, I knew all languages
15:50:50 <chipChuck> With Forth, I've neglected them
15:51:09 <chipChuck> However, show me an idea (like Prolog) and I'll implement it in Forth
15:51:42 <chipChuck> But don't suggest processing of text. That's an exhausted field
15:52:00 <chipChuck> LISP was one of the inspiration for Forth
15:52:19 <chipChuck> The notion that you could compute something without storing anything
15:52:48 <chipChuck> I don't see new ideas in the new languages

15:53:34 <futhin> <kc5tja> Your hardware and software ventures are decidedly "out of the box".  Have they been profitable enough to live comfortably with?  (I guess, in other words, how big is the market?)
15:54:05 <chipChuck> They've not been profitable
15:54:11 <chipChuck> But they've met expenses
15:54:54 <chipChuck> iTv was the best organized attempt at profitability
15:55:16 <chipChuck> At one time, I was worth $20M (paper)
15:55:37 <chipChuck> But it didn't work out
15:56:08 <chipChuck> I wouldn't recommend me as a role model

15:56:23 <futhin> <onetom> Q: if text processing is so exhausted could u tell us some pointers to some -say- text replacement library understanding regexp-s implemented in forth?
15:57:21 <chipChuck> don't understand
15:57:33 <futhin> oks orry

15:57:59 <futhin> *water* Mr. Moore: have you looked at the functional language Joy that is purely functional but works like a Forth, using word substitution and list-based processing? what do you think joy could incorporate from forth or vice versa?
15:58:22 <chipChuck> I glanced at Joy
15:58:56 <chipChuck> Couldn't really comment
15:59:15 <chipChuck> Many macro languages substitute text and interpret it
15:59:34 <chipChuck> That isn't the way Forth macros work
15:59:50 <chipChuck> They actually do the action, rather than postpone it
16:00:14 <futhin>  *water* what about the fact that it works nice and algebraically?
16:00:25 <chipChuck> I see no advantage to manipulating the text instead of getting on with the job
16:00:44 <chipChuck> By algebraically, you mean infix?
16:00:48 <futhin> yes i think so
16:00:58 <chipChuck> That just means they did it the hard way
16:01:16 <futhin> er
16:01:17 <chipChuck> Forth can, and has, implemented infix. Many times
16:01:24 <chipChuck> It's a dead end
16:01:34 <futhin> algebraically wasn't meant as infix..
16:01:43 <futhin> <water> joy has lists as code closures and can do things with the stack based on them
16:02:02 <chipChuck> Ok. Out of my depth

16:02:28 <futhin> <i440r> what forths other than your own have you used?
16:02:48 <chipChuck> There was one
16:03:01 <chipChuck> What preceeded Win32?
16:03:04 <I440r> fpc
16:03:10 <chipChuck> Right
16:03:17 <I440r> tom zimmer - isforth is loosly based on fpc
16:03:20 <I440r> loosly
16:03:26 <chipChuck> It was very frustrating. I kept wanting to change things
16:03:36 <chipChuck> But I hadn't a Forth for the PC
16:03:48 <chipChuck> Now, with colorForth, I feel no urge
16:03:49 <futhin> chipChuck:  i440r would like you to check out his forth at http://isforth.clss.net  ;)
16:03:58 <I440r> lol
16:04:25 <chipChuck> Noted

16:04:42 <futhin> ok, a side question
16:05:22 <futhin> would you consider being a semi regular visitor to the channel, on an informal basis? :)
16:05:29 <futhin> or doing this event in the future?
16:05:37 <futhin> people are wondering :)
16:06:12 <futhin> informal..  unannounced and unplanned
16:06:14 <chipChuck> Sure. Could do it again. Won't you run out of questions?
16:06:24 <futhin> not running out of questions at the moment
16:06:39 <I440r> never :)
16:07:05 <chipChuck> I'd like more opinions from you-all
16:07:25 <I440r> then maybe we should set mode -m on the channel ?
16:07:48 <I440r> a non chaotic (i hope) free for all ?
16:07:51 <futhin> i have quite a handful of questions still to be asked, but that could be dealt with another time..
16:08:23 <futhin> up to you if you want to continue this way for a bit more?
16:08:51 <chipChuck> For a little while. The sun's coming onto my screen
16:08:58 <futhin> i was hoping to finish things up with a -m and everybody being able to talk..
16:09:30 <chipChuck> go

16:09:32 <futhin> goshawk`: what inspired you to focus on hardware, and what background did you have up until that point that allowed him to make that move?
16:09:51 <chipChuck> I considered software a solved problem
16:10:07 <chipChuck> All my trouble with read-time systems were with the hardware
16:10:22 <chipChuck> No background. Just determination

16:10:30 <futhin> <kc5tja> When designing the first x21 processor (i21??), by what process did you arrive at the initial 27 opcodes for the machine?  Software simulations and statistical profiling?
16:10:54 <chipChuck> Seat of pants
16:11:09 <chipChuck> Paring down the Forth primitives till I had a managable set
16:11:32 <chipChuck> My guesses corresponded well with others profiling
16:11:33 <chipChuck> over
16:11:50 <futhin> <geakazoid> What is the status of Chuck & Jeff's work on parrallel processing?
16:12:05 <chipChuck> The 25x is unfunded
16:12:24 <chipChuck> I could fund a prototype, but without funding, where's the market

16:13:25 <futhin> <wtanksley> colorForth interests me greatly -- one thing which occurs to me about it is that because you change the editor rather than the language when you add new syntax, it would be reasonable to extend the editor _greatly_ when you add new syntax, for example by creating a table widget to handle a state machine definition (q.v. Noble's FSM definition words). Would you consider that a proper use?
16:14:05 <chipChuck> Yes
16:14:30 <chipChuck> The ability to change the tag table leads to many interesting applications
16:14:44 <chipChuck> I only hope that 16 tags is enough

16:15:12 <futhin>  *mlg* chipchuck - as to parallel processing, does something already work? What approach do you use to distribute computation across processes?
16:15:47 <chipChuck> I would distribute functionally
16:16:07 <chipChuck> For example, one processor would accept seial input
16:16:16 <chipChuck> Another would process PPP
16:16:26 <chipChuck> Another would process IP
16:16:36 <chipChuck> Another would process TCP
16:16:45 <chipChuck> Someone would eventually do the application
16:16:47 <chipChuck> over

16:17:19 <futhin>  *BigBoyToddy* The 25x is a great design from what I can tell, if it could be funded via selling kits, marketing it to end users, what would the numbers be to get it into production?
16:17:53 <chipChuck> VCs rightly demand a marketing plan
16:18:21 <chipChuck> My last guess was $200K for 2 prototype runs over 9 months
16:18:36 <chipChuck> Then $100K for production
16:19:02 <chipChuck> Add to that, kit design and production, programming, documentation\
16:19:22 <chipChuck> Marketing, support. It's not cheap
16:19:39 <chipChuck> Requires a commitment no one has made


16:20:13 <futhin> you said you wanted opinions..  have any questions to ask us? :)
16:20:29 <chipChuck> What's the future of Forth?
16:20:37 <futhin> hm
16:20:43 <futhin> maybe we should come back to that later heh
16:20:45 <futhin> sorry
16:20:50 <futhin> when everyone is -m 

16:21:13 <futhin>  <alephnull> "Thanks, I'll make the Ethernet/UDP code available at next website update." (--Chuck Moore, from the ColorForth mailing list on Apr. 14) Q: Could you briefly describe how the Ethernet/UDP code is coming along? 

16:21:20 <chipChuck> How many of you are using Forth?
16:21:21 <futhin> we're running out of questions now
16:21:36 * I440r uses forth
16:21:39 <futhin> so i think the closing will be soon..
16:21:49 <futhin> ok
16:21:49 <chipChuck> How can we tabulate opinions?
16:21:51 <I440r> well. im writing one for linux
16:22:02 <futhin> one last question
16:22:05 <futhin> and then we'll go to
16:22:10 * chipChuck sees sun coming round
16:22:28 <futhin> the "what's the future of forth?" question

16:22:38 <futhin> <shapr> ChipChuck - do you have any suggestions for new directions to explore in computing?
16:23:13 * futhin apologizes to all profusely if he is handling this poorly..
16:23:22 <chipChuck> Yes, but that's a long answer
16:23:30 <chipChuck> You're doing great
16:24:10 <chipChuck> I'm exploring parallel computing
16:24:37 <chipChuck> With very small. very fast computers
16:24:58 <chipChuck> That's 64 word of ROM, 128 words of RAM, 2400 Mips
16:25:14 <chipChuck> They can't do much, but can do it very fast
16:25:21 <I440r> are you giving each processor specific types of task or does the next instruction/task go to the first available processor ?
16:25:35 <chipChuck> With this, I hope to explore some hard problems
16:25:43 <chipChuck> More next time
16:26:27 <chipChuck> Processor tasks are programmer assigned
16:26:39 <chipChuck> Partly dependent on unique processor capabilities
16:27:00 --- quit: WFR ()
16:27:03 <chipChuck> There are 25 independent instruction streams
16:27:28 <chipChuck> 63,000 Mips total, programmable
16:27:35 <I440r> wow
16:27:36 <chipChuck> Nice programming problem
16:27:48 <I440r> when you have that on a pc based machine ill be a beta tester for you :)
16:27:49 <chipChuck> 500 mW
16:28:09 <chipChuck> I can simulate a few of them
16:28:10 <chipChuck> over
16:28:28 <futhin> i've got 5 to 10 more questions..  all of them good
16:28:37 <futhin> it's ok to continue?
16:28:56 <chipChuck> It's getting too bright
16:29:07 <chipChuck> Let's schedule a repeat
16:29:17 <chipChuck> Guess that's reprise
16:29:17 <futhin> ok then
16:29:37 <futhin> so when are you thinking of repeating this event?
16:30:15 * chipChuck thinking
16:30:42 <chipChuck> My wife says the 18th is good
16:31:02 <futhin> okay then
16:31:25 <futhin> <MrReach> may I suggest that chipChuck buy some blinds for his window?
16:31:33 <chipChuck> Enjoyed talking to you
16:31:42 <futhin> yes, let's continue next time
16:31:48 <futhin> and we'll make it more open-forum
16:31:52 <futhin> and you can ask us
16:31:56 <futhin> questions