Forth is a procedural, stack-oriented, reflective programming language and programming environment. It was initially developed by Charles H. Moore at the US National Radio Astronomy Observatory in the early 1970s, formalized as a programming language in 1977, and standardized by ANSI in 1994. It features both interactive execution of commands (making it suitable as a shell for systems that lack a more formal operating system), as well as the ability to compile sequences of commands for later execution. Some Forth versions (especially early ones) compile threaded code, but many implementations today generate optimized machine code like other language compilers. Procedural programming is a programming paradigm based upon the concept of the procedure call. ... A stack-oriented programming language is one that relies on a stack machine model for passing parameters. ... In computer science, reflection (or computational reflection) is the ability of a program to observe and possibly modify its structure and behavior. ... Computer code (HTML with JavaScript) in a tool that uses syntax highlighting (colors) to help the developer see the purpose of each piece of code. ... Charles H. Moore (also known as Chuck Moore) is the inventor of the Forth programming language. ... The National Radio Astronomy Observatory (NRAO) is an institution set up by the United States government for the purpose of radio astronomy. ... The 1970s decade refers to the years from 1970 to 1979, inclusive. ... For the album by Ash, see 1977 (album). ... The American National Standards Institute (ANSI) is a private, non-profit standards organization that produces industrial standards in the United States. ... 1994 (MCMXCIV in Roman) was a common year starting on Saturday of the Gregorian calendar, and was designated the International year of the Family. ... It has been suggested that this article or section be merged into Shell_(computing). ... An operating system is a program required for the user to manage the system and to run third-party application software for that system. ... A diagram of the operation of a typical multi-language compiler. ... In computer science, the term threaded code refers to an implementation technique for programming languages that produces very compact code. ... Compiler optimization techniques are optimization techniques that have been programmed into a compiler. ... A system of codes directly understandable by a computers CPU is termed this CPUs native or machine language. ...

Forth is so named because Moore considered it appropriate for fourth-generation computers (i.e. microcomputers), and the system on which he developed it was limited to five-letter filenames. Although the name is not an acronym, it is sometimes spelled in all capital letters, following the customary usage during its earlier years. Charles H. Moore (also known as Chuck Moore) is the inventor of the Forth programming language. ... The Commodore 64 was one of the most popular microcomputers of its era, and is the best selling home computer of all time. ...

Overview

Forth offers a standalone programming environment consisting of a stack-oriented, interactive, incremental interpreter and compiler. Programming is done by extending the language with words (the term used for Forth subroutines), which become part of the language once defined. A stack-oriented programming language is one that relies on a stack machine model for passing parameters. ... An interpreter is a computer program that executes other programs. ... A diagram of the operation of a typical multi-language compiler. ... In computer science, a subroutine (function, procedure, or subprogram) is a sequence of code which performs a specific task, as part of a larger program, and is grouped as one or more statement blocks; such code is sometimes collected into software libraries. ...

Early versions of Forth were implemented with an inner interpreter tracing indirectly threaded machine code, which yields compact and fast high-level code that can be compiled rapidly. In computer science, the term threaded code refers to an implementation technique for programming languages that produces very compact code. ... A system of codes directly understandable by a computers CPU is termed this CPUs native or machine language. ...

A character-oriented screen/block mechanism and standard editor written in Forth provided a file mechanism for creating and storing Forth source code in the early systems, although today most Forths run under a host operating system and use conventional editors and text files. A source code editor is a text editor program designed specifically for editing source code of computer programs by programmers. ...

A typical Forth package will consist of a pre-compiled kernel of the core words, which the programmer uses to define new words for the application. The application, once complete, can be saved as an image, with all new words already compiled. Generally, programmers will extend the initial core with words that are useful to the sorts of applications that they do and save this as their working foundation.

Forth has been popular for developing embedded systems and instrument controls because it is easy to add small machine code definitions to the language and use those in an interactive high-level programming environment. An embedded system is a special-purpose computer controlled electo-mechanical system in which the computer is completely encapsulated by the device it controls. ...

