The Language List - Version 2.4, January 23, 1995

Collected information on about 2350 computer languages, past and present.

Available online as:
        http://cui_www.unige.ch/langlist
        ftp://wuarchive.wustl.edu/doc/misc/lang-list.txt

Maintained by:

  Bill Kinnersley
  Computer Science Department
  University of Kansas
  Lawrence, KS 66045

  billk@cs.ukans.edu

Started Mar 7, 1991 by Tom Rombouts <tomr@ashtate.A-T.com>

  This document is intended to become one of the longest lists of computer
programming languages ever assembled (or compiled).  Its purpose is not to
be a definitive scholarly work, but rather to collect and provide the best
information that we can in a timely fashion.  Its accuracy and completeness
depends on the readers of Usenet, so if you know about something that
should be added, please help us out.  Hundreds of netters have already
contributed to this effort.  We hope that this list will continue to evolve
as a useful resource available to everyone on the net with an interest in
programming languages.
 

"YOU LEFT OUT LANGUAGE ___!"

   If you have information about a language that is not on this list,
please e-mail the relevant details to the current maintainer, as shown
above.  If you can cite a published reference to the language, that will
help in determining authenticity.
 

What Languages Should Be Included

   The "Published" Rule - A language should be "published" to be included
in this list.  There is no precise criterion here, but for example a
language devised solely for the compiler course you're taking doesn't
count.  Even a language that is the topic of a PhD thesis might not
necessarily be included.  But if material on that language was published in
a technical journal or report, or if it formed the basis for additional
research, the language belongs in this list.  A language does NOT have to
be implemented (actually running on at least one computer) to be included.
Many languages appearing in the ACM SIGPLAN Notices fall into this
category.

   In general when there's any doubt, an entry will be included.  Making
the list as complete as possible necessarily means there will be a large
number of obscure entries.  To compensate for this "clutter" effect, more
widespread languages such as C or FORTRAN should have longer entries.

   For historical completeness roughly 200 early pre-1959 "automatic
programming systems" were included, based on a list from CACM 2(5):16, May
1959.  It can be argued that many of these are not really programming
languages as the term is used today.  We've also included some formalisms
which are clearly not meant to be used as a source language for writing
programs: metalanguages such as BNF, intermediate languages such as P-Code,
and computational models such as Linda.
 

Dialects, Variants, Versions and Implementations

   Computer languages evolve, and are related to one another in rather
complex ways.  Almost every language can be regarded as an improved version
of something else.  Sometimes it's hard to know where to draw the line and
say "this is a separate language".  Taking LISP as an example, what started
out as a single language has evolved into a large family.  Dialects (such
as Scheme and Common LISP) have major differences and are certainly
considered by their users to be distinct languages.  Variants (such as
Kyoto Common LISP and Allegro CL) are primarily intended to be the same,
but have certain features which make them incompatible.  Implementations
are designed to run on particular machines or operating systems and will
usually have special features added.  Inevitably a series of revisions will
be issued, causing further small changes in the language.  It has even been
suggested that if command line options are present, each choice of options
could be considered a distinct language!

   A language's name by itself is not always an accurate guide to its
identity.  Sometimes a language will undergo significant evolution without
any official change in name (e.g. SETL2 has done this).  Sometimes just the
name will change (IAL to ALGOL to ALGOL 58).  And occasionally a name has
been used for several distinct languages (e.g. Vulcan).

   It may also be debatable what is "in" a language and what is not.  For

example SML is defined in stages: a "core syntax" surrounded by a standard
set of extensions.  Technically that makes it two separate languages.
Other languages have purposely omitted essential features like I/O from
their definition because they were never intended to be used without a
standard library (C) or interface (Smalltalk-80), or because they
constitute the command language for a particular product or system.  Still
other languages are by their very nature extensible, and the large number
of macro packages built on TeX for example could be called an endless list
of separate "languages".

   Brand names - You might wonder why we do include a number of commercial
products such as Turbo Pascal.  Usually these items offer non-standard
extensions to the base language.  This has been particularly true in the
varieties of BASIC and Prolog.  But also one could argue that in a strict
sense Microsoft C and Turbo C for example are distinct languages.
   Another reason for including entries of this type is that many languages
are proprietary, appearing only in a certain product.  Such languages may
be distinctive and interesting and deserve to be here.  On the other hand
we don't want the list to become a catalog of commercial programming
products.
 

What Each Entry Should Contain

Name:  An explanation of the language name, which in perhaps 80% of the
cases is some form of acronym or abbreviation.
 

Date of origin:  The year when a language first appeared.  Since the
design, implementation and distribution of a language can take place over a
period of several years, such dates are often approximate.  Any language
that has an ANSI, ISO or BSI standard should include the date approved.
For specific brands such as Turbo Pascal the release dates of each version
can be listed.

Reference:  At least one reference work on the language, as definitive or
as official as possible.

Availability:  ftp site, commercial source or publisher, contacts for
further information.

