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.

* * * * * * *