Welcome to the Dictionary of Programming Languages, a compendium of computer coding methods assembled to provide information and aid your appreciation for computer science history.

Browse the dictionary by clicking on a section:
A  B  C  D  E  F  G  H  I  JK  L  M  N  O  P  QR  S  T  UV  WXYZ+

Get a full dump of the dictionary:
List of Names      Short Form      Full Form

F

FLooP
Language type:
S - block-structured

Description:
FLooP was a very simple recursive block structured language invented by Douglas Hofstadter for his book Godel, Escher, Bach. It features simple subroutine structure, very simple number and boolean handling, and recursion. Unlike its cousin BLooP, FLooP does support unbounded loops. This allows it to possess the full power of a Turing machine, thus making it fair game for various undecidability theorums. The syntax of FLooP is rather verbose, but simple in structure.

Origin:

Remarks:
Though Hofstadter doesn't mention it in GEB, FLooP is similar to early exercises in exploring the computational model of "Random Access Machines". Note the use of 'CELL(0) <= 2' and similar constructs.
Though FLooP was never intended to be more than an academic exercise, an implementation of FLooP in Perl was made. Unfortunately, I can't seem to find it.

Date:
Last updated 12/6/00

Sample code:
```
DEFINE PROCEDURE ''DIVIDE'' [DIVIDEND, DIVISOR]:
BLOCK 0: BEGIN
IF DIVISOR < 1, THEN: QUIT BLOCK 0;
CELL(0) <= DIVIDEND;
LOOP AT MOST DIVIDEND TIMES:
BLOCK 1: BEGIN
IF CELL(0) < DIVISOR, THEN: QUIT BLOCK 0;
CELL(0) <= MINUS[CELL(0), DIVISOR];
OUTPUT <= OUTPUT + 1;
BLOCK 1: END;
BLOCK0: END.

DEFINE PROCEDURE ''PERFECT?'' [N]:
BLOCK 0: BEGIN
CELL(0) <= 0;
CELL(1) <= 0;
LOOP DIVIDE [N,2] TIMES:
BLOCK 1 BEGIN:
CELL(1) <= CELL(1) + 1;
IF REMAINDER[N,CELL(1)] = 0, THEN: CELL <= CELL(0) + CELL(1);
BLOCK 1 END;
IF CELL(0) = N THEN: OUTPUT <= YES;
BLOCK 0: END.
```

FORMAC
See:

Language type:
M - Mathematical or Simulation

Description:
FORMAC is a dialect of FORTRAN with an extensive set of extensions for symbolic computation and expression manipulation. It was designed and implemented in the 1960s to support scientific and engineering computing on IBM mainframes.
As a kind of symbolic dialect of FORTRAN IV, the original FORMAC had syntax and overall program structure similar to FORTRAN. Data types supported included all the FORTRAN numeric types, plus rational numbers, symbols, arrays, and expressions. FORMAC programs could include subroutines and functions, and could use other FORTRAN facilities like common areas.
FORMAC was originally implemented as a preprocessor on top of FORTRAN; the formulae and symbolic function calls were transformed into calls to a symbolic manipulation library. For I/O, FORMAC could take advantage of all the usual FORTRAN facilities, and could also print its symbolic expressions.
In the late 1960s, IBM researchers created a similar proprocessor for PL/I, imaginatively named PL/I-FORMAC.
Unlike later symbolic math systems, FORMAC supported creation of expressions but not meta-expressions (rules). This is indicative of its early status in the evolution of symbolic computation, and despite its comparative lack of features it was influential on the field on its immediate successors (e.g. Reduce, Macsyma). FORMAC was used up until the early 1990s.

Origin:
Jean Sammet et al, IBM, 1964.

Remarks:
FORMAC was the first general symbolic mathematics language. There had been other attempts to apply computers to symbol manipulation, but prior to FORMAC all of them were libraries of procedures and functions that had to be assembled in the context of a conventional language.
Even after FORMAC and its cousin PL/I-FORMAC were dropped as official IBM products, they continued to be enhanced and used by members of IBM's SHARE user group.
The name stands for FORmula MAnipulation Compiler.

Date:
Last updated 3/11/98