"See also:"  Related languages or terms that may also be of interest.

   Any material marked with brackets "[]" is doubtful and may be considered
a request for further information.

   Editorial Comments -  What constitutes a good language has often become
the subject of intense debate.  We've tried to avoid adding to this by
avoiding any remarks that are subjective, such as calling a language
"powerful".  Nevertheless some comments might still be construed this way.
For instance saying that Pascal is "ALGOL-like" could offend both some
ALGOL and some Pascal users.  Also, some questions of historical origin are
not universally agreed upon.
 

   Classification - It's been suggested that the languages in this list
should be arranged into categories, but to do so would be extremely
difficult.  For every classification scheme there wlll be a large
proportion of languages that do not fit.  The languages are therefore
listed alphabetically, and in fact we think that this is the most useful
organization.  You'll find that the following categories have been referred
to in the list, but we must emphasize that most languages are not purely
one or the other, and we are really categorizing language features.

Imperative language

        A language which operates by a sequence of commands that change the
value of data elements.  Typified by assignments and iteration.

Declarative language

        A language which operates by making descriptive statements about data
and relations between data.  The algorithm is hidden in the semantics of
the language.  This category encompasses both applicative and logic
languages.  Examples of declarative features are set comprehensions and
pattern-matching statements.

Procedural language

        A language which states how to compute the result of a given problem.
Encompasses both imperative and functional languages.

Applicative language

        A language that operates by application of functions to values, with no
side effects.  A functional language in the broad sense.

Functional language

        In the narrow sense, a functional language is one that operates by use
of higher-order functions, building operators that manipulate functions
directly without ever appearing to manipulate data.  Example: FP.

Definitional language

        An applicative language containing assignments interpreted as
definitions.  Example: Lucid.

Single Assignment language

        An applicative language using assignments with the convention that a
variable may appear on the left side of an assignment only once within the
portion of the program in which it is active.

Dataflow language

        A language suitable for use on a dataflow architecture.  Necessary
properties include freedom from side effects, and the equivalence of
scheduling constraints with data dependencies.  Examples: Val, Id, SISAL,
Lucid.

Logic language

        A logic language deals with predicates or relationships p(X,Y).  A
program consists of a set of Horn clauses which may be:
        facts - p(X,Y) is true
        rules - p is true if q1 and q2 and ...qn are true
        queries - is g1 and g2 and ...gn true?  (gi's are the goals.)
        Further clauses are inferred using resolution.  One clause is selected
containing p as an assumption, another containing p as a consequence, and p
is eliminated between them.  If the two p's have different arguments they
must be unified, using the substitution with the fewest constraints that
makes them the same.
    Logic languages try alternative resolutions for each goal in
succession, backtracking in a search for a common solution.  OR-parallel
languages try alternative resolutions in parallel, while AND-parallel
languages try to satisfy several goals in parallel.

Constraint language

        A language in which a problem is specified and solved by a series of
constraining relationships.

Object-Oriented language

        A language in which data and the functions which access it are treated
as a unit.

Concurrent language

        A concurrent language describes programs that may be executed in
parallel.  This may be either
        multiprogramming: sharing one processor
        multiprocessing: separate processors sharing one memory
        distributed

Concurrent languages differ in the way that processes are created:
        coroutines - control is explicitly transferred - Simula I, SL5, BLISS,
Modula-2.
        fork/join - PL/I, Mesa
        cobegin/coend - ALGOL 68, CSP, Edison, Argus
        process declarations - DP, SR, Concurrent Pascal, Modula, PLITS, Ada

and the ways in which processes interact:
        semaphores - ALGOL 68
        conditional critical regions - Edison, DP, Argus
        monitors - Concurrent Pascal, Modula
        message passing - CSP, PLITS, Gypsy, Actors
        remote procedure calls - DP, *Mod
                rendezvous - Ada, SR
                atomic transactions - Argus

Fourth generation language (4GL's)

        A very high-level language.  May use natural English or visual
constructs.  Algorithms or data structures may be chosen by the compiler.

Query language

        An interface to a database.

Specification language

        A formalism for expressing a hardware or software design.

Assembly language

        A symbolic representation of the machine language of a specific
computer.

Intermediate language

        A language used as an intermediate stage in compilation.  May be either
text or binary.

Metalanguage

        A language used for formal description of another language.
 
 

                           * * * * * * *
 

2.PAK - AI language with coroutines.  "The 2.PAK Language: Goals and
Description", L.F. Melli, Proc IJCAI 1975.

20-GATE - Carnegie, ca 1965.  Algebraic language for the G-20.

3-LISP - Brian Smith.  A procedurally reflective dialect of LISP which uses
an infinite tower of interpreters.  "The Implementation of Procedurally
Reflective Languages", J. des Rivi et al, ACM J Lisp and Functional
Programming, pp.331-347 (1984).

473L Query - English-like query language for Air Force 473L system.  Sammet
1969, p.665.  "Headquarters USAF Command and Control System Query
Language", Info Sys Sci, Proc 2nd Congress, Spartan Books 1965, pp.57-76.