Forth principles

Readability
By its very nature, stack dependency and postfix style of operations, FORTH is not a very readable language. Consider an IF statement which evaluates two conditional tests and AND’s the result. In C/C++ a statement of this type could look something like this: if (x>y) and (y>z) { … }  in FORTH this type of statement would have to be coded:  x @ y @ > y @ z @ > if which even to a fairly experienced programmer can look confusing.

Writability
FORTH proves to be a fairly writeable language. Once one gets accustom to thinking in postfix notation basic programs can be created to do a great many powerful mathematical manipulations fairly easily. For example: the FORTH code necessary to implement Euclid’s Algorithm for finding the greatest common divisor of two numbers is quite simple -- : GCD ( n n--n) BEGIN DUP WHILE TUCK MOD REPEAT DROP ;

Reliability
FORTH is a simple language to learn. In terms of the entire body of commands available in standard FORTH the set is quite compact compared to most modern programming languages consisting of well under a 100 core “words” (a word being an executable command in FORTH). Many of the words are variants of an even smaller set of primitive words which are coded in Assembly Language, as opposed to the larger full set of standard words many of which are coded in FORTH itself.

Security
FORTH is a very insecure language. Programmers are allowed to place values on the stack into literally any memory address by putting a value on the stack and using a memory address with the ! symbol, for example 0 3262436 ! would store the value 0 in the memory location 3262436. Unless caution is exercised, such unrestricted access to memory may crash the program or even the operating system without warning. Moreover, since FORTH does not do any range checking inherently loops and routines which access memory locations via such loops care high risk operations unless the programmer does their own range checking.

Simplicity
FORTH is a simple language to learn. In terms of the entire body of commands available in standard FORTH the set is quite compact compared to most modern programming languages consisting of well under a 100 core “words” (a word being an executable command in FORTH). Many of the words are variants of an even smaller set of primitive words which are coded in Assembly Language, as opposed to the larger full set of standard words many of which are coded in FORTH itself.

Expressiveness
For stack based operations, FORTH is quite expressive. The stack commands are all specialized to do specific, easily understandable operations on the stack. For example: to duplicate the top value on the stack you invoke the DUP word. To swap the first two values on the stack you use SWAP, etc. With just a handful of stack manipulation words FORTH can accomplish some remarkable things.

Portability
FORTH programs are fairly portable as long as the program doesn’t directly manipulate memory storage locations directly. Even in this case, it is probable a program can be run on various operating systems providing that it does not require architecture and or O/S specific storage locations in order to function properly.

Extensibility
There are some popular extensions of FORTH, such as gForth, pForth and BigForth (which actually has been extended to be object oriented). So the core language is fairly extensible in this respect. However, perhaps the most powerful use of FORTH is as an extension itself, adding the superior stack handling capability to higher level languages such as C/C++.

Efficiency
When it comes to code efficiency FORTH is among the most efficient of all modern programming languages. Many complex algorithms can be implemented in FORTH with a very minimal amount of code, and that code is VERY fast and efficient often compiling to run at speeds approaching Assembly Language programs.

Orthogonality
As has been pointed out, FORTH consists of a fairly small core of command words. From this smaller core many standard words have already been implemented, and a programmer can design thousands more, in fact in FORTH the native form of subprograms is the command word. So with just a small set of core words, FORTH affords a programmer the flexibility to design a large library of words with which to solve problems. FORTH is very orthogonal.

Consistency
FORTH provides for a general consistency in the definition of core WORD's and standard WORD's derived from the core. For example, to retrieve the top value from the data stack the command is simply a dot (.) and to view the data stack the command is .S, with this in mind, say you want to retrieve the top value on the floating-point stack? Then you would use F. (F dot) and to view the values on the floating-point stack you use F.S. Much of FORTH follows this same basic consistency.

Learnability
As with any computer language, learnability in FORTH is a very relative concept. In general, it is fairly easy to learn to use FORTH to do basic data stack manipulations and mathematical computations as long as this does not require accessing elements of complex data structures such as arrays, hashing tables, etc.