Sample code:
```C FORMAC program to find the symbolic roots of some
C quadratic equations.  By J. Sammet from the HOPL-II
C paper on the history of FORMAC, typos corrected.
SYMARG
ATOMIC X,Y,K
DIMENSION CASE(3), X1(3), x2(3)
LET CASE(1) = X**2 + 2*X*(Y+1) + (Y+1)**2
LET CASE(2) = 2 * X**2 - 4*X
LET CASE(3) = 3*X**2 + K*(X+X**2+1) +4
N=3
DO 88 I = 1,N
LET RVEXPR = EXPAND CASE(I)

LET A = COEFF RVEXPR,X**2
LET B = COEFF RVEXPR,X
LET C = COEFF RVEXPR,X**0

LET DISCRM = EXPAND B**2 - 4*A*C
LET X1(I) = EXPAND (-B + DISCRM**(1/2))/(2*A)
LET X2(I) = EXPAND (-B - DISCRM**(1/2))/(2*A)
88   CONTINUE

FMCDMP
STOP
END
```

Forms/3
Language type:
V - Visual or graphical

Description:
Forms/3 is an interpreted visual programming language with an expression-oriented interface and mostly declarative semantics. It is an academic research language.
Elements of a Forms/3 form are called cells. Cells can hold powerful functions. The syntax for cell contents is fairly simple, but includes fair support for arithmetic and general sequential programming, as well as various graphical operations. Every cell has a current value. Data types supported in Forms/3 are strings, integers, reals, and booleans. Cell expressions can directly manipulate the appearance and other characteristics of graphical objects in the Forms/3 workspace.
Like many other visual languages, Forms/3 embodies a notion of time; it can be compared to a visual simulation system in that respect. Forms/3 allows time to be run both forward and backwards; it also supports semantics for reacting to asynchronous events.
One interpreter for Forms/3 exists, it is written in Common Lisp and runs on Unix workstations. The system is available at no charge from the authors.

Origin:
Burnett and Ambler, 1991.

Remarks:
Forms/3 is the successor to Forms/2 (89), also by M. Burnett and A. Ambler, which was a successor to the spreadsheet-like Forms (86) language by A. Ambler. Forms/3 is a research language, used to study visual programming paradigms, for comparison between visual and traditional programming methods, and for study of reversible program execution ('time travel').
Languages like Forms/3 differ from commercial so-called 'visual' language like Visual Basic in the sense that in true visual languages, the actual program structure and module relationships are created graphically. Commercial 'visual' languages are more like language-integrated GUI builders, although some convergence with academic visual programming is beginning to occur.

Date:
Last updated 6/12/99

Sample code:

Forth
Language type:

Description:
Forth is an interpreted stack-based language with a very simple syntax and elegant abstract exection model. Designed for efficiency and simplicity, Forth is noted for the very small size of the language system.
A Forth program is a sequence of words. Each word is independent, and causes some specified action. Even constants are words: the word "12" is just a command to push the number 12 onto the data stack. Sequences of words can be grouped as procedures, and employed to build up modular programs. In order for this to work, of course, operators and operands must be given in reverse polish order (operands followed by operator). All data manipulation takes place on the data stack, so Forth offers several operations for manipulating the stack.
Forth implementations vary in the range of data types they provide, but most provide a conventional set of numeric and string types, plus arrays. Forth offers regular control structures: If-Else, While-Do, and For-Next, albeit with peculiar ordering of the keywords. Most dialects of Forth provides simple file handling and I/O support.
Forth is also meant to be extensible at every level. Programmers can define new words, and implement them in Forth itself, in some other high-level language, or in machine code.
Information about Forth is widely available on the Internet. There are several commercial and implementations, many available from here.

Origin:
Charles H. Moore, 1969-1971.

Remarks:
Forth is often employed for controlling micro-computers and embedded systems, especially at boot-up prior to loading of a more complex OS. Because Forth is small and fast, it is well-suited for embedding in ROM. Forth is also used for creating general-purpose applications, even CGI scripts.
Forth is standardized as ANS-Forth; the standard is available here. There is also an IEEE standard in draft for using Forth as a standard firmware language, IEEE 1275.
Forth's stream-of-conciousness syntax, polymorphism, and typically terse style make reading real Forth code a challenging exercise.
The first real application of what we call Forth was controlling telescopes at the NRAO at Kitt Peak, in 1971. Forth became very popular in the astronomy community, and was adopted as the standard programming language by the International Astronomical Union in 1976.

Date:
Last updated 2/28/98

