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:
- 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:
Hofstader, 1979 (implementation: Cowan, 1994)
- See Also:
- 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.
- Links:
-
- Date:
- 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.
- See Also:
- 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:
- 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:
- 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.
- See Also:
- 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.
- Links:
- Date:
- Sample code:
This is an example program from the Forms/3
home page:
-
Forth
- Language type:
T - Threaded or stack-based
- 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.
- See Also:
- 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.
- Links:
-
-
-
- Date:
- 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:
- 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
- See Also:
- 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.
- Links:
-
-
-
-
- Date:
- 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:
- See Also:
- 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.
- Links:
- Date:
- 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
[Ziring MicroWeb Home]
[Dictionary Start]
[Sign Guestbook]
Dictionary and script maintained by Neal Ziring, last major modifications 3/18/98. Most recent
additions to dictionary and master list, 1/00.