The logical structure of Forth resembles a virtual machine. It has been implemented efficiently on modern RISC processors, and processors that use Forth as machine language have been produced. The modular extensible nature of Forth permits many high-level applications such as CAD systems to be written in Forth. In general terms, a virtual machine in computer science is software that creates an environment between the computer platform and the end user in which the end user can operate software. ... This article is about the computer architecture. ... In computer science, a stack machine is a model of computation in which the computers memory takes the form of a stack. ... This article is about computer-aided design. ...

Forth is used in the Open Firmware boot ROMs used by Apple, IBM, and Sun Microsystems. It is also used by the FreeBSD operating system as the first stage boot controller. Open Firmware (also, OpenBoot) is a hardware-independent firmware (computer software which loads the operating system), developed by Sun Microsystems, and used in post-NuBus PowerPC-based Apple Macintosh computers, Sun Microsystems SPARC based workstations and servers, IBM POWER systems, and PegasosPPC systems, among others. ... An Internet payphone loading Windows XP In computing, booting is a bootstrapping process that starts operating systems when the user turns on a computer system. ... Apple Computer, Inc. ... International Business Machines Corporation (IBM, or colloquially, Big Blue) NYSE: IBM (incorporated June 15, 1911, in operation since 1888) is headquartered in Armonk, NY, USA. The company manufactures and sells computer hardware, software, infrastructure services and consulting services. ... Sun Microsystems, Inc. ... FreeBSD is a Unix-like free software operating system descended from AT&T UNIX via the Berkeley Software Distribution (BSD) branch through 386BSD and 4. ...

Forth is quick to implement and can be ported at low cost. A skilled programmer with good tools can port Forth to a new computer architecture in as little as two weeks. Porting a familiar computer architecture to a new computer is often much faster because only a few drivers are needed. Even programmers unfamiliar with Forth can use low-quality tools and write a Forth system from scratch in a few months of part-time effort. In computer science, porting is the adaptation of a piece of software so that it will function in a different computing environment to that for which it was originally written. ...

One result has been a proliferation of nonstandard Forth systems by hobbyists, often of indifferent quality and with poor documentation. A newcomer to the language may download a free version from the net, have problems and dismiss the language without further consideration, mistaking a poor implementation for a fundamentally flawed language.

In contrast, professional implementations are rigorously tested (usually with proprietary test suites), conform to published standards, have manuals and telephone support, and often employ sophisticated optimization techniques to ensure excellent run-time performance. High-end professional Forth systems are usually delivered with all source code required to recompile themselves.

See also List of operating systems. It has been suggested that List of Microsoft operating systems be merged into this article or section. ...

Forth from a programmer's perspective

Forth relies heavily on explicit use of the stack data structure and reverse Polish notation (or RPN, also used on advanced calculators from Hewlett-Packard). This notation is also called postfix notation because the operator is placed after its operands, as opposed to the more common infix notation where the operator is placed between its operands. The rationale for postfix notation is that it is closer to the machine language the computer will eventually use, and should therefore be faster to execute. For example, one could get the result of the mathematical expression (25 * 10 + 50) this way: A stack is a data structure that works on the principle of Last In First Out (LIFO). ... Reverse Polish notation (RPN), also known as postfix notation, was invented by Australian philosopher and computer scientist Charles Hamblin in the mid-1950s, to enable zero-address memory stores. ... The Hewlett-Packard Company (NYSE: HPQ), commonly known as HP, is a very large, global company headquartered in Palo Alto, California, United States. ... Infix notation is the arithmetic formula notation known to most people, in which operators are written infix-style between the operands they act on. ...

25 10 * 50 + .
300