Sample code:
```\ Forth implementation of Newton's method for finding
\ roots, simplified. (c) Copyright 1994 Everett F. Carter.

: z1 ( i -- ) ( f: -- z1 )
z F@ xn{ SWAP } F@ F-
;

: Newton ( i -- ) ( f: e d p -- e d p )
\ calculate new D
DUP z1 FROT F* FOVER F+

\ calculate new P
FSWAP DUP z1 F* dif{ OVER } F@ F+

\ calculate new E
FROT z1 FABS F* FOVER FABS F+

\ restore stack order
FROT FROT
;

: FNewt ( &xn &dif n -- ) ( f: z -- e d p)
>R
& dif{ &!
& xn{  &!
R>

z F! 0.0e0  0.0e0 0.0e0
0 DO
I Newton
LOOP
;
```

FORTRAN
Language type:
S - block-structured

Description:
FORTRAN (from FORmula TRANSlation) is one of the oldest programming languages. Originally developed in the late 1950s, FORTRAN has moved through many versions and is still popular even today.
FORTRAN is characterized by its good support for mathematics, especially floating-point computation, its lack of modular programming structures, and implicit declarations, and odd control-flow constructs. FORTRAN is normally case-insensitive. In older versions of the language, the position of text on lines was significant; Fortran90 and later versions support free-form input.
FORTRAN has had many versions over the years, some of the most popular being: FORTRAN I, FORTRAN II, FORTRAN IV, FORTRAN 77, and Fortran90. The current standard is Fortran 95 (ISO/IEC 1539-1), and it includes many modern structured programming features in a traditional Fortran framework. Many specialized and parallel-processing versions of FORTRAN have also been created.

Origin:
John Backus, IBM, 1954-57

Remarks:
FORTRAN has long been a language of choice for complex scientific calculations, engineering models, statistics, and signal processing. Its simple code structure and lack of dynamic data structures make it highly amenable to compiler optimization and targetting to special hardware (eg. vector supercomputers).
Every few years, somebody predicts the imminent death of FORTRAN, and it never happens.

Date:
Last updated 7/9/01

Sample code:
```        PROGRAM Rad
! Simple FORTRAN program
REAL P,R,C
IF (.NOT. (R = 0.0)) THEN
P = 3.1415926
R = 2.5
C = P * R
PRINT *, "C = ", C
END IF
END
```

FP
Language type:
F - Functional or lambda-based

Description:
FP was a very early pure-functional language invented by Backus. FP was an interpreted language that attempted to break the VonNeumann-machine mould. All computations in FP were carried out by expressions and pure functions (subroutines that returned a single value and had no side effects.) Sequences and combining forms were also prominent features of FP.
The language also included a fairly novel feature of an explicit no-value value called bottom.
FP was succeeded by FL in 1985.

Origin:
John Backus, 1977.

Remarks:
FP helped to spawn the research field of functional languages, by exhibiting that a language based on very simple, clean semantics could be powerful enough to do interesting work. Also, functional programs can be reasoned about in a formal way much more easily than most conventional language programs.
Several implementations of FP existed in the late 1970s and early 80s. An FP interpreter was distributed with Berkeley UNIX 4.2BSD, a very popular UNIX implementation for DEC computers.

Date:
Last updated 12/3/97

Sample code:
```# Mergesort from the Berkeley FP manual

{ mergeSort | merge }
{merge atEnd @ mergeHelper @ [[], fixLists]}

# convert atomic args into sequences
{fixLists &(atom -> [id] ; id)}

# Merge until one or both input seqs are empty
{mergeHelper (while and @ &(not @null) @ 2
(firstIsSmaller -> takeFirst; takeSecond))}

# Find seq with smaller first element
{firstIsSmaller < @ [1 @ 1 @ 2, 1 @ 2 @ 2]}

# Take the first element of the first seq
{takeFirst [apndr @ [1,1 @ 1 @ 2], [tl @ 1 @ 2, 2 @ 2]]}
# Take the first element of the second seq
{takeSecond [apndr @ [1,1 @ 2 @ 2], [1 @ 2, tl @ 2 @ 2]]}

# Handle remaining nonempty seq
{atEnd (firstIsNull -> concat @ [1,2 @ 2];
concat @ [1,1 @ 2])}

{firstIsNull null @ 1 @ 2}

# apply the function
mergeSort : <0 3 -2 1 11 8 -22 -33>
```

6 entries retrieved.

Descriptions in this dictionary are ©1997-99 Neal Ziring. Some examples copyright of their respective authors. Some technologies and languages are trademarked. Permission to copy descriptions is granted as long as authorship credit is preserved.

Comments on this dictionary, corrections and suggestions, are all welcome. Please use email, the address is ziring@home.com

Dictionary and script maintained by Neal Ziring, last major modifications 3/18/98. Most recent additions to dictionary and master list, 1/00.