comp.lang.forth Frequently Asked Questions (1/6): General/Misc <author> <htmlurl url="" name="M. Anton Ertl">, <htmlurl url="" name=""> <toc> <sect> Acknowledgements <p> This FAQ is based on previous work by Gregory Haverkamp, J. D. Verne, and Bradford J. Rodriguez. <sect> comp.lang.forth FAQs <p> The comp.lang.forth FAQ is published in seven parts, corresponding to these seven sections. This part is the <em>General/Misc</em> FAQ, where the questions not covered in the other FAQs are answered. The parts are: <itemize> <!--prevent line breaks in urls; new sgml-tools?--> <item><url url="" name="General questions"> <item><url url="" name="Online resources"> (no longer maintained, most links broken). <item><url url="" name="Forth vendors"> <item><url url="" name="Forth systems"> <item><url url="" name="Books, periodicals, tutorials"> <item><url url="" name="Forth groups & organizations"> <item><url url="" name="ANS Forth"> </itemize> You can get the text versions of these FAQs at <url url="">. <p> These FAQs are intended to be a brief overview of the tools and information available for the new FORTHer. For a historical reference, programming paradigms, and deep technical information try some of the listed references. For general questions on the Usenet, or the methods used to get this information, try these other Usenet groups: <!-- !!make newsgroups htmlurls --> <itemize> <item>news.announce.newusers <item>news.newusers.questions <item>news.announce.important </itemize> <sect> General Questions <sect1> What is Forth? <p> Forth is a stack-based, extensible programming language without type-checking. It is probably best known for its "reverse Polish" (postfix) arithmetic notation, familiar to users of Hewlett-Packard calculators: to add two numbers in Forth, you would type 3 5 + instead of 3+5. The fundamental program unit in Forth is the "word": a named data item, subroutine, or operator. Programming in Forth consists of defining new words in terms of existing ones. The Forth statement <code> : SQUARED DUP * ; </code> defines a new word <tt>SQUARED</tt> whose function is to square a number (multiply it by itself). Since the entire language structure is embodied in words, the application programmer can "extend" Forth to add new operators, program constructs, or data types at will. The Forth "core" includes operators for integers, addresses, characters, and Boolean values; string and floating-point operators may be optionally added. <sect1> How does Forth differ from other languages? <p> Forth offers the following features: <itemize> <item>interactivity <item>low-level-ness (for hardware access and speed) <item>extensibility to higher levels <item>potential for very low resource consumption (down to 448 bytes, including multitasking) <item>no division between compile-time and run-time (e.g., full language power in macros, run-time code generation) <item>no type checking (yes, that's a feature) <item>very simple syntax: programs are just sequences of words <item>no syntactic difference between built-in and user-defined words (indeed, it is possible to redefine built-in words, e.g., for extension purposes) <item>programmer-visible stack </itemize> Other languages provide some of these features, but none provides all of them. Joe Knapka has written a <url url="" name="Welcome to Forth">, which discusses some of the differences between Forth and other languages in more detail. <sect1> Where does the name Forth come from? <p> <quote> The name FORTH was intended to suggest software for the fourth (next) generation computers, which Moore saw as being characterized by distributed small computers. The operating system he used at the time restricted file names to five characters, so the "U" was discarded. FORTH was spelled in upper case until the late 70's because of the prevalence of of upper-case-only I/O devices. The name "Forth" was generally adopted when lower case became widely available, because the word was not an acronym. </quote> Rather, Colbourn, and Moore: <url url="" name="The Evolution of Forth">, in: History of Programming Languages (HOPL-II), ACM Press/Addison-Wesley 1996. <p>Note: Forth is not a 4GL (language for programming database applications). <sect1> Why and where is Forth used? <p> Although invented in 1970, Forth became widely known with the advent of personal computers, where its high performance and economy of memory were attractive. These advantages still make Forth popular in embedded microcontroller systems, in locations ranging from the Space Shuttle to the bar-code reader used by your Federal Express driver. Forth's interactive nature streamlines the test and development of new hardware. Incremental development, a fast program-debug cycle, full interactive access to any level of the program, and the ability to work at a high "level of abstraction," all contribute to Forth's reputation for very high programmer productivity. These, plus the flexibility and malleability of the language, are the reasons most cited for choosing Forth for embedded systems. <sect1>Hang on, isn't Forth out of date now? <p>One of the best answers came from <url url="" name="Brad Rodriguez">. You can find the full version at <url url="">. In short, Forth's advantages are that it's comprehensible, small, interactive, fast, extensible, and makes it easy to work at a high level of abstraction. <p>BTW, this question came from someone comparing a 10+ year old Forth system with the latest version of Borland C++. His system was really out of date, but also with respect to current Forth systems. <sect1> Is Forth faster or smaller than C? <p> Not in itself. I.e., if you translate a C program literally into Forth, you will see a slow-down (e.g., a factor 4-8 with Gforth 0.5, a threaded-code system; for typical native-code systems you will see a factor of 1-3). Similarly, there is no inherent size advantage in Forth. For details see <url url="">. <p>However, there are many reports of cases where Forth programs beat others in size and/or speed. My guess is that the added flexibility of Forth helps programmers produce faster and/or smaller programs. <sect1> What language standards exist for Forth? <p> An American National Standard for Forth, ANSI X3.215-1994, is accepted worldwide as the definitive Forth standard ("ANS Forth"). This standard also has been blessed as international standard (ISO/IEC 15145:1997). <p> IEEE Standard 1275-1994, the "Open Firmware" standard, is a Forth derivative which has been adopted by Sun Microsystems, HP, Apple, IBM, and others as the official language for writing bootstrap and driver firmware. See <url url="">. <p> Prior Forth standards include the Forth-83 Standard and the Forth-79 Standard issued by the Forth Standards Team. The earlier FIG-Forth, while never formally offered as such, was a de facto "standard" for some years. <p> "FORTH STANDARDS Published standards since 1978 are Forth 79 and Forth 83 from the Forth Standard Team, and ANS Forth - document X3.215-1994 - by the X3J14 Technical Committee. The most recent standard, ANS Forth, defines a set of core words and some optional extensions and takes care to allow great freedom in how these words are implemented. The range of hardware which can support an ANS Forth Standard System is far wider than any previous Forth standard and probably wider than any programming language standard ever. See web page <url url=""> for latest details. Copies of the standard cost $193, but the final draft of ANS Forth is free and available (subject to copyright restrictions) via ftp..." --Chris Jakeman, <p> The (un)official ANS Forth document is available in various formats at <url url=""> and at <url url="">. The format I like best is the <url url="" name="HTML version">. <p> To get yourself on the ANS-Forth mailing list, consult the various README files at <url url="">. <p> Two unofficial test suites are available for checking conformance to the ANS Standard Forth: <itemize> <item> John Hayes has written a test suite to test ANS Standard Systems (available through <url url="">). <item> JET Thomas has written a test suite to test ANS Standard Programs: <url url=""> </itemize> <p>There is also an <url url="" name="ANS Forth FAQ"> that explains the standardization process. <sect1> What is an RFI? <p>A Request For Interpretation. If you find something in the standard document ambiguous or unclear, you can make an RFI, and the TC (technical committee), that produced the standard, will work out a clarification. You can make an RFI by mailing it to <htmlurl url="" name=""> and labeling it as RFI. The answers to earlier RFIs are available at <htmlurl url="" name="">. They are also integrated in the <url url="" name="HTML version of the standard">. <sect1> Are there Coding Standards for Forth? <p> Leo Brodie's book <em>Thinking Forth</em> gives some advice; a short excerpt is now available <url url="" name="online">. Forth shops have rules for their coding. Paul Bennet has published those of his company; you can find them on <url url="">. <sect1> I have trouble managing the stack. Should I use global VARIABLEs? <p> No. There are better alternatives: <itemize> <item>Keep on trying to use the stack. Reorganize (refactor) your words. One day you will get the knack for it. <url url="" name="Elizabeth Rather"> writes: <quote> The basic skill required for comfortable, efficient Forth programming is good stack management. It's hard for newcomers to learn, since it isn't a skill required in other languages, which all require the use of variables for practically everything. Having taught literally hundreds of courses over the last 25 years, I've seen newcomers wrestle with this, and have developed exercises (similar to those in Starting Forth) to help. It seems to be a skill rather like riding a bicycle: wobbly & scary at first, then suddenly a "switch is thrown" in the brain and it seems comfortable and natural ever after. </quote> Andrew Haley writes in <htmlurl url="" name="Message-ID: <7k8lln$q3c$>">: <quote> Try writing all of your code using definitions one, or at most two lines long. Produce a stack digram for each word showing its inputs and its outputs. If you ever need an "intermediate" stack diagram to see what's going on, split your word at that point into two words. By doing this, you may test each half of the word on the command line, checking the stack each time. Do not use PICK and ROLL. <p>Once you get the hang of writing code in this way you can relax these rules, but it's much better to get used to this style first. </quote> <item>Use the return stack. <item>Use locals. <item>Use data structures in memory, and pass pointers to it on the stack. <item>One area that has been mentioned often as troublemaker is graphics programming. Take a look at how Postscript handles this: They do indeed have a global state to avoid stack management problems, but you can access this state only through certain words. </itemize> <sect1> What is the Forth Interest Group? <p> The Forth Interest Group "FIG" was formed in 1978 to disseminate information and popularize the Forth language, and it remains the premier organization for professional Forth programmers. FIG maintains a Web page at <url url="">, with a more complete introduction to the Forth language, and links to the Web pages of many Forth vendors. <!-- Q: What Forth libraries are available, and how can I access them? A: There are several online repositories of Forth programs, sources, executables, and so on. These various repositories are NOT identical copies of the same things. Material is available on an AS-IS basis due to the charity of the people involved in maintaining the libraries. See the "online" FAQ (part 2 of 6) for a complete listing of online Forth resources. You can get free- and share-ware Forths for various platforms at: a.k.a. Various Forths, code, and home of the forth scientific library; this is the official library site of the Forth Interest Group. ( is currently an alias for -bjr) A mirror for the taygeta site. " FTP site in Portugal devoted to Forth, which contains a mirror of the FIG library on GEnie, plus whatever anyone has donated. The archive is run by Paulo A. D. Ferreira who has donated the resources for it." Gregory Haverkamp Various Forths and code. A SIMTEL (MS-DOS software) mirror. "...there is a subdirectory /pub/forth/ that has on it. There are TWO Forths included, F-PC 3.56 and eForth. Download it via ftp and don't forget to say 'binary' first!" Julian V. Noble FIG used to maintain a software library on the GEnie service, and you can still find some older files there. You'll need a GEnie account; look for the FORTH Roundtable. -bjr --> <sect1> Who is Chuck Moore and what is he doing? <p> <htmlurl url="" name="Chuck Moore"> discovered (as he puts it) Forth (for historical information read <url url="" name="The Evolution of Forth">). He later went on to apply his design philosophy to hardware design and designed a number of processors well-suited for executing Forth: Novix 4016, Shboom, uP20, uP21, F21, i21, ... <p>He also explored new ideas and refined his earlier ideas on software and Forth: his cmForth for the Novix has been quite influential. His latest developments are Machine Forth and Color Forth. <p>Machine Forth is a simple virtual machine consisting of 27 instructions. It is implemented in hardare in uP21 and the following chips, but has also been implemented in software on the 386 as simple native-code system. Some of the differences from ANS Forth are that each stack entry contains an extra carry bit, and that there is register A for accessing memory (instead of addressing through the top of stack). <p><htmlurl url="" name="Color Forth">'s most obvious feature is that it uses colour in syntactically significant ways. You can now <url url="" name="download it"> and run it out on modern PCs. <p>You can find out more about Chuck Moore at <url url="" name="his site"> and at <url url="" name="Jeff Fox' site">.</p> <sect1>When I redefine a word, old uses refer to the old definition. How do I ...? <p>That behaviour is known as early binding (of names), and it is a feature: E.g., name collisions are mostly harmless in Forth, unlike most other languages. <p>So how do I change a word during debugging? The typical approach is to completely reload the program; the memory for the old version is usually reclaimed either by exiting and restarting the system, or by using MARKERs. Since Forth systems start up and compile very fast (in the 0.1s ballpark), that does not break the workflow. <p>And how do I implement mutual recursion? How do I implement words that change behaviour? You use <htmlurl url="" name="deferred words">. <sect>Flame baits <p>Some statements spawn long and heated discussions where the participants repeat their positions and ignore the arguments of the other side (flame wars). You may want to avoid such statements. <p>Here, I present some regularly appearing flame baits and the positions you will read (so you don't have to start a flame war to learn them). <sect1>Commercial vs. free Forth systems <p>"You get what you pay for. With a commercial Forth you get commercial documentation and support. We need commercial Forth systems or Forth will die." <p>"I have had good experiences with free Forths. I cannot afford a commercial Forth system. I want source code (some commercial vendors don't provide it for the whole system). Examples of bad support from commercial software vendors. Without free Forth systems Forth will die." <sect1>Free Forth systems are bad for Forth. <p>"Anyone can write a bad Forth and give it away without documentation or support; after trying such a system, nobody wants to work with Forth anymore. Free Forths give Forth a bad name. Free Forths take business away from the vendors." <p>"Many people learned Forth with fig-Forth. There are good free Forths. Most successful languages started with (and still have) free implementations. Languages without free implementations (like Ada, Eiffel and Miranda) are not very popular [There are free Ada and Eiffel implementations now]." <sect1>Blocks vs. files <p>The discussions on this topic are much cooler since Mike Haas has dropped from comp.lang.forth. <p>"Everyone is using files and all third-party tools are designed for files. Files waste less space. Blocks lead to horizontal, unreadable code. Blocks make Forth ridiculous." <p>"We are not always working under an operating system, so on some machines we don't have files. We have very nice block editors and other tools and coding standards for working with blocks (e.g., shadow screens)." <sect1>LOCALS| <p> Everyone who mentions using <tt>LOCALS|</tt> gets the following flame from me: <p> <tt>LOCALS|</tt> is bad because the locals are ordered contrary to the stack comment convention. I.e.: <code> : foo ( you can read this -- ... ) LOCALS| this read can you | ... ; </code> The following locals syntax is better and widely used: <code> : foo { you can read this -- ... } ... ; </code> You can find an implementation of this syntax in ANS Forth at <url url=""> <sect1>Type-checking and Overloading <p> "Static type checking allows catching bugs early. Overloading makes code more readable. Many other languages use type-checking and overloading to various extents." <p>"Type errors are caught early in testing even without type checking; they are not a problem in practice. Type-checking may seduce the programmer to do less testing. Type-checking sometimes gets in the way. Overloading makes code harder to read, and especially harder to debug. Overloading is error-prone, because it is easy to read the code differently than the compiler. Overloading sometimes gets in the way. Typechecking and overloading require more complexity in the compiler, with various other negative consequences. Forth offers facilities like <tt>execute</tt> and run-time code generation and it allows building your own object-oriented system (etc.); these features would be hard or impossible to achieve with static type checking. Dynamic type-checking costs run-time." <sect>Miscellaneous <sect1>Where can I find a C-to-Forth compiler? <p><url url="" name="Parag Patel"> writes: <!-- posting msg-id: <7e3msl$a68$>--> <quote> We, (<url name="CodeGen, Inc." url="">) sell a C-to-Fcode compiler. Well, it actually generates IEEE-1275 Forth that then must be run through a tokenizer.<p> Really, it generates pretty ugly Forth code. It's easy to generate lousy Forth, but it's very difficult to generate nice clean optimized Forth. C and stack-based languages don't mix too well. I end up faking a C variable stack-frame using a Forth $frame variable for local vars. </quote> <p> <url url="" name="Stephen Pelc"> writes: <quote> MPE has produced a C to stack-machine compiler. This generates tokens for a 2-stack virtual machine. The code quality is such that the token space used by compiled programs is better than that of the commercial C compilers we have tested against. This a consequence of the virtual machine design. However, to achieve this the virtual machine design has local variable support.<p> The tokens can then be back end interpreted, or translated to a Forth system. The translater can be written in high level Forth, and is largely portable, except for the target architecture sections.<p> These are not shareware tools, and were written to support a portable binary system. </quote> <sect1>Where can I find a Forth-to-C compiler? <p> An unsupported prototype Forth-to-C compiler is available at <url url="">. It is described in the EuroForth'95 paper <url url="">. Another Forth-to-C compiler is supplied with <url url="" name="Rob Chapman's"> <url url="" name="Timbre"> system. <sect1>RECORDS in Forth? <p> Many packages for data structuring facilities like Pascal's RECORDs and C's structs have been posted. E.g., the structures of the Forth Scientific Library (<url url="">) or the structures supplied with Gforth <url url="">. <sect1>Why does THEN finish an IF structure? <p> Some people find the way THEN is used in Forth unnatural, others do not. According to <em>Webster's New Encyclopedic Dictionary</em>, "then" (adv.) has the following meanings: <quote> ... 2b: following next after in order ... 3d: as a necessary consequence (if you were there, then you saw them). </quote> Forth's THEN has the meaning 2b, whereas THEN in Pascal and other programming languages has the meaning 3d. <p> If you don't like to use THEN in this way, you can easily define ENDIF as a replacement: <code> : ENDIF POSTPONE THEN ; IMMEDIATE </code> <sect1>What is threaded code? What are the differences between the different threading techniques? <p> Threaded code is a way of implementing virtual machine interpreters. You can find a more in-depth explanation at <url url="">. <sect1>Has anyone written a Forth which compiles to Java bytecode? <p> <url url="" name="Paul Curtis"> writes: <p> The JVM, although a stack machine, can't really be used to compile Forth efficiently. Why? Well, there are a number of reasons: <itemize> <item> The maximum stack depth of a called method must be known in advance. [JVM Spec, p. 111]</> <item> JVM methods can only return a single object to the caller. Thus, a stack effect ( n1 n2 -- n3 n4 ) just isn't possible.</> <item> There is no direct support for unsigned quantities.</> <item> CATCH and THROW can't be resolved easily; you need to catch exceptions using exception tables. This doesn't match Forth's model too well. [JVM Spec, p. 112]</> <item> You'd need to extend Forth to generate the attributes required for Java methods.</> <item> There is no such thing as pointer arithmetic.</> <item> You can't take one thing on the stack and recast it to another type.</> <item> You can't manufacture objects out of raw bytes. This is a security issue.</> <item> There is no support for the return stack.</> </itemize> That said, it is possible to write something Forth-like using JVM bytecodes, but you can't use the JVM stack to implement the Forth stack. ... <p>If you're serious, try getting Jasmin and programming directly on the JVM. <sect1>What about translating Java bytecode to Forth? <p> Some of the non-trivial pieces in translating JavaVM to Forth, that we have identified, are: <itemize> <item> garbage collection <item> threads <item> control structures (branches->ANS Forth's seven universal control structure words) <item> exceptions <item> subroutines (JavaVM does not specify that a subroutine returns to its caller) <item> JavaVM makes the same mistake as Forth standards up to Forth-83: It specifies type sizes (e.g., a JavaVM int is always 32-bit). A few operators have to be added to support this. <item> The native libraries (without them JavaVM can do nothing). </itemize> <sect1>How is Postscript related to Forth? <p> Postscript is similar to Forth in having a data stack, being interactive, and supporting wordlists. Postscript differs from Forth in using run-time name binding, run-time typing for type-checking and overloading resolution, implementing control structures through words that take anonymous definitions as parameters, in terminology (I have used Forth terminology here), and in other respects. <p> Concerning the question of whether Forth influenced Postscript, the Postscript manual (first edition) claims that Postscript and its predecessors were conceived and developed independently of Forth. However, also <url url="" name="according to John Warnock"> Postscript's "syntax looks a little bit like Forth, because it is derived from Forth". Jim Bowery's <url url="" name="Genesis of Postscript"> mentions Forth. <sect1>How about running Forth without OS? <p> A Forth system running on the bare hardware is also known as a native system (in contrast to a hosted system, which runs on an OS). Don't confuse this with native-code systems (which means that the system compiles Forth code to machine code); hosted native-code systems exist as well as native threaded-code systems. <p> In the beginning Forth systems were native and performed the functions of an OS (from talking to hardware to multi-user multi-tasking). On embedded controllers Forth systems are usually still native. For servers and desktops most Forth-systems nowadays are hosted, because this avoids the necessity to write drivers for the wide variety of hardware available for these systems, and because it makes it easier for the user to use both Forth and his favourite other software on the host OS. A notable exception to this trend are are the native systems from Athena. <sect1>How about writing an OS in Forth? <p> Native Forth systems can be seen as OSs written in Forth, so it is certainly possible. Several times projects to write an OS in Forth were proposed. Other posters mentioned the following reasons why they do not participate in such a project: <p>If you want to write an OS in Forth for a desktop or server systems, the problems are the same as for native Forth systems (and any other effort to write a new OS): the need to write drivers for a wide variety of hardware, and few applications running on the OS. <p>To get around the application problem, some posters have suggested writing an OS that is API or even ABI compatible with an existing OS like Linux. If the purpose of the project is to provide an exercise, the resulting amount of work seems excessively large; if the purpose is to get an OS, this variant would be pretty pointless, as there is already the other OS. And if the purpose is to show off Forth (e.g., by having smaller code size), there are easier projects for that, the compatibility requirement eliminates some of the potential advantages, and not that many people care about the code size of an OS kernel enough to be impressed. <sect1>What is a tethered/umbilical Forth system? <p> A tethered Forth system is a cross-development environment where the host and the target are connected at run-time (during development), allowing full interactive use of the target system without requiring all the space that a full-blown Forth system would require on the target. E.g., the headers can be kept completely in the host. Tethered systems may also provide the compilation speed and some of the conveniences of a full-blown Forth system on the host. <p>Tethered systems are also called umbilical systems. <sect1>How about interpreting by compiling and immediately executing? <p> Such ideas have been proposed several times, to allow using control structures interpretively, among other benefits. It has also been implemented in some systems (e.g., Christophe Lavarenne's Free-Forth). In most proposals a line would be compiled and then executed. <p>However, such systems behave quite differently from ordinary Forth systems in some respects, in particular when dealing with parsing words. E.g., consider: <code> ' + . : my-' ' ; my-' + . </code> <p>In classical Forth <tt>'</tt> parses <tt>+</tt> in both cases. This behaviour is hard to achieve in a compile-then-execute Forth system, unless it works a word at a time, but then it would have none of the benefits, either. <sect1>Why does a decimal point not indicate floating-point? <p> In the old days Forth did not have floating-point numbers; instead, fixed-point arithmetic was used, usually on double-cell numbers. So, a decimal point indicated a double number (the position of the decimal point was stored in the variable <tt>DPL</tt> for potential use by fixed-boint software). <p>In ANS Forth, a decimal point at the end indicates a double-cell number, and an E in the number indicates a floating-point number (when <tt>BASE</tt> is decimal). <p>All other ways to write numbers are system-dependent. However, most systems still interpret decimal points within a number as indicating double-cell numbers. <sect1>eForth: Who wrote it, and how do the versions differ? <p> <htmlurl url="" name="eForth"> was written by Bill Muench, and was originally metacompiled. On request from C. H. Ting he also produced a version that was written in MASM, and had many words removed (the user should add them back in as an educational exercise). <sect1>Why is there a separate stack for FP? <p> More specifically, why do we put doubles, addresses, string descriptors etc. on the data stack? Why not FP values as well? <itemize> <item> There is little overlap between integer and FP operations, basically just the data-movement stuff @ ! DUP SWAP etc. By contrast, we use, e.g., +, -, and u< on signed and unsigned integers, and on addresses, and being able to access the individual cells of doubles allows implementing various more refined operations (e.g., triple-cell integers in M*/). Having the individual cells of a c-addr u string descriptor accessible is the foundation for a number of string operations, e.g., checking whether a string is a prefix of another string. If we put these data on separate stacks, we would have to introduce and then use all kinds of words for transfering cells between these stacks; that's not the case for FP data. <item> How many cells should an FP value have on the data stack? 1? 2? 4? None of these answers is good for all systems. Or maybe an FP value should be an opaque type with an unspecified size? Then you cannot access anything below it. <item> FP hardware usually works on separate FP registers, and transfers between FP registers and integer registers are often pretty expensive (sometimes they require a memory store and memory load). Many Forth systems keep the top-of-data-stack in an integer register. On such a system with a shared integer+FP-stack an FP operation would imply a move from the integer registers to the FP registers and back. By contrast, with a separate FP stack, the system can keep the top-of-FP-stack in an FP register. On the 387 the whole Forth FP stack is often kept in the 387 FP stack. </itemize> <!-- <sect1>Case sensitivity issues --> <sect>Newsgroup-specific questions <sect1>How can I read and post to comp.lang.forth? <p> The usual way is to use a newsreader and an NNTP server. If your internet provider does not offer you access to a good NNTP server, you might consider switching providers. There is also a free (registration required) NNTP server: <htmlurl url="" name="">. <p>Once you have access to an NNTP server, you can use a wide variety of newsreaders. You should consider using one that has passed the <url url="" name="GNKSA"> test, as such newsreaders can help you to avoid a number of errors when posting (even if you don't want to post right now, you probably don't want to have to change the newsreader if you ever decide to post). <p>Even with a good newsreader, you should make test postings to a test group (e.g., misc.test) before posting to discussion groups like comp.lang.forth. Also, check your test postings; not with your newsreader, as it tends to hide its own errors; try the "Show original" button of <url url="" name="Google groups"> or <url url="" name="use telnet">. <p>Not only your newsreader should be well-behaved, you should be as well. Most people will do ok if they read the newsgroup they want to post to for a while before posting (note that different newsgroups can have different cultures). If you want to learn more, read the <url url="" name="Netiquette">, <htmlurl url="news:news.newusers.answers" name="news.newusers.answers">, about <url url="" name="smart questions">, or about avoiding <url url="" name="common mistakes">. <p>As a poor alternative to an NNTP server, you can also use <htmlurl url="" name="Google Groups">. </article>