This command line first puts the numbers 25 and 10 on the implied stack; the "*" command multiplies the two numbers on the top of the stack and replaces them with their product; then the number 50 is placed on the stack, and the "+" command adds it to the previous product; finally, the "." command prints the result to the user's terminal. Even the language's structural features are stack-based. For example:

 : FLOOR5 ( n -- n' ) DUP 6 < IF DROP 5 ELSE 1 - THEN ; 

This code defines a new word (again, 'word' is the term used for a subroutine) called "FLOOR5" using the following commands: "DUP" simply duplicates the number on the stack; "<" compares the two numbers on the stack and replaces them with a true-or-false value; "IF" takes a true-or-false value and chooses to execute commands immediately after it or to skip to the "ELSE"; "DROP" discards the value on the stack; and "THEN" ends the conditional. The text in parentheses is a comment, advising that this word expects a number on the stack and will return a possibly changed number. The net result is a function that performs similarly to this function written in the Python programming language: Python is an interpreted programming language created by Guido van Rossum in 1990. ...

 def floor5(v): if v < 6: return 5 else: return v - 1 

and similarly to this function written in the C programming language: The C Programming Language, Brian Kernighan and Dennis Ritchie, the original edition that served for many years as an informal specification of the language The C programming language is a standardized imperative computer programming language developed in the early 1970s by Dennis Ritchie for use on the Unix operating system. ...

 int floor5(int v) { return v < 6 ? 5 : v - 1; } 

An even terser Forth definition of FLOOR5 that gives the same result:

 : FLOOR5 ( n -- n' ) 1- 5 MAX ; 

Forth became very popular in the 1980s because it was well suited to the small microcomputers of that time: very efficient in its use of memory and easily implemented on a new machine. At least one home computer, the British Jupiter ACE, had Forth in its ROM-resident OS. The language is still used in many embedded systems (small computerized devices) today for three main reasons: efficient memory use, shortened development time, and fast execution speed. The Commodore 64 was one of the most popular microcomputers of its era, and is the best selling home computer of all time. ... TRS-80 Color Computer II The home computer is a consumer-friendly word for the second generation of microcomputers (the technical term that was previously used), entering the market in 1977 and becoming common during the 1980s. ... The Jupiter ACE was a British home computer of the 1980s, marketed by a company named Jupiter Cantab. ... Read-only memory (ROM) is a class of storage media used in computers and other electronic devices. ... An embedded system is a special-purpose computer controlled electo-mechanical system in which the computer is completely encapsulated by the device it controls. ...

FCode, a Forth dialect, is used for programming the boot loader on Sun SPARC computers. In computing, booting is a bootstrapping process that starts operating systems when the user turns on a computer system. ... Sun Microsystems, Inc. ... Sun UltraSPARC II Microprocessor Sun UltraSPARC T1 (Niagara 8 Core) SPARC (Scalable Processor ARChitecture) is a pure big-endian RISC microprocessor architecture originally designed in 1985 by Sun Microsystems. ...

Forth is also one of the simplest extensible languages. Programmers can easily extend the language with new commands appropriate to the primary programming problem in the particular application area. Unfortunately, extensibility also helps poor programmers to write incomprehensible code, which has caused Forth to acquire a reputation as a "write-only" language. In addition, the ease of implementing Forth on a given processor meant that the barrier to self-development of a Forth system was quite low, so that commercial suppliers were, in effect, competing head-to-head with hobbyists, many of whom supported the idea that software should be free. Free software, as defined by the Free Software Foundation, is software which can be used, copied, studied, modified and redistributed without restriction. ...

Forth has been used successfully in large and complex projects, and applications developed by competent and disciplined professionals have been shown to be easily maintained over decades of use on evolving hardware platforms.

Facilities of a Forth system

Interpreter

At the screen prompt, the user interacts directly with the Forth system, typing sequences of words which are then read and executed by the Forth system. This is the central value of the Forth system: Forth is a very simple way to translate text into computer behavior.

The interpreter uses spaces (some systems accept other whitespace characters, also) to separate "words." When it finds a word, it tries to look the word up in the dictionary and execute the word's code. If that fails, it then tries to convert it into a number and push it onto the stack. If that fails, then it prints the word followed by an error message ( e.g. "not in dictionary" ), and awaits further user input. For information on the programming language Whitespace, see Whitespace programming language. ...

The simplicity of the interpreter is one of the greatest features of Forth.

Compiler

Almost anything that can be typed, can also be compiled and executed automatically and even manually. The compiler uses semantics almost identical to the interpreter, and is also very simple.

Assembler

Most Forth systems include a specialized assembler that produces executable words. Forth assemblers often use a reverse-polish syntax in which the parameters of an instruction precede the instruction. The usual design of a Forth assembler is to construct the instruction on the stack, then copy it into memory as the last step. Registers may be referenced by the name used by the manufacturer, numbered (0..n, as used in the actual operation code) or named for their purpose in the Forth system: e.g. "S" for the register used as a stack pointer. An assembler is a computer program for translating assembly language — essentially, a mnemonic representation of machine language — into object code. ...

Operating System

Classic Forth systems traditionally used no operating system and no dedicated file system. Instead of storing code in files, source-code was stored in disk blocks written to physical disk addresses. Forth systems use a single word "BLOCK" to translate the number of a 1K-sized block of disk space into the address of a buffer containing the data. The buffers are managed automatically by the Forth system. In computing, a file system is a method for storing and organizing computer files and the data they contain to make it easy to find and access them. ...

Most modern Forth systems run under a host operating system such as Microsoft Windows or a version of Unix and use the host operating system's file system for source files. They usually provide a mechanism for issuing calls to the host OS or other resident facilities. Microsoft Windows is a series of popular proprietary operating environments and operating systems created by Microsoft for use on personal computers and servers. ... Wikibooks has more about this subject: Guide to UNIX Unix or UNIX is a computer operating system originally developed in the 1960s and 1970s by a group of AT&T Bell Labs employees including Ken Thompson, Dennis Ritchie, and Douglas McIlroy. ... In computing, a system call is the mechanism used by an application program to request service from the operating system, or more specifically, the operating system kernel. ...

File System

Some classic commercial Forth systems have implemented contiguous disk files, using the Forth operating system's disk access, and placing the files at fixed disk block ranges. Usually the system implements records as fixed-length binary data, with an integer number of records per disk block. Quick searching is achieved by hashed access on key data.

The ANSI standardization effort (1994) added an optional set of commands for managing host OS files.

Multitasking

Some Forth systems feature a multitasker, most commonly a cooperative round-robin scheduler. The word "PAUSE" is used to save the current task's execution context, to locate the next task, and restore its execution context. Each task has its own stacks, private copies of some control variables and a scratch area. Swapping tasks is simple and efficient; as a result, Forth multitaskers are available even on very simple microcontrollers such as the 8051, AVR, and MSP430. In computing, multitasking is a method by which multiple tasks, also known as processes, share common processing resources such as a CPU. In the case of a computer with a single CPU, only one task is said to be running at any point in time, meaning that the CPU is... In computing, multitasking is a method by which multiple tasks, also known as processes, share common processing resources such as a CPU. In the case of a computer with a single CPU, only one task is said to be running at any point in time, meaning that the CPU is... Round-robin is one of the simplest scheduling algorithms for processes in an operating system, which assigns time slices to each process in equal portions and in order, handling all processes as having the same priority. ...

On Forth systems that run under operating systems such as Microsoft Windows or Linux, the Forth system normally utilises the scheduling provided by the operating system. Typically these systems have a larger and different set of words that permit task creation, suspension, destruction and modification of priority. Microsoft Windows is a series of popular proprietary operating environments and operating systems created by Microsoft for use on personal computers and servers. ... Tux is the official Linux mascot. ...

Self (meta) and cross compilation

A full-featured Forth system with all source code will compile itself, a technique commonly called meta-compilation by Forth programmers (although the term doesn't exactly match meta-compilation as it is normally defined). The usual method is to redefine the handful of words that place compiled bits into memory. The compiler's words therefore use specially-named versions of fetch and store that can be redirected to fetch and store to a buffer area in memory. The buffer area simulates or accesses a memory area beginning at a different address than the code buffer. Such compilers define words to access both the target computer's memory, and the host (compiling) computer's memory. Compiling a program takes place by running a compiler on the build platform. ... Metacompilation is a computation which involves metasystem transitions(MST for short) from a computing machine M to a metamachine M which controls, analyzes and imitates the work of M. Semantics-based program transformation, such as partial evaluation and supercompilation (SCP), is metacomputation. ...

After the fetch and store operations are redefined for the code space, the compiler, assembler, etc. are recompiled using the new definitions of fetch and store. This effectively reuses all the code of the compiler and interpreter. Then, the Forth system's code is compiled, but this version is stored in the buffer. The buffer in memory is written to disk, and ways are provided to load it temporarily into memory for testing. When the new version appears to work, it is written over the previous version.

There are numerous variations of such compilers for different environments. For embedded systems, the code may instead be written to another computer over a serial port or even a single TTL bit, while keeping the word names and other non-executing parts of the dictionary in the original compiling computer. The minimum definitions to "remote" a forth compiler are the words that fetch and store a byte, and the word that commands a forth word to be executed. Often the most time-consuming part of a remote port is to construct the initial program to implement fetch, store and execute. Many modern microprocessors have integrated debugging features (such as the Motorola CPU32) that eliminate even this task. An embedded system is a special-purpose computer controlled electo-mechanical system in which the computer is completely encapsulated by the device it controls. ... A Motorola 68000-based computer with various TTL chips. ... The Motorola 683XX aka CPU32 is a family of compatible microcontrollers that use a Motorola 68000 CPU core. ...

Structure of the language

The basic data structure of Forth is the "dictionary" which maps "words" to executable code or named data structures. The dictionary is laid out in memory as a linked list with the links proceeding from the latest (most recently) defined word to oldest, until a sentinel, usually a NULL pointer, is found. In computer science, a linked list is one of the fundamental data structures used in computer programming. ...

A defined word generally consists of head and body with the head consisting of the name field (NF) and the link field (LF) and body consisting of the code field (CF) and the parameter field (PF).

Head and body of a dictionary entry are treated separately because they may not be contiguous. For example, when a Forth program is recompiled for a new platform, the head may remain on the compiling computer, while the body goes to the new platform. In some environments (such as embedded systems) the heads occupy memory unnecessarily. However, some cross-compilers may put heads in the target if the target itself is expected to support an interactive Forth. An embedded system is a special-purpose computer controlled electo-mechanical system in which the computer is completely encapsulated by the device it controls. ...

Dictionary Entry

The exact format of a dictionary entry is not prescribed, and implementations vary. However, certain components are almost always present though the exact size and order may vary. Described as a C language structure, a dictionary entry might look this way:

 struct forthword { byte _flag; /* 3bit flags + length of word's name. */ char name[]; /* name's runtime length isn't known at compile time in C. */ struct forthword *previous; /* backward ptr to previous word. */ struct forthword *codeword; /* ptr to the code to execute this word. */ byte parameterfield[]; /* unknown length of data, words, or opcodes. */ }; 

The name field starts with a prefix giving the length of the word's name (typically up to 32 bytes), and several bits for flags. The character representation of the word's name then follows the prefix. Depending on the particular implementation of Forth, there may be one or more NUL ('0') bytes for alignment.

The link field contains a pointer to the previously defined word. The pointer may be a relative displacement or an absolute address that points to the next oldest sibling.

The code field pointer will be either the address of the word which will execute the code or data in the parameter field or the beginning of machine code that the processor will execute directly. For colon defined words, the code field pointer points to the word that will save the current Forth instruction pointer (IP) on the return stack, and load the IP with the new address from which to continue execution of words. This is the same as what a processor's call/return instructions does.

Structure of the Compiler

The compiler itself consists of Forth words. This gives the programmer considerable control of the compiler, and a programmer can change the compiler's words for special purposes.

The "compile time" flag in the name field is set for words with "compile time" behavior. Most simple words execute the same code whether they are typed on a command line, or embedded in code. When compiling these, the compiler simply places code or a threaded pointer to the word.

Compile-time words are actually executed by the compiler. The classic examples of compile-time words are the control-structures such as IF and WHILE. All of Forth's control structures, and almost all of its compiler are implemented as compile-time words.

The assembler (see above) is a special dialect of the compiler.

Structure of Code

In most Forth systems, the body of a code definition consists of either machine language, or some form of threaded code. Traditionally, indirect-threaded code was used, but direct-threaded and subroutine threaded Forths have also been popular. The fastest modern Forths use subroutine threading, insert simple words as macros, and perform peephole optimization or other optimizing strategies to make the code smaller and faster. A system of codes directly understandable by a computers CPU is termed this CPUs native or machine language. ... In computer science, the term threaded code refers to an implementation technique for programming languages that produces very compact code. ... In compiler theory, peephole optimization is a kind of optimization performed over a very small set of instructions in a segment of generated code. ...

Data Objects

When a word is a variable or other data object, the CF points to the runtime code associated with the defining word that created it. A defining word has a characteristic "defining behavior" (creating a dictionary entry plus possibly allocating and initializing data space) and also specifies the behavior of an instance of the class of words constructed by this defining word. Examples include:

• VARIABLE -- Names an uninitialized, one-cell memory location. Instance behavior of a VARIABLE returns its address on the stack.
• CONSTANT -- Names a value (specified as an argument to CONSTANT). Instance behavior returns the value.
• CREATE -- Names a location; space may be allocated at this location, or it can be set to contain a string or other initialized value. Instance behavior returns the address of the beginning of this space.

Forth also provides a facility by which a programmer can define new application-specific defining words, specifying both a custom defining behavior and instance behavior. Some examples include circular buffers, named bits on an I/O port, and automatically-indexed arrays.

Data objects defined by these and similar words are global in scope. The function provided by local variables in other languages is provided by the data stack in Forth. Forth programming style uses very few named data objects compared with other languages; typically such data objects are used to contain data which is used by a number of words or tasks (in a multitasked implementation).

Forth does not enforce consistency of data type usage; it is the programmer's responsibility to use appropriate operators to fetch and store values or perform other operations on data.

Computer programs in Forth

Words written in Forth are compiled into an executable form. The classical "indirect threaded" implementations compile lists of addresses of words to be executed in turn; many modern systems generate actual machine code (including calls to some external words and code for others expanded in place). Some systems feature sophisticated optimizing compilers. Generally speaking, a Forth program is saved as the memory image of the compiled program with a single command (e.g., RUN) that is executed when the compiled version is loaded.

During development, the programmer uses the interpreter to execute and test each little piece as it is developed.

Most Forth programmers therefore advocate a loose top-down design, and bottom-up development with continuous testing and integration.

The top-down design is usually separation of the program into "vocabularies" that are then used as high-level sets of tools to write the final program. A well-designed Forth program reads like natural language, and implements not just a single solution, but also sets of tools to attack related problems.

The tool-box approach is one of the reasons that Forth is so difficult to master. While learning the syntax is easy, mastering the tools delivered with a professional Forth system can take several months, working full-time. The task is actually more difficult than rewriting one's own Forth system from scratch. Unfortunately, a rewrite also loses the experience accumulated in a typical professional Forth toolbox.

Implementation of a Forth System

Forth uses two stacks for each executing task. The stacks are the same width as the index register of the computer, so that they can be used to fetch and store addresses. The parameter or data stack (commonly referred to as the stack) is used to pass data to words. The linkage or return stack (commonly referred to as the rstack) is used store return addresses when words are nested (the equivalent of a subroutine call, and store local variables. There are standard words to move data between the stacks, and to load and store variables on the stack. In computer science, a subroutine (function, procedure, or subprogram) is a sequence of code which performs a specific task, as part of a larger program, and is grouped as one or more statement blocks; such code is sometimes collected into software libraries. ...

The Forth interpreter looks up words one at a time in the dictionary, and executes their code. The basic algorithm is to search a line of characters for a non-blank, non-control-character string. If this string is in the dictionary, and it is not a compile-time word (marked in the flag byte), the code is executed. If it is not in the dictionary, it may be a number. If it converts to a number, the number is pushed onto the parameter stack. If it does not convert, then the interpreter prints an error message; for example, the string followed by a question mark. The interpreter then throws away the rest of the input.

A Forth compiler produces dictionary entries. Other than that, it tries to simulate the same effect that would be produced by typing the text into the interpreter.

The great secret to implementing Forth is natively compiling it, so that it compiles itself. The basic scheme is to have the compiler defined in terms of a few words that access a code area. Then, one definition of the words may compile to the normal area of memory while another definition compiles to disk, or to some special memory area. The compiler is adapted by recompiling it with the new definitions. Some systems have defined low-level words to communicate with a debugger on a different computer, building up the Forth system in a different computer.

Hello world

For an explanation of the tradition of programming "Hello World", see Hello world program. A hello world program is a software program that prints out Hello, world! on a display device. ...

One possible implementation:

 : HELLO ( -- ) CR ." Hello, world!" ; HELLO 

A standard Forth system is also an interpreter, and the same output can be obtained by typing into the Forth console (note parentheses instead of quotes): Interpreter can mean one of the following: In communication, an interpreter is a person whose role is to facilitate dialogue between two parties that do not use the same language. ...

 CR .( Hello, world!) 

Note that the word 'CR' comes before the text to print. By convention, the Forth interpreter does not start output on a new line. Also by convention, the interpreter waits for input at the end of the previous line, after an 'ok ' prompt. There is no implied 'flush-buffer' action in Forth's CR, as it sometimes is in other programming languages.

Online Forth interpreters

• JavaScript Forth implementation with tutorial material. The interactive terminal emulation works best with browsers like Firefox, Mozilla, and Netscape.
• Forth implementation accessible through TELNET. (Not all browsers support this protocol.)

JavaScript is the name of Netscapes implementation of ECMAScript, a scripting programming language based on the concept of prototypes. ... Firefox redirects here. ... Mozilla is a computer term that has had many different uses, though all of them have been related to Netscape Communications Corporation and its related application software. ... Netscape is the general name for a series of web browsers originally produced by Netscape Communications Corporation, but now developed by AOL. The original browser was once the dominant browser in terms of usage share, but it now has only a relatively small number of users. ... Microsoft TELNET client animation. ...

See also

• Threaded code
• Jupiter ACE – The British home computer with ROM-resident Forth
• Joy A Forth-like language that includes dynamic typing, lists, garbage collection, and similar high-level features.
• PostScript
• RPL A programming language for Hewlett-Packard calculators, with similarities to FORTH.
• Sy language

In computer science, the term threaded code refers to an implementation technique for programming languages that produces very compact code. ... The Jupiter ACE was a British home computer of the 1980s, marketed by a company named Jupiter Cantab. ... The Joy programming language is a purely functional programming language that was produced by Manfred von Thun of Latrobe University in Melbourne, Australia. ... PostScript (PS) is a page description language and programming language used primarily in the electronic and desktop publishing areas. ... The RPL programming language (RPL meaning reverse Polish LISP or, alternatively, ROM-based procedural language) is a handheld calculator system and application programming language used on Hewlett-Packards engineering graphing RPN calculators of the HP-28, HP-48 and HP-49 series. ... Sy is a stack language or stack-based computer language that is interpreted inside the Scrinchy webserver. ...

Dialects

• 51-FORTH
• Bashforth
• colorForth

51-FORTH is an implementation of the Forth programming language for the Intel 8051 microcontroller. ... Bashforth is a free Forth interpreter, written entirely in the bash scripting language. ... colorForth is the current state-of-the-art from the Forth programming languages original designer, Chuck Moore. ...

External links

Wikibooks has more about this subject:

Programming:Forth

• ANSI Forth Standard -- Appendix F is the index to the standard words.
• Execution speed of threading
• Forth Compilers Page
• Forth Chips Page - will reappear - site is being reorganised -- Forth in hardware

Image File history File links Wikibooks-logo-en. ...

Books, tutorials, and classes

• Forth books for sale, by Elizabeth Rather and others at FORTH, Inc.
• Programming Forth by Stephen Pelc, MPE (draft version, on-line)
• Gforth tutorial
• A Beginner's Guide to Forth by Julian Noble (on-line tutorial)
• Forth programming classes at FORTH, Inc. or on-site
• Starting Forth Leo Brodie's, introduction to Forth — a classic. (out of print)
• Thinking Forth, Leo Brodie's book about Forth programming methodology (on-line, creative commons license)
• Stack Computers, by Philip Koopman, Jr. A book about stack-based computers, including the Novix NC4016 and the Harris RTX series, both Forth-based CPUs

Intel 80486DX2 microprocessor in a ceramic PGA package A central processing unit (CPU), or sometimes simply processor, is the component in a digital computer that interprets instructions and processes data contained in software. ...

Freely available Forth implementations

• amrFORTH -- 8051 Tethered Forth for Windows/OSX/Linux/*BSD
• PFE -- Portable Forth Environment
• Gforth -- GNU Forth Language Environment
• bigFORTH -- x86 native code Forth with MINOS GUI
• kForth -- Small Forth Interpreter written in C++
• SPF -- OpenSource Forth for Win32 and Linux. This is a ANS94 compliant Forth with optimising compiler and fast subroutine threading code
• RetroForth -- Public Domain, for DOS, Linux, FreeBSD, Windows or standalone use -- has a wiki
• pForth -- PD portable Forth in 'C' for embedded systems or desktops.
• herkforth -- A colored forth which runs on a simple virtual machine -- has a wiki
• TWiki's Forth page -- includes a list of implementations for many homecomputers.
• Computer Intelligence Forth -- an assembler-based ISO-Forth
• eForth by C.H.Ting
• Mops -- an object-oriented Forth dialect for the Macintosh based on the formerly commercial Neon
• Win32Forth -- Forth for Microsoft Windows 98/2000/XP
• colorForth for the PC, downloader / source reader program.
• Reva a small fast x86 Forth implementation for Linux and Windows by Ron Aaron
• 4IM small simple fast 16bits standalone and DOS Forth system; 32 bits Linux and Windows (portable C version), featuring GUI library bindings.
• uCalc Forth uCalc Language Builder source code for a small Win32 Forth.

TRS-80 Color Computer II The home computer is a consumer-friendly word for the second generation of microcomputers (the technical term that was previously used), entering the market in 1977 and becoming common during the 1980s. ...

Commercial Forth implementations

• Forth, Inc. -- The original purveyor of Forth systems. Supplier of books on Forth, Forth for Microsoft Windows and cross-compilers for many microcontrollers. Links to many tutorials and historical articles.
• MicroProcessor Engineering Limited (MPE) -- for Microsoft Windows with cross compilers to many different processors.
• Quartus Forth -- for the Palm OS, has a wiki at http://quartus.net/cgi-bin/twiki/view/Main/
• iForth -- for Microsoft Windows, Linux and MS-DOS
• MacForth -- for Mac OS

Microsoft Windows is a series of popular proprietary operating environments and operating systems created by Microsoft for use on personal computers and servers. ... Microsoft Windows is a series of popular proprietary operating environments and operating systems created by Microsoft for use on personal computers and servers. ... Palm OS is an operating system made by PalmSource, Inc. ... Microsoft Windows is a series of popular proprietary operating environments and operating systems created by Microsoft for use on personal computers and servers. ... Tux is the official Linux mascot. ... Microsofts disk operating system, MS-DOS, was Microsofts implementation of DOS, which was the first popular operating system for the IBM PC, and until recently, was widely used on the PC compatible platform. ... Mac OS, which stands for Macintosh Operating System, is a range of graphical user interface-based operating systems developed by Apple Computer for their Macintosh computers. ...

Historical Forth implementations

• Information on Forth for 8-bit Home-Computer (Atari, Apple, ZX-80, ...)
• volksFORTH a 16bit Forth System for MS-DOS, Atari Portfolio, CP/M, Atari ST, Amstrad CPC, Apple 1/Replica 1, Atari XL/XE, Commdore PET, C=64, C-16, Plus 4
• GraFORTH -- Forth for the Apple ][ with AV primitives (ShrinkIt archive)
• MVP Forth with source code available from Mountain View Press

Forth communities

• Forth-specific wiki
• Forth Interest Group
• Russian Forth Interest Group
• Forth Gesellschaft e.V. (german)
• The original Wiki's Forth page
• One can meet on IRC, irc.freenode.net, channel #forth. To connect from Europe, irc.eu.freenode.net is preferred.
• #forth IRC channel website
• comp.lang.forth Forth newsgroup, where many professional and amateur Forth programmers lurk and post.

Internet Relay Chat (IRC) is a form of instant communication over the Internet. ...

History of Forth

• Forth, the Early Years by Chuck Moore
• The Evolution of Forth by C. H. Moore, E. D. Rather, and D. R. Colburn. Presented at the ACM SIGPLAN History of Programming Languages Conference (HOPL II, April, 1993). Published in ACM SIGPLAN Notices, Volume 28, No. 3 March 1993.