Unique Forth Language Features

Forth is interesting because it offers a unique combination of language features (e.g., low-level features combined with interactivity and meta-programming). But it also offers features that are unique to Forth (or it least so uncommon that you probably have not studied them elsewhere). This page discusses some of them:

Static Name Binding

In many programming languages, you just get an error. In some programming languages (e.g., Lisp or Postscript), the new definition replaces the old one; all references to the name now reference the new function (dynamic name binding).

In Forth, the old definition continues to exist, and any use of the name that was made before the new definition still refers to the old definition (static name binding). Any newer uses of the name refer to the new definition (i.e., the new definition shadows the old one). [In general, in Forth names are visible from the definition downwards.]

Why is this interesting? Because it is a way to deal with name collisions, without requiring name spaces or similar features (although Forth has such features (called vocabularies or wordlists)).

Consider an application defining a function foo. Somewhat later, the language or an important API is extended with a function foo.

• In a language like C, the application would no longer compile, even though it was standard-compliant at its time; to work around that, you should use feature test macros in C that (when used correctly) enable or suppress declarations of various functions (how many C programmers know this?); if you make a mistake there, people may only notice that when the next version of the language/API comes out that declares a conflicting function.
• In contrast, in Forth the application would just define its own foo, shadowing the new system's foo, and any uses of foo would refer to the application's foo, as they did with the old system.

But how do you do forward declarations, e.g., for mutual recursion? And how do you change the behaviour of a word (somewhat like the dynamic name binding of Lisp and Postscript)? There are other mechanisms for that, e.g., deferred words.

Control structures

Type checking

Programmer-visible stack

Explicit run-time compilation