ABC is an interpreted procedural language
designed to be a higher-level replacement
for BASIC. The design of the language
was originally based on a task analysis
of programming work; ABC and its
development environment were designed to
make the work easier.
ABC features a small, orthagonal set of
data types, and a simple goal-oriented
syntax. The data types are: strings,
unlimit-precision numbers, records,
lists, and associative arrays. Data
handling is mostly performed by
specialized commands that manipulate
the lists, tables, and records. The
language also has a substantial set of
high-level operators and I/O statements.
To facilitate top-down programming,
ABC supports 'refinement', a mechanism
for declaring operations in-line and
defining them later in the code.
ABC the language is not really distinct
from its programming environment (some
dialects of Basic, and many of Lisp, also
have this property). Expressions or
statements in
ABC can be part of function or predicate,
or can be given directly to the environment
for immediate execution.
ABC's high-level operators and data
structures allow many kinds of computations
to be expressed very succintly. ABC
has been used to write simple natural
language parsers and databases.
ABC is available for some Unix systems,
MS-DOS, and
for the Macintosh.
Some information is available on the web,
and there are also books about the
language.

ACSL - Advanced Continuous Simulation Language
Originally a simple FORTRAN preprocessor
for continuous-system modelling, ACSL has
been used since 1980. The language is a
hybrid of system specification elements
and procedural processing blocks. Newer
ACSL products present a visual front-end
but still use a FORTRAN-like syntax for
the programs themselves.
ACSL is a proprietary language, available
from MSA Software.

Ada is a block-structured language with many
object-oriented programming features. It
was originally designed for the US Dept. of Defense,
and was intended to support large-scale programming
and promote software reliability. Some of Ada's
features include: nested procedures, nested packages,
strong typing, multi-tasking, generics,
exception handling, and
abstract data types.
Primitive data types supported by Ada
include a variety of numeric types, booleans,
characters, references, and enumerated
symbols. Arrays, records (structures),
and strings are Ada's composite types.
With its emphasis on program safety, it is
not surprising that Ada is a strongly typed
language: all data elements must be declared
as storing a particular type or subtype, and
type enforcement is strictly applied both
within and between modules.
Ada supports a full complement of
sequential control structures, as well as
comprehensive exception handling.
Ada is very strictly standardized and
well documented as a language. Ada
compilers undergo stringent validation
with an official test suite. At least one
free Ada compiler and several good
commercial ones are
available.
Ada was named in honor of Lady Ada Lovelace (1815-1852), a
friend and confidante of Charles Babbage.
Ada was initially standardized in 1983, and was
superseded by a new standard in 1995. These
two versions are now known as Ada 83
and Ada 95.

Alef is a compiled concurrent programming
language similar in appearance to C,
designed for network application development
under the Plan 9 operating system.
Data types supported by Alef include various
sizes of integers, reals, chars,
string, tuples, structures, unions,
arrays, and channels. The language
supports definition of abstract data types
and parameterized (generic) ADTs and
functions. Alef's control constructs
include a comprehensive set of
conditional, goto, and loop
statements, as well as error handling and
parallel task synchronization.
Alef also features a unique explicit tail
recursion statement.
Alef has been ported to a wide variety
of hardware with the Plan 9 operating
system, and also to SGI IRIX.
The Alef language development system is
available as part of the Plan 9
distribution. Spare but well-written
documentation is available on-line.

Algol (for Algorithmic Language) was
a very early block-structured
compiled language
developed a committee, and implemented by
computing pioneer John Backus.
It was designed for general-purpose industial
and scientific programming.
Dialects of Algol include the original
Algol58,
Algol60, Algol68, ABC Algol, Algol W,
S-Algol, and
many other variants. Algol58 was
originally called the "International
Algebraic Language" (IAL).
Data types supported by Algol60 include
booleans, various sizes of integers and
reals, and strings. Support for strings
was limited in standard Algol, but later
dialects and implementations added more
support.
Algol60 was strongly typed in the sense
that the compiler checked parameter types
in expressions and subroutine calls.
It did not permit the declaration of new
data 'types' or data structures. Arrays
are the only composite data type in Algol60.
Algol60 supported highly regular block
structure and a complete set of
control structures: if-then-else, case,
while loops. One of Algol's main
contribution to programming was the
introduction of block nesting and
lexical scoping of local and block
variables.
Algol60 did not support any kind of
general memory management or dynamic
memory allocation.
Various implementations of some Algol
dialects are still available commercially.
Information on the web seems sparse, but
some documentation of Algol68 is available.
Of course, many old programming books
describe the language.

Origin:

J. Backus and P. Naur, 1958-60.

Date:

Last updated 11/7/99

Algol68

Language type:

S - block-structured

Description:

Algol68 was a greatly expanded and enhanced
version of the Algol block-structured
language. Many capabilities were added to
the sound framework of Algol60 to create a
much more capable language for general
application and systems programming.
Algol68 introduced a large number of new
features over previous versions:
formalized syntax and semantics, parallel
programming constructs, new data types
and structuring methods, and type
declarations.
Primitive data types supported by Algol68
include booleans, chars, strings, integers,
reals, complex numbers and references.
Dynamic arrays,
structures, and unions are available for
building complex data structures.
Algol68 also supports separate compilation
modules, as Algol60 did.
Also like its predecessor, Algol68 is
very strongly typed.
A few implementations of Algol 68 and
various dialects of it exist, including
some for PCs and mainframes.

APL is an interpreted mathematical language
characterized by its terse syntax and
bizarre non-ASCII character set. It is
very strong in all forms of arithmetic
and matrix manipulation.
APL was invented in the 1960s, and has
enjoyed some modest popularity ever since.
Commercial and free APL implementations
exist for most modern platforms.
The original APL has been partly superseded
by advanced variants, such as APL2, J,

AppleScript is a procedural, structured
command language designed for the Apple
Macintosh environment. It can be used
to control programs, network operations,
and user interfaces under MacOS. AppleScript
scripts are compiled into
some kind of intermediate code prior to
execution.
The syntax of AppleScript is meant to
resemble spoken language: verbs,
nouns, prepositions, and adjectives.
A program consists
of statements, terminated by end-of-line (like
Tcl, csh, and other command languages; of course,
there is a line continuation character).
AppleScript offers a small complement of
primitive data types: integers, reals, and
strings.
All manipulable entities in AppleScript are
represented as objects, these objects have
various properties, and can accept
certain commands. Composite data types,
lists and records, are also considered to
be objects in AppleScript.
AppleScript is an object-oriented
programming language, new object
classes, called script objects, can be
defined within the language.
(New classes can also be defined by
binary object modules called
scripting extensions.)
Values in AppleScript are
typed, but variables are not; AppleScript
does not enforce strong type checking.
The language offers a conventional set
of procedural control flow constructs,
supports subroutines, and offers
rudimentary error handling.
For object-oriented programming, AppleScript
supports single inheritance and delegation,
as well as simple polymorphism.
MacOS 7.5 was shipped with AppleScript 1.1,
MacOS 8 is shipped with 1.1.2.
Tutorials and documentation
about AppleScript are available on
the Internet, as well
as example scripts and powerful extensions.
The language itself is available from
Apple or bundled with some Macintosh
applications, but utilities, editors, and
other tools for developers are available free.

AutoIt is a scripting language for automating
tasks in the Microsoft Windows environment.
It can be used for scripting a wide variety
of activities that would normally require
human interaction with Windows GUIs, because
it is capable of scripting user input actions.
The syntax and structure of AutoIt is
fairly simple. Like many scripting languages
it is weakly typed: all variables use the same
Variant type, which can hold numbers, strings,
or boolean values. The language supports
simple scalar variables and arrays, but no
pointers or other advanced data structures
(not uncommon for macro languages). Control
structure supported in AutoIt include
If-then-else, case statements, five kinds of
loops, and simple functions. It does not
support closures.
AutoIt has a large number of built-in
functions for interacting with the Windows
environment.

Origin:

Jonathan Bennett, 1999

Date:

Last updated 3/6/07

Autolisp

Language type:

A - Application/Macro

Description:

Dialect of Lisp used as the extension
language for AutoCAD(tm) and other
products from Autodesk. Supported
primarily for AutoCAD versions 11-13
In addition to normal Lisp features,
Autolisp offered extensive facilities for
manipulating objects in a CAD drawing in
CAD files, and
for interacting with the user through
the AutoCAD interface. Popular in
the Autodesk user community.

Origin:

Autodesk, late 1980s

Date:

Last updated 12/7/97

Awk

Language type:

D - Database or Text-processing

Description:

Awk is an interpreted string-processing
language developed at Bell Labs in the
early 1970s. It quickly assumed its
place as the utility language of choice
for small UNIX data transformation and
parsing programs. Awk offered powerful
regular expression pattern matching, handy
line-oriented program structure, and enough
conventional language features to let you
get your work done. Awk did not support
any kind of modularity nor type checking.
In a typical Awk program, sections of code
are applied to lines of data input as
matched by regular expressions. Later
versions of Awk supported multiple input
files as well as subroutines and other
advanced features.
A version of 'new' awk (circa 1985) is
supplied with most UNIX systems. The
most powerful and portable awk implementation
is GAWK (Gnu Awk), available from the Free
Software Foundation. Awk is a part of
the POSIX Command Language and Utilities
standard.

The Beginners All-purpose Symbolic Instruction
Code (BASIC) was designed by two professors
at Dartmouth University to be an easy first
language for programming neophytes.
Though the first version was compiled,
most Basic systems were interpreters.
Original Basic had a simple syntax that
included a line number for every source
line. Control structure mostly consisted
of GOTO ### and GOSUB ###; simple conditional
and bounded loop constructs were also
available. Original Basic provided numeric and array datatypes, but no strings, structures, or objects. Strings were added
to most early versions of Basic, but more
sophisticated data structures weren't added
until many years later.
Basic has enjoyed steady popularity and
usage since about 1965, and has evolved
greatly since then. Modern Basic dialects,
such as Visual Basic, eschew line numbers,
support objects, libraries, GUIs, databases,
optimizing compilers, garbage collected
dynamic memory management, and much more.
Basic was and still still is loosely typed,
and has poor support for enforcing program
portability.
Dialects and subsets of Basic are often
designed as extension or macro languages
for programming systems on PCs.

BCPL was an early block-structure
procedural language, fairly low-level,
and used for system and small application
programming in the early- and mid-1970s.
BCPL is an operator-typed language; the
data types of variables are defined by
the operators applied (rather than being
declared for the variable, as in Algol).
Data items were untyped cells
labeled with identifiers.
Data types supported by BCPL included
integers, reals, bit patterns, I/O streams,
various kinds of references, and
vectors. Strings
could only be used as constants.
The language supported simple control
constructs like loops and conditionals,
as well as means to declare subroutines
and functions.
The BCPL system library, which evolved
along with the language, provided I/O
support and very simple memory management.
Early versions of BCPL were
machine native compilers, but nearly all
recent versions have been translators.
In other words, the BCPL compiler
translates the BCPL code to an abstract
machine language called INTCODE. The
INTCODE data is then interpreted by a
simple, fast virtual machine (typically
coded in assembly language, C, or a
mixture of the two).
There were several academic implementations
of BCPL in Britain. Free versions are
available today for various Unix systems,
the Amiga, MS-DOS, and other operating
systems.

Befunge is an interpreted
low-level programming
language that uses a unique data model
and instruction set to perform
computations on a coordinate grid.
The Befunge machine model stipulates
the existence of a pushdown stack, and
a two-dimensional grid of cells. Each
cell can hold a data item, which may be
treated as an instruction or as data,
depending on program execution. The
"Instruction Pointer" can move in any
of four directions: up, down, left, or right.
Befunge's instruction set includes
stack manipulation, arithmetic,
rudimentary I/O, conditional
branches (both horizontal and vertical),
and many other operations.
In Befunge-93, the grid was fixed in size:
80x24, but Befunge-97 allows an unlimited-size
grid.
In Befunge-93, the data types
supported were 32-bit integers
and bytes, but Befunge-97
supports only machine-width integers.
Befunge-97 also supports a broad
set of interpreter directives (very
roughly analogous to assembler
directives or C preprocessor directives)
to help the programmer take advantage
of the larger grid.
Several free
implementations of both old Befunge-93
and newer Befunge-97 exist, some
explicitly for PCs and at least one that
is highly portable (based on Perl).
Fairly good documentation and some
example programs are available on the web.

BETA is a powerful object-oriented language
intended for application development.
It evolved in the Scandanavian object-oriented
programming community, which helped originate
object-oriented programming with Simula.
BETA language features include: strong type
checking, inheritance, concurrency,
object persistence, runtime type
identification, garbage collection,
polymorphism, and GUI support.
The syntax of BETA is somewhat like Pascal
and somewhat like C. Punctuation
symbols are used for many syntactic elements
in place of keywords, giving the code a
terse, compact appearance.

Origin:

Madsen et al, Aarhus Univesity, 1983

BLISS

Language type:

S - block-structured

Description:

Bliss was a low-level procedural language
developed and used by Digital Equipment
Corp. for system programming. Widely
used by DEC in development of OS software
and tools for PDP, DECsystem, and VAX lines of
computers roughly 1971-1988. No longer
widely used.
Bliss supported various datatypes, but
did not enforce strong type checking. It
had a very powerful macro system that was
heavily used in system coding, but which
made crafting a compiler for the language
more difficult. Because it was intended as
a system programming language, it had
features that allowed the programmer to do
what is taught in the 1990s as the compiler's
job: register allocation, data structure
packing definition, etc.

Origin:

Wulf, Russell et al, DEC, 1970?

BLooP

Language type:

S - block-structured

Description:

BLooP 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.
The interesting aspect of BLooP was that it
offered only bounded loop constructs, and
was therefore incapable of expressing
certain general recursive computations.

C is a fairly low-level block structured
language with good support for system
programming. C is renowned as the language
of the UNIX operating system, but in fact
is widely used in PC, Mac, mainframe, and
other computing environments.
The original C programming language, as
described by Kernighan and Ritchie, had
fair arithmetic support, simple data
structures, subroutines, conventional
flow control constructs, naked
memory pointers, simple but useful
I/O facilities, and a powerful
macro preprocessor. C was
standardized, finally, in 1990;
currently the ANSI ISO/IEC 9899 (as
amended) defines the C language. The
ANSI standard defines better data type
handling and subroutine declarations
for C, as well as standardizing on
minimum I/O and other library facilities.
Primitive data types supported in modern
standard C are: several sizes of integers,
reals, characters, pointers, and arrays.
C does not have strings per se, but
the language does have the convention that
an array of characters ending with a nul (0)
character can be treated as
a string. Data aggregation types in C are
structures (records) and unions.
The C language has no I/O facilities defined
as part of the syntax.
The ANSI C standard defines an extensive
but low-level
standard library, including I/O mechanisms.
The standard library was not really designed,
it evolved out of the standard library
functions supplied with C implementations on
Unix systems.
C is a powerful language for writing
tight, fast, highly tuned code in a
language far more portable than assembly.
C is low-level enough to write
device drivers, and high-level enough
to write GUI libraries.
Modularity in C is limited to one level
of subroutines: all C names exist either
at the global scope, file scope, or
subroutine local scope.
C has no built-in support for separation
of module interfaces from module
implementation, but a flexible set
of conventions for employing the
macro preprocessor to separate "header"
files and "body" files has evolved to
support this paradigm.
C was extremely popular in academic
and industrial computing thoughout the
late 1970s through the early
1990s, and still enjoys
a huge user community. The influence
of C and UNIX on each other, and the
pair of them on the rest of computing,
cannot be underestimated. C also had
a profound impact on the WWW: the first
web servers and web clients were all
written in C.
Free and commercial C implementations are
widely available; one of the most popular
free implementations is the GNU C Compiler
(gcc). Information about the language
is widely available on the web and in
books.

C# is an object-oriented language derived
from C, with some features from C++, Java,
and Visual Basic. C# was designed by
Microsoft, initially as part of their
.net initiative. Microsoft claims that
C# offers the power and richness of C++
with the productivity of Visual Basic.
As a language in the C family, C# offers
the usual complement of primitive types:
integers, reals, booleans, and characters.
It also supports objects and arrays.
Unlike Java and C++, C# hides some of the
distinction between primitive types and
object types by automatically 'boxing'
and and 'unboxing' primitive as objects.
C# is strongly types and provides extensive
compile-time and run-time checking; unlike
Java, C# supports C-style unsafe pointers,
but only within specially designate code
sections. C# supports a string type that
is an object, but otherwise tightly integrated
with the rest of the language (just like Java).
C# supports single inheritance, overloading,
overriding, reflection, and polymorphism. Overriding
must be done explicitly. Because C# was
intended mainly to support development on
Windows operating systems, the C# object
model is designed to correspond directly with
Microsoft's COM/DCOM object mode.
C# also supports an interesting mechanism,
called properties, that allow a coder to
expose object methods but permits the user
of those objects to treat them as object
data attributes, reminiscent of CORBA IDL
and the Self language. Other features
supported by C# include structs, indexers,
operator overloading, and control over
parameter passing.
C# is also designed to run on Microsoft's
Common Language Runtime (CLR), a Windows-oriented
set of standard packages and object libraries.
These standard packages available to C# include
a wide variety of data structures, I/O facilites,
network support, system interaction support,
GUI objects (highly Windows-specific), web
services, COM, and much more. C# fully supports
exception handling, although exceptions are
not always used consistently in the standard
packages.
C# provides garbage collection and automatic
memory management.
For creating code for handling GUI events
and other external triggers, C# offers a
novel form of delegation. This is probably
the most complex feature of the language,
and has not counterpart in C++ or Java,
although Objective-C has something equivalent.
Another novel features of C#, which is actually
part of the Common Language Runtime, is the
notion of Attributes. Attributes are meta-data
about code, communications from the programmer
to the compiler and run-time system. In C,
such things are often done with pragmas and
non-standard keywords; in Java, marker interfaces
are used. Attributes are much richer than any
similar capability in comparable languages. They
also add a very complex facet to the language,
one which many developers will not need. Fortunately,
it is possible to write many
C# programs without uses
attributes at all.
Currently, the only full implementation of C#
is provided by the Microsoft .net compilers.
Microsoft makes a command-line compiler available
free, under the unintuitive name of the
".Net Framework SDK". Other
implementations are under
development.

Origin:

Microsoft, 1999

Date:

Last updated 12/8/01

C*

Language type:

P - Parallel or Multi-programming

Description:

C* is a dialect of C featuring extended
syntax and semantics for supporting
parallel processing. It was designed for
application development on the Connection
Machine line of SIMD massively parallel
computers.
Two fundamental added features distinguish
C* from standard C: parallel data elements,
and parallel computation domains. Each
variable in a C* routine is either a 'mono'
(scalar) or a 'poly' (parallel) variable.
The programmer can define any number of
named domains, with domain-local parallel
and scalar variables, and then define
computations that take place in those
domains.
C* supports the same data types and
control structures as C.
C* is a commercial product, it was sold
along with the Connection Machine CM2 and
CM5 systems. No documentation seems to be
available on the web.

C++ is a fairly complicated object-oriented
language derived from C. The syntax
of C++ is a lot like C, with various
extensions and extra keywords needed to
support classes, interitance and other OO
features. C++ was originally developed
as an extension to C, but quickly
evolved into its language. Despite some
of the flaws it has inherited from C,
C++ is a very popular language for
application development on Unix systems
and PCs.
The C++ programming language
offers a very broad range of OOP features:
multiple inheritance, strong typing, dynamic memory
management, templates (generics),
polymorphism, exception
handling, and overloading.
Some newer C++ systems also offer
run-time type identification and
separate namespaces.
C++ also supports the usual features expected
of an application language: a variety of data types including
strings, arrays and structures, full I/O facilities,
data pointers and type conversion.
The C++ Standard Template Library (STL)
offers a set of collection and abstract
data type facilities.
Because it is derived from C, C++ has a
number of features that support unsafe
and defective software. The more
recent C++ standards do support safe
casts, but this feature is not yet
universally available or employed.
Also,
C++ has dynamic memory allocation, but
does not have garbage collection; this
allows programs to mis-use and leak
memory. C++ also supports
dangerous raw memory
pointers and pointer arithmetic. These
low-level facilities are useful in some
situations, but can increase the time
needed for software development.
Efforts at unifying the C++ language were
begun in 1989.
C++ was finally standardized by the ISO and ANSI
in November, 1997.
Information on C++ is widely available on
the WWW, but language has no official home
on the Web. Many C++ implementations
exist, some of them follow the old
tradition of translating C++ into C, while
others are native compilers. A few free
C++ compilers exist, the most notable of
which is the GNU C/C++ compiler, GCC.

Cecil is a pure object-oriented programming
language developed at the University of
Washington. Cecil was designed as part
of the larger Vortex project at UW, and
it is intended to provide a framework in
which large, extensible software systems
can be developed more easily. Some
other goals of the project are
orthagonality, efficiency, and ease-of-use.
The Cecil language is based on a simple
object model that supports multiple
inheritance and multi-methods,
dynamic inheritance, and optional static
type checking. Unlike most OOP systems,
Cecil allows subtyping and code inheritance
to be used separately, thus allowing
run-time or external extension of object
classes or instances. Like
Objective-C, all object services in Cecil
are invoked by message passing, and
the language supports run-time class
identification. These features allow
Cecil to support dynamic, exploratory
programming styles. Parameterized types
and methods (generics, polymorphism),
garbage collection, and delegation are
also supported.
Cecil also supports a module mechanism
for isolation of independent libraries
or packages. Cecil does not presently
support threads or any other form of
concurrency.
A standard library for
Cecil is also part of the project, it
includes various collection, utility,
system, I/O, and GUI classes.<
The latest version of the Cecil language
definition is 2.1, dated 3/97. Cecil
currently runs on Unix and Linux systems.

Cold Fusion Markup Language is a web
scripting language designed to support
dynamic page creation and database access
in a web server environment. It is
part of the commercial product Cold Fusion
Web Application Server.
The syntax of CFML is exceptional among
executable scripting languages: it consists
mostly of HTML-style tags for all
statements and control structures.
CFML is a weakly-typed language that supports
only a few primitive types: integers,
real numbers, strings,
and dates. Several aggregate types are
supported: arrays, lists, and
associative arrays (also called structures).
Control structures supported in CFML
include conditionals, several kinds of
loops, and simple exception handling.
Like many scripting languages, CFML
supports dynamic interpretation of string
data as code.
CFML does not offer the ability to define
subroutines, but it does support defining
custom tags which can serve in a similar
capacity.
Documentation about CFML is easy to obtain
on the WWW.
The only implementation of CFML is in
commercial products from Allaire.

CHILL is a block-structured compiled language,
standardized by the ITU, and designed for
building large robust software systems.
It is used mostly in the
telecommunication area.
Intended for supporting large software
development efforts, CHILL is a fairly
large and complicated language. Its data
type system is derived from that of Algol68;
CHILL offers various numeric types,
array and other composite types, references,
and various function, I/O, and process
synchronization data types. The language
is strongly typed: all data objects and
expressions are typed and type checking is
enforced. CHILL supports a full set of
sequential control-flow operators:
conditional, iteration, and goto.
Strangely, early versions of CHILL did not
support real numbers, only integers.
It also provides full multi-programming
and multi-processing support, as well as
I/O and timing features.
The syntax of CHILL is similar to related
block-structured languages like Pascal and
Algol. It has a large set of reserved
words.
CHILL supports features for building complex,
reliable software
systems: concurrency, exception handling,
and real-time response guarantees.
Several commercial CHILL programming
systems exist, but the only free
implementation seems to be GCC.
Some information about CHILL
is available on the web, but the actual
language standard must be purchased from
ITU or ISO.

Cilk is a dialect of C extended with
fine-grain parallelism. It was developed
at M.I.T. as series of research projects
studying parallelism and parallelizing
compilers.
All the fundamental data types and program
structures supported by C are also available
in Cilk. However, Cilk adds several new
keywords to C to support dynamic,
asynchronous multi-threading.
The main facilities that Cilk adds to C
are the ability to spawn function calls
in parallel, and the ability to synchronize
the parallel calls.
Cilk is available free in source form from
the Cilk Project web site. It runs on
multi-processor Unix and Linux systems, and
has also been ported to Windows NT.

Claire is an object-oriented language with
powerful functional and
logic rule programming features, intended
for language research and specialized
application programming.
As an object-oriented language, Claire
does support definition of classes and
simple (single) inheritance. The class
system is just a part of the complex
type system that Claire supports, and
which programmers can use to set up
complex rules and conditions on subroutines.
The syntax of Claire is terse, it makes
heavy use of
punctuation and grouping characters,
like {} and :>, as well as a set of
reserved words similar to that of C.
The syntax is also very sensitive to
correct use of white space.
The primitive data
types in Claire include various numeric
types and strings, as well as program types
like classes and rules. Aggregate data
types built into the language are lists,
sets, and generalized (associative) arrays.
Claire supports the usual sequential
control constructs like conditionals and
loops, plus
exception handling.
The language also supports implicit control
flow in the form of searching of rules
(like Prolog).
Programs are composed of modules, which
define separate name spaces. Modules can
be defined statically or created dynamically.
Claire has simple I/O facilities for
reading and writing data. It does not
have any support for multi-threading or
extensive operating system interactions
(which probably helps it stay portable).
The current version of Claire, as of early
2003, was 3.2, with 3.3 just released.
The Claire implementation
is written in C++ and Claire, and runs on
Unix, PCs, and Macintosh.
The Claire compiler, interpreter, and tools
are available for free download in source
form. Documentation is also available,
along with scholarly papers about applications
of the language.

Origin:

F. Laburthe, Y. Caseau, ENS Paris, 1995.

Date:

Last updated 1/10/03

Clean

Language type:

F - Functional or lambda-based

Description:

Clean was the name for an early
form of
Concurrent Clean, a pure functional
language designed at the University
of Nijmegen. Click on the link above to
view the entry for Concurrent Clean.

Date:

Last updated 1/2/98

CLU

Language type:

S - block-structured

Description:

CLU is a compiled imperative language
with extensive features for defining and
employing abstract data types. It was
intended for general application development,
and also as a research vehicle in computer
language design.
As was a descendant of Algol, CLU
offered syntax that was similar to Algol60
in many respects, but it added
data type abstraction, exception handling,
and other advanced features.
The name "CLU" is short for "CLUster",
this was chosen because a CLU program
normally
consists of procedures, clusters, and
interators.
CLU supported a number of advanced
features for structured languages for its day,
including garbage collection, a form of
inheritance, iterators,
strong typing, generics, and exception
handling.
The research operating system SWIFT
was written in CLU, as were other tools
and utilities.
A free CLU compiler named 'PCLU' is
available from MIT. There is also a
CLU->C translator named clu2c available
from Tokyo Tech. Some information about
CLU is available on the web, but not much.

Origin:

B. Liskov et al, 1974-77.

Date:

Last updated 2/28/98

CMS-2

Language type:

S - block-structured

Description:

CMS-2 is a general-purpose programming
language used almost exclusively for
real-time and embedded applications for
the US Navy.
A CMS-2 module consists of two sections:
a global
declarations "SYS-DD" block and a
code "SYS-PROC" block.
Both global and local data, as well as
procedures, can appear in the SYS-PROC block.
Depending on the compiler, there are
various facilities for source code inclusion
and cross-module linking.
Data types in CMS-2 include: integer,
fixed-point and floating-point numbers,
fixed-length strings, and enumerations.
Identifiers are strongly typed, but unlike
Pascal and Ada most versions of CMS-2
had facility for type declaration.
The only aggregate data type in CMS-2 is
the array.
CMS-2 has a conventional complement of
imperative control-flow statements, but
with peculiar syntax. Loop statements
offer special exit/resume facilities;
it is even possible to resume a loop
after having exited it! CMS-2 also
offers several kinds of index jump table
statements (like Fortran's computed GOTO
but more complicated).
Over a dozen implementations of CMS-2
were created in the 1970s and 1980s for
various US Navy system architectures.
A few are still available for sale today
through the Navy NUWC.
There do not appear to be a free compiler.

COBOL, the COmmon Business-Oriented Language,
has been in continuous widespread use since
the early 1960s. The name says it all; this
language was designed to meet the needs
of banks, manufacturers, bureaucracies, and
other big organizations with data handling
and report generation requirements. Its
verbose quasi-english syntax, and formidable
output formatting capabilities make
COBOL unique, and well-suited to its
niche.
A COBOL program normally consists of four
divisions: identification, environment,
data, and procedure. COBOL's environment division
is an attempt to make programs more portable
by forcing the programmer to enumerate all
in one place the
resources and facilities that the program
would require. Traditional
COBOL's feature set
is idiosyncratic: only static
data structures are supported,
numeric variables can be binary or
decimal, with extensive support for
range checking and output formatting,
extensive string manipulation support,
and simple flow-control constructs.
Record structures and arrays are the
primary means for organizing data,
but no pointers or references are
available. The language is very
often employed along with a database,
and most implementations include
extensive database support. COBOL's
support for complicated calculations
is modest, and some implementation don't
even support recursion.
COBOL was first defined in 1960, really
standardized by ANSI in 1974, and
the standard was revised in 1985. The
current standard is ISO/ANSI '85, but
a new standard is in review and
should be issued in 1998. The new
standard will have various OOP features
and more comprehensive computational
features. The intent is to modernize
COBOL while preserving the extensive
worldwide investment in COBOL software.
Several high-quality, mature commercial
COBOL compilers are available, mostly
for mainframe and Unix platforms. DOS
and Windows COBOL compilers also exist, but
there do not seem to be any free or
shareware compilers (not surprising
given the ANSI standard's size and
complexity).

Origin:

US DOD GPO, 1960; CODASYL Committee, 1960.

Date:

Last updated 12/1/97

Common Lisp

Language type:

F - Functional or lambda-based

Description:

Lisp is a quasi-functional language
characterized by s-expression syntax
and lists as it primary data structure.
Common Lisp is a standardized dialect
of Lisp, intended to be highly portable
and serve the needs of the Lisp programming
community. Most Lisp implementations
today are compliant (more-or-less) with
the Common Lisp standard.
As a standard, Common Lisp defines the
following facilities for the language:

Common Lisp grew out of an effort,
begun in 1981, to unify the fragmented
Lisp community. The first Common Lisp
book was written by Steele in 1984. In 1985, an
effort was started to standardize the
language in a formal setting, which led to
the development of an ANSI standard in 1993
and an ISO standard in 1994.
Both commercial and free implementations
of Common Lisp are widely available.

Concurrent Clean is a purely functional
strongly-typed language meant for
distributed and parallel-processing
application development. It can use
a lazy evaluation model, and supports
higher-order functions; it also supports
interfacing with legacy non-functional
languages and systems.
Basic data types supported by Clean include
integers, reals, strings, boolans, lists,
tuples, arrays, and higher-order functions.
Like Hope and other modern functional languages,
Clean allows multiple typed rules to be
defined for a given function name; a
pattern-matching process applies the correct
function rule for a particular set of arguments.
To allow modification of state
information and interfacing with non-functional
languages, Clean employs a polymorphic
uniqueness type inferencing system.
Clean supports several advanced facilities:
currying and higher-order functions,
module support with separate interface
and implementation, algebraic functions
with quantified variables, and even
a simple
compile-time macro
facility.
The U. of Nijmegen implementation of Clean is
the only one (as of early 1998); it is
available free for Macintosh, Windows, Linux
and Sun Unix. The portable compiler
generates textual ABC-bytecodes (roughly RTL-level),
which the platform-specific Clean code generator then translates
to a native executable.
Fairly good documentation
about the language is available at the
Clean home site, but most of it is in
downloadable PDF rather than HTML.

Origin:

Nöcker, Plasmeijer, Smetsers et al, Univ. of Nijmegen, 1984-91.

Date:

Last updated 1/2/98

Concurrent Pascal

Language type:

P - Parallel or Multi-programming

Description:

Concurrent Pascal is a dialect of the
structure Pascal language, extended to
support abstract data types,
multi-tasking, and monitors. It was
intended for operating system programming
and research.
The syntax of Concurrent Pascal was
essentially the same as that of original Pascal,
except for the added concurrency and ADT
features, and a few features omitted.
The language is strongly typed and
safe: variant records and pointers as
defined in original Pascal are not
supported.
Concurrent Pascal adds the following
fundamentally new features
to Pascal: process types, monitors,
class types (no inheritance), init and
cycle statements, and queues.
Some fundamental features of Pascal were
dropped: recursion, goto statements,
packed arrays, pointers, and file types.
Original versions of Concurrent Pascal
were implemented on various mini-computer
and mainframe hardware in the 1970s.
No versions seem to be available on the
web.

Origin:

P. Brinch Hansen, 1974.

Date:

Last updated 3/7/98

CORAL 66

Language type:

S - block-structured

Description:

Coral66 was a compiled structured programming
language, of the Algol family, used for
real-time system development.
Not much is available about Coral, but it
is described as a small, simple language
derived from Algol and Jovial.
It supported conventional control structures,
subroutines, and machine data types like
integers, floats, and pointers. It also
included a facility for adding in-line
assembly code, possibly due to its typical
use for writing embedded control software.
Coral was implemented for many different
mini-computers in the 1970s, and was
also available on the VAX under VMS.
No free Coral66 compilers seem to be
available today.

CorelSCRIPT is a dialect of Basic that
serves as the macro extension language for
many products from Corel Corp, including
their line of graphics products.
While the syntax of CorelSCRIPT is
nearly identical to that of Microsoft's
Visual Basic, it is distinguished by the
large number of built-in functions that
it provides for the end-user. In
versions of CorelDraw 6.0 and later,
for example, essentially every function
the drawing tool can perform is available
to the CorelSCRIPT programmer.
Also, Corel tools can compile scripts to
speed execution; this capability is
somewhat unusual for an application
macro language.
Like
the Visual Basic language systems it
resembles,
CorelSCRIPT is compatible with MS-Windows
OLE automation facility, allowing a
CorelSCRIPT program to invoke and control
any OLE-capable Windows application.
CorelSCRIPT is a commercial product
available only with Corel Corporation
products. Meager information about the
language is available on the WWW.

Origin:

Corel Corporation, 1994.

Date:

Last updated 12/10/97

csh

Language type:

C - Command or Scripting

Description:

Csh is an interpreted command and scripting
language designed and implemented as part of
the BSD Unix development effort.
It was primarily designed as an interactive
command language, but is also widely used
to automate system administration and
software development tasks in Unix
environments.
Csh supports only one
primitive data type:
strings. Csh has arithmetic operators
that can
treat strings as integers in some constructs.
Like other Unix shell language, csh
has two scopes for variables: local and
exported (environment).
All local variables in a csh program have the
same data type: a vector of strings.
All environment (exported) variables have
the same data type, string, as required
by Unix.
Statements in csh are normally delimited
by line boundaries, but semicolons may
also be used.
Control flow constructs supported by Csh
include if-then-else, two kinds of loops,
goto, a case statement, and a very
simple interrupt handling statement. All
of the flow control constructs, as well as
the expression syntax, are modeled
roughly
after those in the C programming language.
Unlike most other programming language,
csh has no explicit syntax for subroutines.
Instead, each separate csh source file can
be treated as a kind of subroutine.
Csh is available on essentially all Unix
and related operating systems.
Despite its wide use, good tutorials on
C shell programming are not widely
available on the web. Good books on
shell programming are available.

Date:

Last updated 2/15/98

CSP

Language type:

M - Mathematical or Simulation

Description:

CSP is a simple and elegant language for
describing parallel computations and their
interactions. It evolved from a formal
notation used to discuss communicating
independent entities into a formal
language for describing parallel systems,
simulating them, and reasoning about them.
CSP offers a modest set of conventional
computer language features: numberic
variables, symbols, and the usual
sequential control structures. CSP's
strength is in its support for defining
parallelism: definitions of processes
and communcation buffers.. The
fundamental notion
of a guarded command was introduced by
CSP, and serves as a powerful model for
regulating and synchronizing concurrent
processes.
All of the facilities in CSP were
carefully chosen to permit formal proofs
about deadlock-freedom and other properties
of CSP models.
Because CSP was invented as a formal
notation, without many practical features,
implementations are rare. Information
about CSP is available scattered around the
Internet, but journal articles and books
have much more detail. One commercial
implementation of CSP is used for
verifying digital logic design.

cT is an algorithmic scripting language
intended for building animations, user
interfaces, and multimedia presentations.
Data types supported by cT include integers,
reals, strings, booleans,
arrays, and a variety of
multimedia types.
Control structures include if-then, simple
loops, simple subroutines, and
event-driven execution.
cT is supported by a large library of
built-in commands for handling images,
videos, sounds, fonts, and other kinds of
graphics data, file I/O,
network communication, and system
interfacing.
For portability,
cT programs are compiled into a
binary intermediate form, to be run
by the "cT executor". This is similar
to the approach used by Java, except that
re-compilation on each platform is
recommended.
The cT language is supported by a comprehensive
programming environment that provides
incremental compilation, interactive
debugging, and a visual editor.
cT is available free for Unix systems (X11) from
CMU. It is available commercially for
Windows and the Macintosh.

Curry is a fairly recent functional logic
programming language, developed as a
research vehicle to test ideas in
the areas of narrowing, unification, and
non-determinism. It has also been
used to teach
logic and functional programming principles.

The syntax of Curry is complex, compact,
and similar to
that of Haskell. Each statement
of a Curry program is an equation or
predicate. Executing a Curry program
consists of simplifying equations and
expressions until a particular specified
goal is reached or a particular solution
is obtained.
Primitive data types
supported by Curry include
booleans, integers, reals, chars,
and strings. Aggregate and specialized
data types include tuples, lists, functions,
and constraints. Oddly enough, Curry uses
the same comment syntax as Ada.
The module construct serves to encapsulate
libraries of functions, data types,
and expressions. The
module seems to be the only program
structuring facility in Curry.

Dylan is a dynamic object-oriented language with
both procedural and functional features,
intended for application development and
system programming. It was developed
by Apple Computer in the mid-1990s.
The name stands for DYnamic LANguage.
The language syntax for Dylan is original,
but structurally resembles Scheme. The
language offers inheritance, type-safety,
polymorphism, garbage collection, macros,
modularity (named modules), reflections,
error handling,
multi-methods, and extensibility.
Data types defined by the language include
a variety of numbers, strings, symbols,
various collections such as sequences, arrays,
vectors, and hash tables.
In Dylan, as in Smalltalk, everything is
an object. Even numbers are organized into
a class hierarchy. Functions are also
objects, and support a large number of
interesting mechanisms including
composition, currying, mapping, and reduction.
Classes are also objects, with support
for dynamic class definition and other
advanced OOP techniques.
Dylan facilities for GUI and database
programming have been implemented, and
most implementations of the language
permit interfacing with external C/C++
libraries.
Implementations of Dylan are available for
most platforms including Unix, Macintosh,
and Windows. Dylan has been implemented as
an interpreter, as a C front-end, and as
a native compiler. Both free and
commercial systems exist. Some commercial
Dylan implementations provide a visual
development environment.

Dynace is an object-oriented extension of the
C programming language, designed for
general application development.
Dynace uses the same base data types
and control constructs as C. It adds the
following OOP and other advanced features
to C: abstract data types, classes with multiple
inheritance, run-time type ids, generics,
garbage collection, multi-threading
and synchronization, and reflection.
Dynace is a weakly typed (actually,
value typed) language like Smalltalk -- all
objects are run-time type identified and
type rules are checked during execution.
This is similar to other dynamic OO language
systems like CLOS (Common Lisp Object System)
and Self.
There is currently only one implementation
of Dynace, the commercial version from
Algorithms Corp. Source code for the
language processor is available for
download from the corporate web pages,
although the product is not freeware.
Documentation about the language is
also available at the web site.

Eiffel is an object-oriented language
intended for general application
programming. Its syntax is superficially
similar to C. Eiffel offers a broad
range of OO programming features:
inheritance, polymorphism, assertions,
exception handling, packaging,
generics, and strong type checking.
Eiffel is available from Interactive
Software Engineering, Inc. Their
commercial Eiffel system compiles Eiffel
to interpretable bytecodes
(similar to the way Java is compiled), but
for efficiency, the bytecodes are usually
translated into C code and compiled with
platform-specific C compilers.
Newer versions of the Eiffel system
include support for interfacing to
other languages, and to popular
distributed computing schemes like
COM and CORBA.

Elisp is a dialect of Lisp that serves
as the scripting and extension language
for GNU Emacs, a very powerful text
editor. Elisp is a full Lisp system, but
does not conform closely to any particular
Lisp language standard.
Because it was designed to support creation
of new functionality for the Emacs editor,
Elisp has a broad set of string and text
handling operations, as well as special
functions and data types
for controlling the editor and interacting
with the user. In terms of syntax,
Elisp is close to Interlisp, but the
syntax of some Lisp constructs is
modified to support in-line documentation
of editor functions. Early
versions of Elisp lacked many standard
parts of conventional lisps, such a macros
and floating-point numbers, but newer
versions have these features as well as
many Common Lisp elements.
The Elisp engine, which is really the
core of GNU Emacs, is written entirely
in C. There is no Elisp compiler, but
GNU Emacs can pre-parse Elisp code into
simpler byte-codes that speed loading.

Erlang is a functional programming language
with concurrency and object-oriented programming
features. It was designed for application
software development, especially large
real-time systems.
Erlang uses declarative syntax and
pattern-matching rules for function
application. This is similar to the
approach used by Prolog, Hope, and other
applicative language. Computations in
Erlang are mostly side-effect free.
The language is also designed to support
concurrency and distributed computing,
but does not support higher-order functional
constructs like currying or lazy evaluation.
Expressions and functions in Erlang are
generally untyped. Data types supported
by the language include integers, reals,
atoms (which also serve as string data),
tuples, lists, and process identifiers.
Tuples and lists can be heterogenous.
Functions in Erlang are defined with
patterns. Pattern matching is used for
assignment and for function application.
Functions belong to modules, which
constitute separate namespaces. Functions
must be explicitly exported from modules
to be usable from other modules.
Erlang supports multiple threads per
process and multiple processes.
The concurrency model in Erlang is
strictly message-based, there is no
shared memory.
The first implementation of Erlang was
an interpreter written in Prolog, but
all current implementations are compilers.
As of late 1997 the main Erlang
implementations come from
Ericsson Telecommuncations Systems in
Sweden.
Commercial Erlang is supported on a wide
variety of CPUs and embedded operating
systems. Free Erlang is available for
non-commercial use and runs
on Windows and some Unix platforms.
Documentation is available on-line, and
with the distributions.

Escher is a declarative programming language
that supports both functional programming
and logic programming models. It was
designed mostly as a research and teaching
vehicle.
The basic view of programming exhibited by
Escher and related languages is the a program
is a representation of a theory in some
logic framework, and the
program's execution (computation) is a
deduction from the theory. The logic
framework for Escher is Alonzo Church's
simple theory of types.
Primitive atomic
data types defined for Escher include:
booleans, integers, characters, and
program elements (such as functions).
Other data types provided by the base
language are strings, sets, and lists.
Real numbers are apparently not supported.
Like most declarative languages, Escher
supports declarations of data relationships
and rules, which imply various computations
during program execution.
Escher supports I/O through a monadic type
representing the 'outside world'. This is
more-or-less conventional for modern
declarative languages.
One of the goals of Escher's designers was
to support meta-programming, and so the
language has comprehensive support for
generating and transforming programs.

The Esterel language is a modeling
and specification language designed for the
programming of synchronous reactive systems.
Developed in an academic setting, it is
used for studying parallel computation and
also for analysis and implementation of
digital hardware.
Because Esterel is specialized for
representing reactive, signal-driven
systems, it has two fundamental kinds
of objects: data elements and signals.
Data elements correspond to variables
in conventional structured languages,
and may be declared at module or local
scope. Signals and sensors are dynamic
values that correspond to the
interactions of the system being modeled
with the outside world.
Primitive data types supported by Esterel
include booleans, integers, reals, and
strings.
Esterel supports several mechanisms of code
organization: modules, procedures, functions,
and tasks. Parallelism and condition
handling must be explicitly specified.
Synchronization is normally provided by
reacting to external signals, using the
await statement or by testing
for sensor values; output can be specified
with the emit statement.
Esterel also allows a programmer (engineer)
to assert exclusion and synchronicity
relationships about signals.
The Esterel compiler and verification tools
are available free from INRIA, France. They
run on a variety of Unix systems.
The current version, as of late 1998, is
Version 5.

Euphoria is an interpreted block-structured
language for PCs. It is intended for general
application development and game
programming.
The data model used by Euphoria is quite
simple: all data elements are either atoms
or sequences. All atoms are numeric: chars,
ints, or floats. Sequences can be any length
and can contain atoms and other sequences.
A string is simply a sequence of characters.
More complex data structures can be built
up from nested sequences (as in Lisp or Scheme).
Indexing and slicing are important
features, as is the ability to distribute
scalar operations over sequence members.
Euphoria performs type checking,
to the extent that it can with only two
types, and also enforces sequence index
bounds and function return values.
Lastly, Euphoria allows a programmer to
define abstract data types operationally,
by declaring for each such type a
boolean function that determines type
membership.
With its line-based syntax and simple
data model, Euphoria is intended to
be a very easy
language to learn.
Euphoria supports rather
conventional sequential control features:
conditionals and loops. It does not
support any advanced features like
threads, exceptions, or higher-order
functions.
The Euphoria language system
and documentation may be downloaded free
from its web site (see below), with
modest documentation and some demo programs
included. Information is also available
at other Euphoria advocacy web sites.
The current implementation
runs only on Windows, DOS,
and OS/2.

Origin:

R. Craig, Rapid Deployment Software, 1993?

Date:

Last updated 3/25/01

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:

Hofstader, 1979 (implementation: Cowan, 1994)

Date:

Last updated 12/6/00

FORMAC

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.

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.

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.

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

Date:

Last updated 7/9/01

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.

Gödel is an interpreted declarative
language based on typed first-order logic.
It was designed as a research vehicle, and
also as a language for teaching logic
programming.
Data types supported by Gödel include
integers, rational and real
numbers, sets, strings, tuples, and symbols.
The language is strongly typed, and the
type mechanisms play an important role in
declaring predicates.
Unlike most logic-based languages, Gödel
has a module system and cross-module
type enforcement.
Gödel is also intended for research
into program generation and transformation,
parallel constraint programming, and
meta-programming.
The only existing implementation of the
language was written on top of Prolog.
A substantial
implementation of Gödel is available in source
form, as well as binaries for various
Unix systems. Some documentation and
example programs come with the distribution,
but real descriptions of the language are
limited to hardcopy books.

Origin:

P.M. Hill & J.W. Lloyd, 1994.

Date:

Last updated 2/19/98

GPSS

Language type:

M - Mathematical or Simulation

Description:

GPSS, the General Purpose Simulation System,
is a family of mostly-declarative languages designed
for discrete-event simulation and system
modelling.
A GPSS simulation program consists of a
set of blocks, and connections between them.
Block types include generators, queues,
servers, selectors/routers, data
collectors, timing and computational nodes, and
various other types. Data types supported
in simulation models varied between
versions, but usually included integers,
reals, strings, and records. GPSS systems
always had sophisticated random sample
generators to model various probability
distributions that arise in modelling of
real-world processes.
Some versions of GPSS are still available
for sale commercially, no free versions
seem to be available. Documentation for
the language is not easily available
on-line.

Haskell is a non-strict purely functional
language, usually interpreted, designed
by representatives of the functional
programming community. The motivation
for Haskell was unification of functional
programming through the introduction of
a standard, widespread, modern language.
Haskell is a strongly typed language with
a rich type system. As in all functional
language, computations are performed only
by expressions; every expression has a
type. Primitive data types supplied by the
language include: integers, reals, characters,
lists, enumerations, tuples, and various
function
mappings.
Haskell language implementations perform
static type checking prior to execution.
Haskell functions are defined as mappings
between parts of the type space. Of course,
composition, curried functions, lambda forms,
and higher-order functions are supported.
Haskell uses lazy evaluation.
It
also permits definition of operators as
functions (operator overloading), a convenience
feature that is unusual in functional programming
systems.
Modularity is explicitly supported by Haskell.
Programs consist of named modules. The
module facility provides distinct namespaces
and a means for defining encapsulated
abstract data types.
Haskell's module features allow some degree
of object oriented programming.
The Haskell standard library is written
using the module facility. It provides
additional numeric data types, various
standard aggregate types like arrays
and lists, system
interface and I/O facilities, time and date
handling, and random number generation.
Several free academic implementations of
Haskell are available, and good documentation
is available at the main Haskell web site.

Hope is a small, simple functional language
based function composition and
on the idea of 'call-by-pattern.'
A Hope program consists of a set of
modules, each of which can contain
sets of recursion equations.
Current implementations of Hope
use full lazy evaluation.
Unlike some of the original functional
languages, Hope is strongly typed.
There were a couple of dialects of Hope,
corresponding to different
groups' implementations. The one that seems
available today was originally called Hope .
Data types supported by Hope include
numbers, symbols, strings, lists, and tuples.
(Constituents of a list must be
all the same type, while tuples can
be heterogenous.) A Hope programmer
can define their own primitive and
aggregate types. This ability to
create true abstract data types is
a novel feature in functional languages.
Modern implementations of Hope use
lazy evaluation.
A free implementation of the Hope
interpreter is available for
MS-DOS, Unix, and Macintosh.

HyperTalk is the scripting language for
Apple's information presentation
system HyperCard. It has a simple and
English-like syntax, a modest set of
general and application-specific
data types, and the usual procedural
control structures. HyperTalk was
designed to allow HyperCard information
collections, which are called "stacks",
to be more dynamic and interactive.
Because Apple envisioned the users
of HyperTalk to be multimedia developers
and not traditional programmers, they
HyperTalk interpreter was designed to
be very forgiving: it allows various
syntactic sugar, type conversion is
automatic, and everything is case-insensitive.
Most of a HyperTalk program will often
consist of handers, subroutines to be
called when the end-user performs some
action or when a certain condition obtains.
HyperTalk supports the notion of
add-on 'external' functions and
commands; these are roughly analogous
to library modules in a language like C.
HyperCard 2 compiles individual HyperTalk
functions into intermediate codes the
first time the function is called. This
is done to reduce start-up time for
HyperCard applications.
There are several versions of HyperTalk.
The two main versions from Apple
correspond to HyperCard releases 1 and 2.
Aldus SuperCard supports a superset of
HyperTalk called SuperTalk.
Commercial implementations of both
are available for the Macintosh. At
one time, SuperCard was also available
for MS-Windows, but that may not be
true anymore.

ICI is an interpreted structured language
reminiscent of C. It is essentially
a scripting language, intended for application
development.
ICI's syntax is similar to that of C, but
it provides a high-level data model intended
to reduce programmer effort and errors.
Primitive data types in ICI include
integers, reals, strings, files, safe
pointers, and regular expressions.
Aggregate data types are arrays, sets,
and associative tables. Sets
can be heterogenous, nested, and support
the usual set operations: union, intersection,
etc. All data structures in ICI
are dynamic, and the language environment
provides memory management and garbage
collection. Control structures in ICI
include the usual loops and conditional
statements, plus a simple error
handling construct. The language supports
subroutines and nested modules. All variables
are lexically scoped at the subroutine
or module level, but unlike most
structured languages, ICI allows the
current scope to adjusted (Tcl, for example,
also allows this).
Although ICI is not object-based,
many object programming features can be
emulated in the language by using data
structure inheritance feature called
super-structures.
To support application development, ICI
has C-like file I/O and system interface
support, as well as a high-level event
trigger facility. The language also has
a modest standard library of built-in functions.
There is only one implementation of ICI;
the current version is 2.02, and it
runs on Unix systems, DOS, Windows, Macintosh,
and some other computers. Documentation
is spare and somewhat outdated, and is
available for download but not on-line
browsing.

Icon is a procedural language with
high-level semantics for string and
data aggregate processing. The language
definition includes a large number of
operators and funtions for manipulating
strings and sequences, as well as novel
semantics: conventional imperative control
structures and goal-directed backtracking.
Built-in data types in the language
are integers, reals, strings (text),
sets, lists, arrays, associative tables,
files, and records. Icon variables
are typed, but the language
performs automatic type casting, so
it cannot be said to support strong
type checking in the sense of Ada or
Modula-2.
Icon also supports a very simple
form of exception handling; procedures
can return one or many values, or they
can fail. Failures do not automatically
propogate up the procedure call stack as they
do in Java or C++.
Icon is not object-oriented, but an
object-oriented extension called Idol
has been available since 1996.
Icon is normally interpreted, but there
is also a translator that generates
compilable C code from Icon code. Icon
was originally implemented for UNIX, but
has been ported to VMS, MS-DOS, 32-bit MS-Windows,
OS/2, and the Macintosh.
Icon is distributed with a
standard library; most platforms also
support a GUI library. The
Icon distribution also includes example
programs and documentation. Icon
implementations are available free from
the U. of Arizona ftp site.

Intercal is a compiled language deliberately
designed to be convoluted,
difficult to program, difficult to read,
unlike all other languages, and yet still
computationally complete.
The syntax of Intercal does not resemble
any other computer language, but does
in some respects resemble the appearance of
a FORTRAN program recovered from a bad
disk sector and then sent through a cheap
fax. Only two primitive data types are
supported: 16-bit and 32-bit unsigned integers.
Intercal supports arrays, but no other
data structures. Intercal provides exactly
five primitive operations on data:

binary bit-level interleave

binary bit selection with packing

unary bit-wise and

unary bit-wise or

unary bit-wise exclusive-or

Strangely enough, this set of operators
can be used to build normal integer
arithmetic.
Data-flow constructs in Intercal are
similarly conventional, that is to say, unique.
One kind of Goto is provided that pushes
its return address onto a fixed-size stack.
Mechanisms for disabling statement, both
unconditionally and with fixed probability,
are also provided.
Later versions of Intercal also provide
the unique 'Come From' statement. While
Intercal does not support subroutines,
a similar facility can be constructed with
some effort.
Intercal does provide I/O, after a fashion.
The original edition of the language could
read and write only numbers, and had the
interesting disability of being totally
unable to read in its own output. Later
versions of Intercal provide a bit-oriented
I/O facility that based on a model of the
differential movement of a Turing machine
tape.
The Intercal reference defines a standard
library for operations that are difficult
to implement in the language, like
addition, subtraction, multiplication, and
random number generation.
Intercal was originally implemented for
IBM mainframes, but since about 1990 a
version called C-Intercal has been available
for Unix platforms. An implementation is also
available for MS-DOS. Information about
Intercal is freely available on the web,
and documentation and sample programs are
included with the distribution.

Origin:

D.R. Woods and J.M. Lyons, 1972.

Date:

Last updated 2/18/98

Interlisp

Language type:

F - Functional or lambda-based

Description:

Interlisp was a dialect of Lisp, derived
from BBNLisp, that was used for
research at Xerox PARC. Various
implementations were made for different
computers, the most popular and influential
of which was Interlisp-D.

J is a interpreted
mathematical/functional programming
language very closely related to APL.
Basically, it is a dialect of APL
with the same functionality, but employing
the ASCII character set instead of APL's
original unique character set.
Commercial and free implementations of
J are available. Excellent documentation
and programming libraries are also freely
available on the web.

Java is a full-featured, portable object-oriented
language designed by research staff at
Sun Microsystems. The feel of the
Java language is fairly similar to that of C++,
but it also borrows ideas from Modula-3,
Mesa, and Objective-C.
The feature set of Java is fairly broad:
it has inheritance, strong type checking,
modularity (packages), exception handling,
polymorphism, concurrency, dynamic loading
of libraries, arrays, string handling,
garbage collection, and a pretty extensive
standard library. The newest version of
the language, Java 1.5
(aka Java 5.0), includes generics,
annotations, auto-boxing, var-args, as
well as many additional standard libraries.
The fundamental structural component of
a Java program is the class. All
data and methods in Java are associated
with some class, there is no 'global'
data or functions as in C++. Classes
can be members of packages; package
and class membership help determine
scope and visibility of data and methods.
Java does not include features that its
designers felt would compromise the
similicity or safety of the language, so
Java has no true pointers, no true
multiple inheritance, no operator
overloading, and no macro preprocessor.
The lack of multiple inheritance could
have been a serious shortcoming, but Java
does support the definition and interitance
of multiple stateless "interfaces", which
serve for most areas where multiple
inheritance might be desired. Java had
no facility for generic functions, but
that was added in Java 1.5.
The Java standard library packages
include extensive I/O facilities, a
comprehensive GUI toolkit,
collection classes, date/time support,
cryptographic security classes,
distributed computation support,
network interfaces, CORBA support,
XML support, and system interfaces.
Java is typically compiled to
platform-independent byte-code. These
byte-codes must be interpreted by a
Java Virtual Machine (JVM), which may
choose to compile the byte-codes further
into native machine instructions.
There is a strict definition of the
Java byte-code file format, the .class
file format, which ensures portability
of compiled Java classes.
In additional to normal application
development, Java is used to develop
embedded programs, called 'applets',
for web browsers and
other Java-enabled platforms.
This capability is an important part
of Java, and the standard library
packages include a security manager
to restrict the capabilities of Java
applets. These applet facilities
were important to Java's widespread
adoption and popularity.
Commercial Java compilers and development
environments are readily available; among
the most popular are products from Symantec
and Microsoft. Javasoft supports and
distributes a 'reference' Java implementation
known as the J2SE, it is free.

JavaScript is a loosely typed scripting
language with object-oriented and
block-structuring features. Invented by
Netscape Communications for adding
dynamic behavior to
web pages, JavaScript was originally
called 'LiveScript'.
The syntax of JavaScript is similar
to that of C or Java, but simpler
and not as rich.
Primitive data types include integers,
reals, strings, and a associative arrays.
Javascript is loosely typed, any variable
can contain data of any type, and conversion
is mostly automatic.
The language
definition includes extensive
facilities for controlling and manipulating
parts of web pages, especially HTML
forms.
Each version of Netscape Navigator has
brought a new version of JavaScript, and
later versions also include a complicated
security model for restricting the hostile
capabilities of scripts embedded in web
pages.
Microsoft web browser also support
Javascript, but under the name "JScript".

Origin:

Netscape Communications Corp, 1994.

Date:

Last updated 12/29/97

Jovial

Language type:

S - block-structured

Description:

Jovial is a block-structured procedural
language derived from early versions of
Algol. It provided Algol-like data types
and syntax, with structural extensions for
large-scale software engineering and for
real-time systems.
Jovial is standardized. The original 1973
specification was US MIL-STD-1589, and
the most recent 1984 edition of
the language standard is
MIL-STD-1589C.
At least one commercial JOVIAL is still
available, and others are certainly
still in use
at various aerospace companies.
Detailed information about the language
does not seem to be available on the web.

Leda is a modest-sized programming language
designed to support several programming
approaches. The current Leda implementations
are interpreters, but the language can be
compiled. Leda was intended mostly as a
teaching and research tool, although it
can be used for general application development.
Multiparadigm programming is the reason
for Leda's existence; the language supports
four programming mindsets:

Imperative (structured) - the programmer can set up
subroutines, use strong type checking, and
information hiding.

A fairly small language, Leda supports a
modest but eclectic
set of primitive data types: integers,
strings, reals, functions, and
relations (rules). Arrays are also
available, and other aggregate
data types are provided by a standard
library.
Leda supports the usual sequential
control structures, and more novel
structures can be built up using the
functional and logical portions of the
language. Strangely, Leda does not
possess any non-local
exception or error handling facility.
Leda's I/O facilities are rudimentary,
although the language provides an escape
mechanism out to system libraries that
could be used to take advantage of more
sophisticated I/O facilities on many
operating systems.
An implementation of Leda is available free
for Unix and Windows 95/NT. Pretty good
information
about the language is available on the web
as scholarly papers and chapters from a
programming textbook.

Origin:

T.A. Budd, Oregon State University, 1988.

Date:

Last updated 3/1/98

LIFE

Language type:

L - Rule-based or logical

Description:

LIFE is an interpreted logic programming
language, related to Prolog, with features
for functional and object-oriented programming.
Intended mainly as a research vehicle, LIFE
integrates inheritance, functional,
and constraint rule programming
styles into a logic programming framework.
The syntax of LIFE is similar to that of
Prolog, and its logic semantics are also
related to Prolog. Prolog uses
indexed Herbrand terms as its primary
data element, but LIFE uses extensible
psi-terms. Primitive data
types supported by
LIFE include booleans,
integers, floats, symbols,
strings, and sorts (a sort is a kind of
type descriptor). In addition to
psi-terms, LIFE supports lists with
the same syntax as Prolog.
As a functional language, LIFE supports
higher-order functions, currying, and
similar operations. It does not support
lazy evaluation.
An implementation of the LIFE language is
available for free download, it is written
in C and works on Unix
systems. A programmer's manual and various
scholarly papers are also available.

Limbo is a block-structured, procedural
language intended for application and
embedded system development. It is
the main programming language of the Lucent
Inferno operating system.
The distinguishing characteristics of
Limbo are its simplicity, its support
for modularity, and its support
for multi-threaded and distributed
processing.
Limbo is strongly typed, all variable
and function types are explicitly declared,
and type checking is performed at compile-time
and module load-time. Primitive data
types in the language are ints (3 sizes),
reals, and strings (using Unicode).
Limbo also supports
lists, arrays, tuples, channels, and
definition of abstract data types.
A Limbo program is comprised of
separate modules, the interface and
implementation of a module are separate
and one interface can have several
implementations.
(Inheritance is not supported, though, so
Limbo cannot be considered and
object-oriented programming language.)
The current Limbo compiler produces
byte-codes that are either
interpreted directly or transformed into
native code on-the-fly by the Limbo
run-time engine. The Limbo run-time system
provides all channel and process management,
as well as memory management and
garbage collection.
I/O and system interface facilities are
provided by a set of standard 'library'
modules.
Limbo's run-time environment
has been ported to various Unix
editions, Windows, Plan9, and other
operating systems, as well as directly onto
various CPU architectures.
The Inferno system is available free from
Lucent, but requires registration.

Origin:

Doward, Winterbottom, and Pike, Lucent Technologies, 1996.

Date:

Last updated 8/5/08

Lingo

Language type:

A - Application/Macro

Description:

Lingo is the application scripting and
extension language used in Macromedia
Inc. authoring and presentation products.
It is a procedural, event-driven language
with English-like syntax and some
object-oriented programming features.
Lingo supports a small set of data types
primitive data types: numbers, strings,
and lists. Lingo also support objects;
the language is defined with a large
set of pre-defined object classes that
pertain to the language's application domains:
multimedia, animation, and user interaction.
Lingo also supports definition of new
object classes, a kind of simple
polymorphism, and a form of delegation.
Lingo does not support persistence or
multiple inheritance.
In Lingo, objects store all of their data
on property lists, and also can act on
certain kinds of events (such as mouse clicks).
The only implementation of Lingo is the
commercial one supplied by Macromedia with
its Director product and related products.
Documentation from the vendor is modest,
but several good books about the language
and its use in the Director environment are
available. General information about
Lingo on the WWW is not widely available,
but some does exist.

Lisp is an extremely rich and powerful
programming language that has enjoyed
continuous use and popularity since the
mid-1960s. Typically, Lisp programming
systems are interpreters, but compilers
are also commonly used.
The Lisp language is founded on the
representational power of "S-expressions",
and employment of functional composition
and recursion. Lisp is a weakly typed
language with excellent support for
reflection and on-the-fly code generation
and interpreting. The language's extreme
flexibility, expressive power, and its
ability to treat code as data, made it
the undisputed king of Artificial Intelligence
research for all of the 1970s and 1980s.
All Lisp implementations since the late 1960s
have offered a set of programming features tough to
equal in any language, even today: macros, string handling,
recursion, closures, reflection, packaging, arrays, and
extensive IO facilities.
Modern Lisp systems support object-oriented
programming, database access, GUI construction,
and all other forms of general-purpose
programming. A very mature language, Lisp
is extremely well-documented, and the
most widespread dialect, Common Lisp,
is also
codified by ANSI and international standards.

Logo is a functional language designed
teach programming and problem-solving
principles to children. It is a
functional language, related to Lisp,
with a simple
syntax and a graphics-oriented feature
set.
The Logo language provides a set of
built-in procedures, a means to create
new procedures, a simple data framework
with symbols, numbers, and lists,
and simple control structures. The
language is surprisingly small, but
like Lisp can be used to create very
complex behavior.
A central concept in Logo is the turtle.
Logo was designed for use with a graphics
display, and the turtle wanders around
the display under the control of the Logo
program, drawing lines. Some of the
most fundamental statements in Logo move
and rotate the turtle. By using Logo's
recursive nature, a programmer can cause
the turtle to draw all sorts of figures.
Commercial and free
implementations of Logo are available
for PC/Windows, Macintosh, and UNIX
platforms.
New releases of Logo
implementations in 1993 and later have
added sound, images, and multi-tasking
to the basic language. Massively
parallel, hardware-embedded, and
object-oriented extended implementations
of Logo have also been developed.
Logo has been used primarily for
education, but has also been employed
for AI research, robotics, and graphics
creation.

LotusScript is a
dialect of Basic used as
the application extension and macro language
for Lotus's line of office automation
software. It has some object-oriented
programming features and extensive
application integration and interface
facilities.
Data types available in LotusScript
include integers, reals, strings, arrays,
records, and objects. The language
supports conventional procedural
constructs with simple Basic-style syntax.
The language is not strongly typed, but
does do some type enforcement for
objects.
LotusScript employs a high-level
simplified event
model to invoke subroutines and functions
in response to user input and application
activity.
LotusScript is included as part of the
Lotus commercial products it serves to extend.
Documentation for the language
is available from
Lotus's web site and elsewhere on-line.

Lua is an interpreted structured
language designed for embedding into other
applications. It is intended for use as
an extension and scripting language,
especially for applications with
requirements for structured data storage.
Because it is intended for use as an
application extension language, Lua does
not have the notion of a 'main' program
or initial entry point; instead, all code
is assumed to be invoked from the host
application.
The syntax of Lua is somewhat similar to
that of Pascal, but the data type system is
quite different. Like many scripting
languages, Lua is loosely typed: variables
need not be declared, and may hold any kind
of value. Data types supported by Lua
include real numbers, strings, functions,
and tables (associative arrays). Lua
also has a distinguished 'nil' value type,
and an extension data type called
'userdata' that can store C pointers
for use by the host application.
Lua associative arrays subsume other data
types like arrays and tuples, just as they
do in Javascript.
Control structures supported by Lua include
various conditional and looping constructs.
The language has
no error handling constructs, instead
errors are usually
routed to pre-defined handler functions.
Like Perl, Lua support multiple return values
from functions and variable numbers of arguments
to functions.
Scope is very simple in Lua: all variables
are either global, or local to a particular
block. The default is global, local
variables must be explicitly declared so.
Function definitions are just assignments
to global variables.
Data values in Lua are tagged to support
specialized extension by the host
application. Tags can be used to define
special handling for data types, or to
set up inheritance or delegation relationships.
There is only one implementation of Lua,
written in C. It is available free, in
source form, on
the web. The Lua reference manual is
also available.

Origin:

W. Celes, R. Ierusalimschy, L.H. de Figueiredo, PUC-Rio, 1994.

Date:

Last updated 6/1/98

Lucid

Language type:

P - Parallel or Multi-programming

Description:

Lucid is a dataflow programming language
designed to experiment with non-VonNeumann
programming models. It has fundamentally
different semantics from a language like C
or Lisp: in Lucid the programmer defines
filters or transformation functions that
act on time-varying data streams.
Lucid supported a very small set of data
types: integers, reals, and symbols.
The syntax of Lucid was deliberately design
to be unusual and different, to prevent
programmers from applying procedural-programming
habits that might be inapplicable, and
to sustain the illustion of data flows
as infinite objects.
Lucid also employed several techniques
from functional programming: lack of
side effects, and lazy evaluation.
Lucid evolved greatly in the 1980s and
1990s. The current evolutionary step
of Lucid
is called GLU (Granular LUcid). It
supports high-level data flow programming
and embedding of legacy code. GLU is
available free for most UNIX platforms.

Origin:

Ashcroft and Wadge, 1976-77.

Date:

Last updated 12/8/97

M

M

Language type:

D - Database or Text-processing

Description:

"M" is the newer name for MUMPS, a
powerful high-level language mostly
used for database and interactive MIS
system development.
M is an ISO and ANSI standard language.

Magma is an environment and
high-level language for
number theory, algebra, and
general mathematical programming.
The fundamental features of Magma are
its procedural syntax and statement
structure, coupled with very
sophisticated built-in data types
and operations. In general, Magma
is dynamically typed and performs
automatic conversions rather than enforcing
type checking.
Some of the
built-in types are: unlimited-precision
integers, rational numbers, real and
complex numbers, sets,
atoms, arrays of various sorts,
groups and fields of various sorts,
and various kinds of functional types.
Newer versions of Magma support closures
and
higher-order functions.
Magma has simple I/O facilities
used mainly for reading and writing
mathematical objects to and from files.
There is only one implementation of the
Magma language. It is an interpreter
written in C.
Magma runs on PCs and Unix systems.
Magma was developed at the University
of Sydney, and used to be downloadable
free. Since about 1996, users have had
to pay for subscriptions to Magma.
Documentation is available with the
distributions.

Mathematica is a formidable commercial
system for symbolic mathematics and
graphics. Most of the system is written
in the Mathematica language, a powerful
hybrid interpreted language for expressing
mathematical formulae and procedures.
The end user also employs the Mathematica
language to perform describe the problems
they wish Mathematica to solve to computations
they want it to undertake.
The language has a very broad complement
of features:

Data elements in Mathematica are
strongly typed, but the language system
performs many types of automatic
conversion, especially on numbers.
All numbers in Mathematica are
unlimited precision: integers, reals,
rationals, and complex. Programmers
can also define their own data types,
after a fashion.
[Note: in a sense, Mathematica has only
one non-primitive data type: the "basic form." All
aggregate data and symbolic expressions in Mathematica are internally stored
as a head and a body, where the head defines the
data type. Programmers can create their
own head types, and do, and in that sense
they are defining new data types.]
For many users, the power of the Mathematica
system is its immense library of pre-defined
functions. These functions fall into
several broad groups, some of which are: arithmetic,
algebra, calculus, graphics, I/O,
programming, and the GUI interface.
As an interpreter, Mathematica can
easily import new functions and
package dynamically. Several hundred
such packages have been written for
the system, in academia and industry.
There is only one Mathematica, now in
its third major release. The system
is available commercially for Windows,
Macintosh, and most Unix platforms.

Mawl is a compiled
structured scripting language
designed for implementing interactive
on-line services.
The syntax of Mawl is similar to that of C.
Primitive data types in the language
include integers, reals, booleans, and
strings. For data aggregates, Mawl
supports vectors (homogenous) and
tuples. All variables in Mawl are marked
as 'auto' or 'static'. The static variables
are persistent, holding their values from
session to session.
Mawl also supports conventional
sequential control constructs: conditionals
and loops, but no goto.
Because it is a special-purpose language
designed for building interactive services,
Mawl programs do not have traditional
single-entry-point subroutine structure.
Instead, a Mawl program consists of one or
more invokable sessions, each of which
can have multiple steps of presenting output
and accepting input. A Mawl program can
be 'executing' any number of sessions
simultaneously, using built-in automatic
synchronization.
The fundamental data type for Mawl's
interactive services is the form.
A form is simply an interface between
display and control. Mawl forms have an
input type and an output type (possibly
aggregates, of course) and use templates
for their display.
The really cool part of this is that the
application programmer can treat the
multi-step, event-driven sequence of
delivering a form, letting the user
work on it, and accepting the results all
as if it were an atomic operation!
Mawl includes a simple exception handling
mechanism for taking care of unusual cases
or error conditions.
The current implementation of Mawl is
implemented as a translator, converting
Mawl code into C++ code for compiling
and linking with a run-time library.
Mawl is available from Lucent technologies
at no charge, but with licensing conditions.

Mercury is a logic programming language
with some functional language features.
It was designed to give the
semantic benefits of declarative
programming and the speed and error-checking
of procedural programming.
The syntax of Mercury is similar to that
of Prolog, but supports additional
constructs that declare type, mode,
and other constraints.
Data types supported by the language
include: integers, reals, strings, and
a very flexible record/union type;
the standard library supports a wide
variety of collection types including
arrays, lists, trees, maps, etc.
As a hybrid
logic/functional
programming language, Mercury does
not support conventional procedural
control flow constructs. It does
support higher-order function
operators like curried functions, filters,
and closures.
Unlike most logic programming languages,
Mercury is not interpreted. Instead,
the compiler translates Mercury code
modules into portable C. This gives
Mercury additional portability and speed,
but prevents it from creating and
evaluating new code on the fly.
Since Mercury is purely functional
(side-effect-free) the I/O model
depends on the notion of an "io_state"
value. This makes output a little
tricky, but doesn't break the semantics.
A free implementation of Mercury for
Unix and Windows platforms is available
free. Mercury is distributed with some
Linux systems. In order to take advantage
of Mercury, however, the target system must
have a good C compiler.

Origin:

Mercury Project, University of Melbourne, 1993.

Date:

Last updated 12/20/97

Miranda

Language type:

F - Functional or lambda-based

Description:

Miranda is an interpreted pure-functional
language, intended both for teaching
functional programming and for application
development.
As a pure functional language, Miranda
has no conventional imperative control
constructs.
Instead, Miranda 'scripts' consist of
a set of equations that define various
data structures and operations.
Data types available in Miranda include
booleans, identifiers (symbols),
integers, characters,
reals, strings,
lists, tuples, and functions.
Miranda is strongly typed, in the sense
that all functions enforce type constraints.
Lists are extremely important in Miranda,
as they are in many functional languages.
Miranda provides a powerful
definition syntax for lists called
list comprehensions.
Unlike Lisp and the original version of ML,
Miranda uses lazy evaluation for all
expressions. This allows the language
system to support infinite lists and
indefinite parameters.
Miranda supports many of the higher-order
features expected of an advanced
functional language: curried functions,
first-class functions,
sophisticated pattern matching on
rule application, and definition of
algebraic types.
The syntax of Miranda is very terse and
compact. The language has no
special statement
syntax, everything is an expression.
The basic syntax for function application
is prefix, but infix notation can also
be used in most cases.
The only implementation of Miranda is
the commercial one, it is available for
most Unix systems including Linux.
Information about Miranda is fairly easy to
find on the web, but the language system
does not seem to be available for download
anywhere. Apparently it must be
purchased commercially. There are several
good computer science books about Miranda.

ML is the name for a family of functional
programming languages: ML, SML, SML/NJ,
CAML, EML, and others. The features
and usage of the different versions vary
somewhat; this description is based on
documentation for Standard ML.
ML language systems are usually interpreters.
ML is a 'pure' functional language, in the
sense that there is not assignment to
storage permitted. Instead, in ML the
programmer declares functions and
references to values; ML is a declarative
rather than a procedural language. The
lack of VonNeumann semantics makes functional
languages like ML challenging for the
programmer, but functional programs
are much more amenable
to formal analysis and proofs of correctness.
ML supports many of the advanced
capabilities expected of a good functional
language: recursion, strong typing with type
inference,
a good variety of built-in data types,
facilities to construct aggregate and
functional types,
late binding, function
composition, higher-order functions,
and exception handling.
Pure functional languages permit no
side-effects of functional evaluation.
These languages are usually of limited
utility.
ML provides file and network I/O to
support writing real programs;
writing data constitutes a side
effect of evaluating an output function.
ML also
supports references to mutable storage,
thus allowing the programmer some of the
convenience of a VonNeumann model while
preserving functional operation?
All SML systems share a common library
of built-in functions and modules called
the SML Basis Library. The basis library
provides various data manipulation, I/O,
string handling, and operating system
interface functions.
ML's sophisticated type system gives the
programmer the ability to
define simple functions that automatically
get applied to the right kind of data. It
also supports very fine-grained polymorphism.
Many other functional languages designed
after ML also support a pattern-matching
approach to function application.
The name ML originally stood for
Meta-Language.
ML developed
in several ways during the mid to late-1980s;
a common dialect and base set of features
were standardized as SML in 1990. The
standard was revised in 1997, language systems
that comply with the new standard are
called SML'97 implementations.
Information on ML is easily available
on the Internet. Several free
implementations of ML exist for most
platforms, some of the most popular are
SML/NJ, CAML, and Moscow-ML. At least
one commercial implementation, from
Harlequin Group is
also available.

Modula-3 is a compiled procedural that
supports object-oriented and block-structured
programming. It is a descendant of Modula-2
and Pascal, and is intended for application
development, large-scale software
engineering, and computer science
education.
As a descendant of Pascal, Modula-3 is
strongly typed and can enforce type safety.
The language supports a conventional
set of data types: numbers, enumerations, strings,
records, sets, and arrays. Modula-3 supports the usual control flow
selection and looping constructs.
It provides
good support for modular programming, including
subroutines and modules with explicit
interfaces.
Unlike Pascal, Modula-3 has full support
for abstract data types and
simple OOP,
dynamic memory management with garbage
collection, generics, exception handling,
and concurrency. It is an
important part of Modula-3's claim to being
industrial-strength that it includes
robust error handling and multi-threading
as part of the language.
Modula-3 does not support some OOP features
that it's designers believed would overcomplicate
the language or detract from productive
software development: multiple
inheritance, delegation,
operator overloading, and
reflection.
Module-3's object-oriented programming model
is very simple: an object is simply a
record type augmented with a method suite.
Superclass method overloading is supported.
Pascal compilers attempt to enforce type
safety in every line of a program. A
Modula-3 compiler allows some modules to
be designated as explicitly unsafe, freeing
the programmer to use tricky or
machine-dependent techniques to gain
efficiency or access to hardware.
There is a fairly wide variety of support
libraries available for Modula-3, including
ones for network communication,
object persistence, database access, 3D rendering,
and graphical user interfaces.
Early implementations of Modula-3 produced
C code for native compilation, but modern
systems produce native machine code directly.
Both commercial and free compilers for
Modula-3 are available, for all major
platforms include Unix, Linux, and WindowsNT.
Digital Equipment Corp, one of the
originators of the language, makes a free
compiler available in source form.
At least one commercial implementation of Modula-3
is available as a comprehensive development
environment. Information about Modula-3 is
also fairly easy to find on the WWW.

Modula-2 is a procedural, block-structured
language intended for application programming
and computer science education. It
was designed to foster good software
engineering practices, and also to remedy
some of the shortcomings of its predecessor,
Pascal. Modula-2 has very good support
for program modularity: named modules,
separate compilation,
and data hiding. It also featured strong
type checking, a variety of conventional
data types, dynamic arrays, and concurrency!
Modula-2 was designed to support the
construction and maintenance of real
application software systems (unlike Pascal).
Its support for concurrency and dynamic
memory management are also better than
Pascal, allowing the programmer more
flexibility. The syntax of Modula-2
is also less rigid than that of Pascal,
allowing the programmer to declare
variables and other items nearer to
where they are used.
Lastly, Modula-2 support function signature
type checking across module boundaries.
Modula-2 compilers are available, with
a little searching, for most platforms:
Unix systems, PCs, and VMS, and even
some cross-compilers for embedded systems.
Both free and commercial compilers are
available, but some may be a bit old. There
is at least one Modula-2 system, by XDS,
that can generate C code from Modula-2 code,
to improve portability.
A fair number of utility, math, data
handling, distributed computing,
and other libraries are available
for Modula-2 programmers.
In its original niche,
Modula-2 has been partly superseded by
Modula-3, Oberon, and Ada.

MUMPS (aka M) is a procedural, interpreted
language with extensive features for
event-driven programming, text
handling, and database
manipulation. The language syntax is
very simple, but quirky. A program
written in M consists of commands
which operate on variables. These
variables can be simple numbers, records,
lists, or
enormous databases. Persistent
variables are called 'globals' and
usually live in the database. Access
to globals is transparent, freeing the
programmer from worrying about many
database management issues.
The usual
sequential control structures are present
in MUMPS, but in somewhat idiosyncratic
forms. The usual arithmetic operators
are included, but MUMPS's real strength
is in its string handling. It has a
flexible set of commands for pattern
matching, sorting,
and manipulating strings (although
not as extensive as SNOBOL or Icon).
M is designed to support multi-programming
and distributed computation. There are
also GUI implementations available for
the language, although the base language
standard supports only text-based screens.
Information about MUMPS products and
services are easy to find on the Web,
as are implementations of the language
and its underlying fast database.
Most MUMPS implementations are commercial,
but there are also free systems around
for Unix, VMS, and DOS, and Windows
operating systems.
Tutorials on MUMPS do not seem to be
available easily on the web, but copies
of the language standard are.

NESL is a data-parallel functional
programming language intended to be highly
portable across different parallel
computer architectures, easy to use, and
efficient to compile.
The basic data types supported by NESL
are: integers, reals, strings, and sequences (vectors).
The sequences are heavily used for
defining parallelism, NESL has special
operators and syntax for operating on
all elements of a sequence and on each
element of a vector.
In addition to its parallel computation
constructs, NESL also supports conventional
selection (if-then-else) and iteration
(for, while) control-flow constructs.
The NESL function library provides a
rich set of sequence operations, plus
string manipulation, I/O, system
interface, and windowing functions.
Currently, NESL runs only on UNIX and
related systems (or parallel computers
attached to such systems); its windowing
support is currently implemented only
for X11.
NESL is usually compiled; the compilation
process automatically generates a mapping
from the computation defined by the NESL
code onto the processors of the target
computer. Variables and functions in
NESL are not strongly typed, but the compiler
seems to perform extensive
type inference at compile-time.
Releases 3.1 and later of NESL also
include a lightweight interpreter for
use in training and debugging. The NESL
compiler is written in C, and the
interpreter is implemented in Common
Lisp.
Implementations of NESL are
available from CMU. The documentation
and a tutorial are also available on
the web.

NIAL, the nested interactive array language,
is a quasi-functional language with some
procedural features. It is intended for
application development.
Nial offers high-level features intended to
make it easy for the programmer to
build complex data structures and
analysis functions. The primitive data types
in Nial includes integers, reals, strings,
and atoms. The primary aggregate
data types is the rectangular array.
Arrays can be heterogenous, dynamic, and
built up in a variety of ways.
Nial supports conventional procedural
control-flow constructs like while loops
and conditional expressions.
Various functional programming constructs
like currying, transformers,
and composition are also
supported.
Nial was originally designed and
implemented at Queen's
University in Ontario, CA. It is now
developed and sold by NIAL Systems
Limited. The company offers free
evaluation downloads.

Oberon is a procedural, block-structured
language with many object-oriented features.
It was designed for computer science
education, but is also suitable for
general-purpose
application programming.
Oberon has a Pascal-like syntax, but its
semantics are richer than Pascal's.
An Oberon system
consists of the Oberon language compiler
along with a comprehensive operating
environment.
The Oberon language offers the following
features: strong type checking,
separately compilable modules, type
extension and type-bound functions for OOP,
run-time type identification, dynamic
memory management with garbage collection,
regular complement of numeric, string,
and array data types, and dynamic module
loading. Oberon, like Pascal, enforces
the rule that every thing must be declared
before it is used.
There are some features of other
object-oriented languages that Oberon
does not offer: operator overloading,
multiple inheritance, abstract interfaces,
and reflection.
Several versions of the Oberon system
and language exist. Oberon V4 (System 2)
is the
classic, text-based system.
Oberon System 3 is the newer, GUI
system with advanced OOP features like
persistence and generic message passing.
Oberon/F is a version of the language
for embedded systems and other 'black-box'
applications.
Implementations of the ETH free
Oberon system
are available for some Unix systems,
Linux, PCs, and Macintosh.
Commercial versions of Oberon also
exist.

Origin:

Wirth and Gutknecht, ETH Zurich, 1985-88.

Date:

Last updated 12/7/97

Objective-C

Language type:

O - Object-oriented

Description:

Objective-C is an object-oriented language
based on C; its object support is based
on a dynamic message-passing model.
Objective-C
provides a range of OOP features:
inheritance, dynamic method invocation,
delegation, metaclasses
and dynamic object creation, a form of
garbage collection, simple persistence,
and a kind of polymorphism.
Objective-C does not support multiple
inheritance, and concurrency is not
part of the language.
The syntax of Objective-C is very similar
to C, but with additions. Unlike
C++, Objective-C does not add OOP semantics
to traditional C syntax; instead, new
syntax specifically for message passing
and class definition provide OOP support.
Objective-C offers the same data types
as C: integers and floats, arrays, structures,
unions, and pointers. Objects are a new
type; Objective-C uses a rooted class
hierarchy: all classes inherit from a root
Object class. This fact is heavily
employed by the Objective-C standard
class library.
Brad Cox invented Objective-C in the
mid-1980s as an OO
extension to C, intended to bring C
programmers some of the benefits offered
by Smalltalk. The language was
used by NeXT in the 1989-94 timeframe as
the application and library
programming language for
the NeXTSTEP and OpenStep operating systems.
Objective-C has been implemented as a C
preprocessor and as a native compiler.
At least one commercial and one free
compiler are available. Information on
Objective-C exists on the Internet but
is not easy to find.

Obliq is an object-oriented interpreted
scripting language that supports
distributed multi-threaded computation.
The syntax of Obliq is similar to that of
Modula-3, but simpler and with no
support for type declarations. Obliq is
basically untyped, variables and fields
can hold any kind of value.
Basic data types include booleans,
integers, reals, characters, strings,
and arrays. Obliq supports a
complete set of sequential control structures
including conditional, iteration, and
exception handling forms,
as well as special control forms for
concurrency (mutexes, guarded statements).
A fairly large set of standard libraries
are defined for Obliq. These libraries
provide support for math operations, I/O,
persistence, thread control, graphics,
and animation.
Distributed computation in is object-based.
Objects can hold state, and that state is
local to a particular process. Scope of
objects and other variables is purely
lexical. Objects
can call methods of other objects, even if
those objects are on another machine on the
network.
Obliq objects are simply collections of
named fields (like Self's named slots), and
support inheritance by delegation (like Self).
The Obliq language system is an
interpreter written in Modula-3, and
employing Modula-3's network objects
capabilities. Obliq is included free
with the DEC Modula-3 distribution,
and pre-compiled binaries for some
platforms are also available. A manual
and many journal articles about the
language and its applications are
available on the web.

Occam is a simple parallel computing language
developed to express many kinds of
parallel programs easily and directly.
Originally intended for the INMOS Transputer,
a chip built to support fine-grain
multi-processing, Occam has been implemented
for several processor and software architectures.
Syntactically, Occam is quite simple,
structure is expressed with a few simple
keywords and with indentation. Occam
supports a modest set of data types:
ints, reals, bytes, strings, and arrays.
(The original
version of Occam didn't support reals.) In
addition to simple data types, Occam defines
some kinds of parallel computing primitives
as types: channels and timers.
The semantics of Occam are based on the notion
of 'processes'. A process can be any
kind of computation (e.g. a := b + 6) and
can run in parallel with other processes.
The language provides structure to allow
processes to execute in parallel or
sequentially. Parallel processes
communicate with channels; these channels
must be declared, like variables, and
can enforce synchronizations (something
like an Ada rendezvous, but simpler and
more flexible). The language also
includes advanced facilities for multiplexing
channels and replicating processes.
Occam's model for parallel computation is
based on the seminal research by C.A.R. Hoare
and his language CSP.
The current version of the Occam language
definition is 2.1. Previously available only
as a commercial system from INMOS, various
free implementations of Occam are now
available for various platforms. Check
the links below for information and downloads.
Some of the available compilers are really
occam->C translators. Occam reference
manuals and examples are available for
download.

Origin:

David May et al 1982, 1987.

Date:

Last updated 12/8/97

OPS5

Language type:

L - Rule-based or logical

Description:

OPS5 is a production rule programming
language for AI research
and building expert systems. The
OPS family of rule-based systems
culminated with OPS5, which has been
widely used for AI instruction and
application development.
An OPS5 program consists of a set of
production rules. Each rule has a
precedent, or set of conditions which
govern application of the rule, and an
antecedent which define actions to take
upon triggering the rule.
OPS5 supports both forward-chaining
and backward-chaining control models.
Data in the OPS5 model is handled as a set
of global state variables and records which
can be modified by the rules.
Production rules reside in "production memory",
while data values reside in
"working memory".
Primitive data types are numbers and
symbols (symbols also serve as strings).
OPS5 is weakly typed, like Lisp:
variables are not declared to have a
particular type, but can hold any type of
data placed in them.
Working memory contains objects that
bear attributes: these attributes can hold
primitive data values, vectors, or
references to other objects.
OPS5 has been largely superseded by newer
expert-system shells (such as CLIPS)
and rule-based languages (such as OPS83).
The first version of OPS5 was coded in Lisp.
Later versions were written in C for speed.
Both commercial and free academic
editions of OPS5 existed during the 1980s.
Free implementations
of OPS5 (C and Lisp) are supposedly
available.
Documentation on the language is not
easily available on the net.

Orca is a parallel-programming language based
on a shared-object data model, designed to
be compiled, and intended for portable
application development across a variety
of multiprogramming architectures.
The syntax of Orca is based on that of
Modula-2, and Orca supports the same
sequential control constructs that
Modula-2 does. Primitive data types in
Orca include characters, integers, and
reals.
Orca also supports arrays, and a
high-level graph type. The programmer
can define new Abstract Data Types (ADTs),
with data attributes and operations.
Orca is a strongly-typed language, designed
so that the compiler can catch a wide variety
of semantic errors.
The fundamental notion for parallelism in
Orca is that running programs on
different processors can share arbitrary
data structures, but that operations on
those structures are automatically
indivisible. This is essentially a
simple model for distributed objects,
and provides the
programmer with a good deal of flexibility
in implementing the elements of a parallel
system, while removing some of the low-level
worries encountered with
message-passing systems.
An alpha distribution of Orca can be
obtained from its principal developer,
Dr. H.E. Bal at Vrije University.
Information about the system on-line
consists mostly of journal and conference
papers about Orca and its original target
platform, Amoeba.

Oz 2 is a declarative
concurrent programming language
that supports object-oriented and
functional
programming with constraint propagation.
It was created as a research
vehicle for advanced language design, AI,
and concurrent system design.
Primitive simple data types in Oz include
integers,
reals, characters, strings, booleans, atoms,
threads, objects, and functions.
The language also supports a flexible set
of aggregate types: records, tuples, lists,
and arrays.
All predefined Oz types are arranged in a
type hierarchy, and inheritance relationships
in the hierarchy can be used as part of the
type system and constraint rules.
Oz supports the usual sequential control
structures, like conditionals and loops, as
well as parallel versions of them. It also
has exception handling constructs.
The Oz object system supports encapsulation,
inheritance, generics, and other OOP features.
Like most functional languages, Oz has
full automatic memory management and
garbage collection. Like most
parallel programming languages, it has
synchronization primitives for serializing
access to objects. Thread creation in
Oz 2 is always explicit.
Oz uses a constraint programming system
called finite domain constraint
propagation. Constraint propagation
runs concurrently with other program
activities.
Oz 2 has been implemented on Unix systems
and Windows, a distribution may be obtained
from DKFI in Germany. Good documentation is
available at the language's web site.

Pascal is a simple block-structured language
originally designed for computer science
education. Pascal features strong type
checking, simple I/O facilities, a
good set of primitive data types,
arrays, fixed and variant records,
conventional control structures, and
simple dynamic memory management.
Pascal requires discipline from the
programmer: all types, data, and subroutines
in a Pascal program must be declared prior
to use. Everything is lexically scoped, to
allow for maximum compile-time type
checking. The language has good support
for programmer-defined data types and
subtypes, which are also subject to strong
checking.
Structure of a Pascal block is somewhat
rigid, elements must appear in a certain
order preceded by their identifying keyword:
labels, constants, types, variables and functions, then
body code.
The original Pascal language borrowed some
structural ideas from Algol, but also
included novel syntactic and
semantic features intended to foster
good structured programming technique (or at least
what was considered sound structured
development technique in the 1970s).
The choice of features and the limited
external interface facilities helped
make Pascal very portable.
However, the initial design was very spare,
it didn't
include strings, only arrays of
characters, and it had a very small
complement of built-in utility functions.
These omissions led developers of Pascal
language implementations to add extensions to
help programmers accomplish real work,
and unfortunately every vendor's extensions
were more-or-less proprietary -- the Pascal
language lost some of its portability.
Amazingly, while it is very strict in
most ways, Pascal still supports a 'goto'
statement.
Pascal does not support object-oriented
programming, persistence, or multi-tasking.
A 1975 variant of Pascal called
"Concurrent Pascal" had good support for
multi-tasking and other advanced features.
Over the 1970s and 1980s,
Pascal became fairly widely used,
especially in the early days of the IBM
PC and the Macintosh. A great many students of computing in
the 80s cut their teeth on Pascal programs.
Both free and commercial Pascal compilers
exist. The most popular commercial
compiler, and a fine language
implementation, is "Turbo Pascal" from
Borland.
Pascal is normally compiled, either to
machine code or virtual machine bytecodes
of some sort. Source-level Pascal interpreters also exist,
and translators from
Pascal to other languages.
Information on Pascal, including
programming tutorials, is widely available
on the WWW.

Origin:

Niklaus Wirth, 1968-71

Date:

Last updated 12/7/97

PerfectScript

Language type:

A - Application/Macro

Description:

PerfectScript was the macro extension
language for WordPerfect, QuattroPro,
and other office automation products.
It is a dialect of Basic, with some
additional data structure types and
some C-like control structure syntax.

Perl is an interpreted scripting language
with extensive facilities for data
manipulation and rapid application
development. Perl is basically
block-structured, but also supports
object-oriented programming.
"Perl" stands for "Practical Extraction
and Reporting Language," a reference to
the purpose for which the Perl
interpreter was originally created:
system administration and data reduction.
Perl has gone through several major
evolutionary phases. The current
language version is Perl5, but some
pockets of Perl4 use still exist. Perl5
is backward-compatible with 4. In the
feature list below, features that are specific
to Perl5 are marked with an asterisk.

The Perl language does not support the
traditional notion of records or structs.
Instead, associative arrays (hashes)
are provided to serve all such purposes.
Similarly, Perl supports object-oriented programming,
but does not stipulate an object storage format.
In Perl5, code is parsed and compiled into very
high-level bytecodes prior to interpreted
execution. This approach, and extensive
optimization of the Perl interpreter and
run-time engine, allow Perl scripts to
achieve very high performance.
Perl currently does not support multi-threading,
although efforts are underway to add this
important feature.
Perl is very popular in the UNIX
community, and gaining acceptance in the
Microsoft Windows developer community.
There is only one Perl language system;
written in C to be very portable, it runs
on all UNIX platforms, 32-bit Windows, VMS,
and many other systems. Perl is free.
Books, tutorials, and on-line resources
for Perl are widely available, and generally
of good quality. Add-on modules and
pre-built scripts for Perl are also
widely available, with more being written
all the time. Add-ons for Perl are
so numerous and in such wide demand that
an organized replicated archive system
for them exists: the Comprehensive Perl
Archive Network (CPAN).
There is no international standard for
Perl syntax. The language definition
is informally set forth in Programming
Perl, 2nd Edition, by Wall, Christiansen, and
Schwartz.

PHP is an interpreted
server-side scripting language for
web servers. It was designed to support
simple, fast server-side extension for web
development. The syntax of PHP is fairly
simple, and very similar to that of Perl,
with some aspects of Bourne shell,
Javascript, and C .
Variables in PHP are weakly types, the
language does not support strong typing.
PHP supports the a modest complement of
primitive data types: integers, floats,
and strings. It also supports heterogenous
multi-dimensional associative arrays, with
very convenient syntax. PHP offers some
object-oriented functionality, allowing the
programmer to define classes with
member variables and methods, and to use
simple inheritance. The language includes
an extensive set of operators and
built-in functions for manipulating
strings, numbers, and arrays.
Control structures supported in PHP
include simple conditionals, plus several
kinds of bounded and unbounded loops.
PHP does not support any kind of
module or library structure, but it
does permit simple file inclusion
(similar to C's #include directive).
In addition to its basic web functionality,
PHP is supported by extensive libraries
that provide database interfaces and
interaction with many common web data
formats.
There is only one implementation of series
of PHP implementations, as of late 1999 the
current version was 3.0, with 4.0 in beta.
PHP is free, distributed as source code,
and runs on
Unix, Linux, and Windows.

Pict is a research programming language
designed as a practical implementation
of the pi-calculus (a parallel computation
formalism). While based on a very
advanced formal model, Pict also provides
a small but usable complement of data types
and constructs.
The core elements of the Pict language are
a simple but general
static type system and
concurrent processes that
communicate using channels.
The pi-calculus defines the
semantics of the processes and
channels.
Pict supports a small
set of primitive data types:
integer, character, boolean,
string, and channel. It does not have
enumerated or real number primitive types.
The aggregate data type in Pict is the
tuple, which can have named or unnamed
fields.
Pict supports only three sequential
programming constructs: sequential
composition, conditional (if-then-else),
and associative application (application
of a function over several values).
Oddly enough, Pict does not have any
sequential looping constructs, although
other forms like recursion and process
composition can do the same thing.
The core Pict language is extended by
several 'derived forms' and library
functions that add no
formal expressive power but make
programming much easier (relatively, anyway).
For example,
local value declarations and
associative application are derived
forms.
Some of the library forms
include bounded loops, array handling,
events and exceptions, and several
other additional data types.
The Pict libraries also include
interfaces to useful features:

Pike is an interpreted dialect of C with
object-oriented programming features and
dynamic memory management.
It is intended for general programming,
especially for networking applications.
The data model of Pike is similar to that of
C , with the addition of a primitive
string type and a 'mixed' type
that can hold any normal date value.
Control
structures in the language include C-like
conditionals and loops, as well as a
Perl-like array iteration loop.
Arrays in Pike are dynamic, and the language
also supports generalized associative
arrays called maps.
Object classes in Pike support
methods with run-time resolution,
multiple inheritance, and method
references.
Pike has extensive additional
facilities, including thread support,
a variety of I/O libraries, network
socket support, simple image processing,
and regular expression pattern matching.
The current version of Pike, 0.6b, has
no GUI or window system capabilities.
Pike is available at no charge from its
developers, Idonex of Sweden. There is
only one implementation, and it runs
on Win32 systems as well as most Unix
incarnations.

Origin:

Fredrik Hübinette, InformationsVävarna, 1996.

Date:

Last updated 9/12/98

Pilot

Language type:

C - Command or Scripting

Description:

Pilot is a simple imperative language
designed for building textual computer-aided
instruction systems.
The syntax of Pilot appears primitive by
1980s standards. It is highly field-oriented,
each line is either a command or a label,
and all commands have the same structure.
A command consists of a keyword, an
optional condition, and text. The core
keywords are:

TYPE - output some text

ACCEPT - read an input string

MATCH - compare input to a pattern

JUMP - goto another part of the program

USE - call another part of the program as a subroutine

COMPUTE - assign a value to a string variable

END - return from a USE

YES - output some text if an answer was yes.

NO - output some text if an answer was no

Pilot supports two data types: strings and
numbers. All variables are dynamically
scoped.
Pilot totally lacks sound control structures,
data abstraction, file I/O, and error handling.
An implementation of Pilot is available
from the Retrocomputing Museum. No
documentation about the language seems
to be available.

Origin:

IBM, 1962.

Date:

Last updated 3/8/98

PL/C

Language type:

S - block-structured

Description:

PL/C was a subset of PL/I developed at
Cornell University. Because the
full IBM PL/I compiler was rather large
and slow to be employed for student
programming programming projects, PL/C
was developed and used at many universities.

Date:

Last updated 12/4/97

PL/I

Language type:

S - block-structured

Description:

PL/I (Programming Language 1)
is a large, complex block-structured
language invented by IBM, and first
released in 1964 in conjunction with the
influential System/360 line of computers.
PL/1 was intended to be THE all-around
language for mainframe system and
application development, and therefore
it had a very large feature set. PL/1
was widely used by the IBM community,
and by
the early 1980s, PL/1 included the following
language facilities:

functions and procedures

huge complement of numeric data types

array and record data types

full set of control structures, including recursion

charater strings and string manipulation

COBOL-style 'picture' formats

stream, record, and formatted I/O facilities

bit strings

generics

interruptions (a form of error handling)

dynamic storage management

multi-tasking and asynchronous events

IBM spent a lot of effort developing
an optimizing compiler for PL/1, and
a lot of seminal research on high-level
language optimization was done in the
late 1960s and early 1970s on the PL/1
optimizing compiler.
Today, commercial
PL/I compilers are available for
IBM mainframes, PCs running WindowsNT
and OS/2, and some UNIX workstations.
No free PL/I compilers are currently
available (although there was a subset
compiler named PL/C that was free at
one time).

PostScript is a threaded interpreted
language with stack-based semantics.
While usable for general-purpose
computation, PostScript was specially
designed to drive graphic devices,
initially printers, and has a large set
of operators for rendering onto a page.
In terms of syntax and semantics,
PostScript resembles
Forth: operators use data from a stack,
and place their results back on the stack.
PostScript data types include floating-point
numbers, strings, fonts, files, vectors,
and symbols.
Defined procedures are simply code
sequences stored in dictionaries.
The essence of PostScript is its model
of execution. In a threaded interpreted
language, a program simply consists of
a series of tokens. The interpreter
processes each token in turn, with
no look-ahead or complex parsing needed.
Supporting this style requires storage
for intermediate results, PostScript
uses several stacks: a code stack, a
data stack, and a dictionary stack. (There
is also a special stack just for graphical
contexts, as needed for the rendering model,
making a total of four stacks.)
Threaded interpreted languages can be
difficult to use, but they offer the
advantage that interpreters for them can
be very compact and fast. As PostScript
was originally designed to execute inside
a printer or similar device with very
little memory, compactness was an important
design criterion.
Several implementations of
PostScript exist, but the two main
ones are the commercial implementations
from Adobe Systems, and the free
Ghostscript implementation from
Aladdin Enterprises.
The current version of PostScript language
is Level 3. PostScript level 2 is also
still very widely used in printers and
other devices. Implementations of
PostScript for GUI systems use a
language dialect called
"Display PostScript," that includes
special operators and slightly different
semantics to accomodate user interaction.

PROLOG is a language for PROgramming in
LOGic. Prolog was a progenitor of the
study of 'logic programming,' a computer
science area concerned with languages
and systems for logical inference,
proof techniques, and very high-level
programming systems.
A Prolog program consists of a set
of facts, and a set of rules that
specify how to satisfy goals related
to those facts. Prolog supports a
small but rich variety of data
types: numbers, strings, symbols, lists,
and composite objects (analogous to records).
You never really execute a Prolog program
directly, in the sense that you might run
a C program; instead, you ask the
Prolog system questions. By attempting
to answer the questions, the Prolog system
examines facts, invokes rules, and
may manipulate data or perform computations.
The programmer does not directly control
the execution sequence of the Prolog system
as it seeks to satisfy a goal, although he
can exert some influence.
In this sense, Prolog must be considered
a declarative language and not
a procedural one.
Prolog was among the first computer programming
systems to employ
the logical formalism of unification.
It also utilizes recursive goal seeking with
backtracking, a common AI technique.
Unfortunately, unification and backtracking
can be computationally expensive, and early Prolog implementations
were very slow. Newer implementation
techniques, as well as language features
that let the programmer guide the search
to some extent, have given modern Prolog much
better performance.
Prolog is usually interpreted.
Free and commercial implementations of
Prolog are available, for all major
platforms and many specialized ones.
Prolog is also undergoing ISO/EIC
standardization, the draft standard
is available for downloading
here.

Python is an interpreted, object-oriented
language. It is intended to be highly
effective, easy to use, and extensible.
The syntax of Python is very simple and
statement-oriented. Block structure is
specified with indentation. Python
supports a good set of primitive and
composite data types: integers, floats,
complex numbers,
strings, lists, and associative arrays
(dictionaries).
Data values
are typed, but strong
type checking is not enforced.
Like most scripting interpreters, Python does have
the ability to execute a string
as code.
Python supports a conventional set of
flow-control constructs: if-then, while and
for loops. Python also has
exceptional-handling
constructs similar to those in Modula-3.
Python supports
subroutines, independent modules,
and object classes with
Object-oriented programming features
are an important part of Python, used
for the standard library and for user
extensibility. Classes can use
single and multiple inheritance.
Python is supported by a feature-rich
standard library; it includes extensive
string manipulation, I/O, parsing,
date handling, low-level networking services,
high-level protocol and data format
handling, image I/O, and a variety of
operating system-specific services.
Python is normally interpreted, but the Python
interpreter can compile scripts and modules into
portable binary form and execute this form
instead. Several Unix-specific and
portable graphics and GUI
libraries also exist.
Newer versions of Python support some
functional programming features,
including lambda forms.
There was originally
only one Python implementation, an interpreter
which ran on a wide variety of Unix platforms
as well as Windows and Macintosh.
Later, an implementation was created that
compiled Python to Java bytecodes
(jPython) and there is also one that
targets the Microsoft C# environment.
Documentation and tutorials for
Python are readily
available on the web.

QBasic, or QuickBasic as it is sometimes
called, is a dialect of BASIC created by
Microsoft for application development under
the DOS 'operating system'.
Microsoft QBasic exhibits a number of
differences from traditional Basic:

line numbers are permitted by not
required, and text labels are supported

QBasic has a better set of control flow
constructs than original Basic

Since it was designed specifically for
one platform, specialized graphics and I/O
support were built into the language

Later versions of QBasic featured
better support for subroutines and
extending the language environment with
libraries written in C and assembly.
Documentation about QBasic is widely available
on the web. Some versions of the language
system itself are also available, although
the licensing arrangements are unclear.

Origin:

Microsoft Crop., 1986.

Date:

Last updated 2/25/98

Quake-C

Language type:

A - Application/Macro

Description:

Quake-C is an subset dialect of C
used to define operations, semantics, and
extentions for the Quake game engine,
used for games like Quake and HexenII.
Quake-C supplied special data objects and
message-passing semantics for the
multi-tasking internal environment of the
game engine.

REBOL is a functional scripting language
with message-passing and
object-oriented features. It is
designed for general application and
network service development.
Intended to support both simple scripts
and larger projects, REBOL has a fairly
large complement of primitive data types:
numbers, time, date, money, strings, booleans,
words (atoms), and more. It also supports
tuples and other primitive data aggregations,
as well as application-oriented types like
files, URLs, and email addresses.
The primary grouping construct in REBOL
is the block, it is used for both
data and code aggregation (the way lists
are used in Lisp and Scheme).
The
evaluation and code structure concepts
of REBOL
resemble those of most other functional
languages. As a first-class functional
language, REBOL stores everything as data
with a definite type; functions and objects
are merely data constructed according to
convention understood by the interpreter.
The REBOL core language has quite a few
advanced features, consult the web sites listed
below for details. Some of the
supported features
are: automatic memory management (gc),
reflection, higher-order functions,
exception handling, and dialecting.
There is only one existing implementation of
REBOL, it is an interpreter that runs on
a wide variety of operating systems.
The system can be downloaded free, or
purchased.

Reduce is a system for computer algebra and
symbolic mathematics, featuring a language
named Reduce in which users can define new
functions and symbolic computation rules.
The expression syntax of Reduce is similar
to that of FORTRAN, but with a variety of
extensions for symbolic operations.
The following data types are supported:
integers, reals, rationals, and complex
numbers, all infinite-precision, strings,
matrices, arrays, and patterns.
Reduce supports definition of procedures and
functions, but has no support for
object-oriented programming or package
structure.
Reduce is written in Lisp, and the source
code for the kernel is normally supplied
with the distribution. There is a
low-level extension language under Reduce
, but above Lisp, called RLisp. RLisp is
used in some versions of Reduce for code
efficiency or to build complicated data
structures.
Reduce is available as a
commercial product for most computer
platforms.
Free demo versions are also available.

Rexx is an block-sturctured
procedural language commonly used for
application development, integration,
and extension.
Designed primarily for ease of use,
the Rexx language is weakly typed and
has a very plain, uncomplicated syntax.
Rexx supports strings, numbers, and
associative arrays as its data structure.
The numbers can be unlimited-precision.
The language includes conventional
control structures: if-then-else, counted
and free loops, and a case statement form.
It supports recursive functions, and also
supports evaluation of run-time code (like
Lisp, Perl, and many other interpreted
languages.)
Some commercial implementations of Rexx
support the creation of GUIs and interaction
with database management systems.
An ANSI standard for Rexx is available,
the standard was created by the X3J18 committee
and is designated X3.274-1996. A pre-pub
draft is available on-line from
here.
Various superset dialects of Rexx exist, providing
a variety of extensions: ObjectRexx supports
object-oriented programming, and NetRexx
provides a variety of network interface and
I/O facilities.
Both free and commercial implementation of
Rexx are available. Most are interpreters
only, but a few Rexx compilers also exist.
Information about the language is freely
available from IBM, various academic
institutions, and the Rexx Language Association.

RPG, Report Program Generator, is a
high-level database access and text
generation language invented for
mainframe MIS environments.
The RPG language is designed around
the programmer's presumed goal: generating
informative large-scale reports from
mainframe databases. To this end, RPG
supports input forms definition,
database access, and
very extensive output formatting facilities.
Because it is mainly intended for
formatting and presenting data, RPG does
not have very extensive computational
support, but most versions have at least
a minimal set of sequential control-flow
operators, support for subroutines, etc.
Data types in RPG include integers,
fixed-format numbers, reals, strings, and
records. Often, data types and records
are declared as having a particular print
format (like in COBOL) and the compiler
takes care of choosing a suitable internal
representation.
The lexical structure of RPG is column/card
oriented. Programs consist of four
distinct sections: file description, input
formats, calculation, and output formats.
RPG-IV (1994) added another section: the
subprocedures section.
RPG programs are typically compiled.
They must be supported by an extensive
run-time environment that provides I/O
and data management services.
Commercial implementations of RPG
are available from IBM, Lattice, and
other companies. There are no free
implementations. Books are RPG programming
are widely available from commercial
publishers.

Ruby is an interpreted scripting language,
fully object-oriented and designed for
easy extensibility.
The syntax of Ruby is simple but bears a
strong resemblance to Perl. All data
types in Ruby are object classes, like in
Smalltalk. Pre-defined data types include
integer and float numeric types, strings,
arrays and hash tables, and structures.
Control constructs in Ruby include a
wide variety of conditionals and
several kinds of loops, along with several
controls structure variations like
break and continue.
Ruby does not have declarations; variables
are weakly typed, and their scope is
denoted by prefixes.
Ruby supports many important OO
features, including classes with
inheritance, class methods, and even
closures. Ruby also supports
exceptions with functionality
similar to that of Java.
Ruby supports a variety of kinds of
introspection, including Java-style reflection
and Lisp-style enumeration of active objects.
The syntax of Ruby's reflection support is
simpler than that of Java.
Ruby does support threading.
There is only one implementation of Ruby;
it is free open-source. Documentation for
Ruby is available on the WWW, and there
are also several published books about
the language.

S is an interpreted, high-level procedural
language designed and used for statistics,
numerical modeling, data analysis, and
simulation.
The structure of an S program is quite simple:
it consists of statements. Some of the
statements might define functions, which
allows the S programmer to build up
complicated modular programs. The expression
syntax of S is very sophisticated and
rich. Array and sequence handling are
supported with a set of compact primitives
that allow complicated data manipulation
to be built fairly easily.
Like many interpreters, S permits evaluation
of code constructed on the fly. It also
has some limited facilities for reflection
and expression manipulation.
By default, all global variables in S are
persistent.
They get saved at each assignment to
one of several data areas.
Function definitions are also persistent,
saved in the same fashion.
The newest version of S, Version 4,
supports object-oriented programming
and event-driven programming.
S is sold commmercially as 'S-Plus' by
MathSoft, Inc. It is available for all
Unix and PC platforms. Some documentation
can be found on-line, but available textbooks
and reference documents distributed with
the commercial implementation are better.

Sather is an object-oriented language,
strongly typed, that supports many modern
OO software engineering features.
The syntax of Sather is somewhat similar to
Eiffel or Ada. However, in Sather all
types belong to object classes.
Primitive types include integers, floats,
strings, booleans, and the distinguished value
void. Arrays are supported, too, but as
a parameterized class rather than a
built-in data type.
The only ways to define new types are
class definition and class parameterization.
All memory management is automatic for
Sather programmers, all Sather implementations
include garbage collection.
Some advanced features of Sather are listed
below.

Exception handling

Closures and iterators

Multiple inheritance (subtyping)

Supertyping

Operator overloading

Immutable classes

Abstract and partial classes

Assertions, preconditions and postconditions

The Sather standard library provides an
assortment of container types, I/O
facilities, system interfaces, and more.
Implementations of Sather and the
source code for them are available free.
Documentation is available on-line and is
also included with most distributions.

Scheme is a dialect of Lisp with functional
and procedural language aspects. Unlike
original Lisp, Scheme is lexically scoped,
but like Lisp it is dynamically typed.
Scheme provides a wide set of
data types: symbols, various numeric types,
characters and strings, lists,
vectors, bit strings, records, association
lists and hash tables,
and various functional/lambda types
(curried procedures, closures, promises, etc).
Scheme has comprehensive I/O facilities
based on an abstraction called "Ports."
As a Lisp dialect, Scheme naturally
supports lambda expressions. It also
has a full set of sequential control-flow
constructs: a variety of
selection, iteration, and
block special forms.
Scheme also has a comprehensive error
handling mechanism.
Scheme has gone through four major revisions
since the first "Report on the
Algorithmic Language Scheme" was issued in
1978. The current version of M.I.T.
Scheme, as of last 1997, is 7.4.
Various other academic implementations
also exist.
Scheme is used to teach computer science
principles, as well as for writing various
compilers, AI systems, and many other kinds
of programs.
Information about Scheme is widely available
on academic sites on the Internet.
Several free implementations are available
for all major platforms: MIT Scheme,DrScheme,
Gambit-C, MzScheme, Pc-Scheme, SCM, VSCM,
and others. There have also been many
extended scheme dialects created.

Self is a dynamic object-oriented
language and programming environment
based on an object prototypes a
general message-passing model. It
was designed to be small, very flexible,
and easy to use.
An object, in Self, consists of several
named slots. Each slot can be a data
slot or a method slot, there is no
fundamental distinction between them.
Slots can hold integers, reals,
strings, methods, code blocks,
and references to other objects.
Aggregate data types of all kinds
are provided by prototype objects in
the Self standard library. The
library also provides a great many
prototypes for graphics, windowing,
I/O, networking, and other services.
Self supports the usual selection and
iteration control flow constructs for
use inside methods and blocks. Their
syntax is a little peculiar because
they are built as methods of the
object prototype 'Block'.
Self is very unusual, among OOP languages,
because it allows an object to change
its slots and its methods dynamically; this
is equivalent to allowing run-time class
definition.
There is no strict inheritance in Self;
the parent class of an object is simply
a reference stored in a parent
slot, messages that cannot be handled
by an object get delegated to its
parent (effectively, its superclass).
Self also fully supports reflection,
allowing objects to inspect each others
configuration during execution.
The Sun implementation of Self is written
in C with some assembly code. It is
basically an on-the-fly translator
with compiled code caching. Since
re-compilation is transparent, Self
appears to the user as if it were
interpreted.
The current (and last) release of
Sun Labs Self is 4.0. It is available
for SunOS and Solaris UNIX from several
FTP sites. The Merlin project is
implementing a version of Self for Linux.
Documentation about Self, including
conference papers and a reference
manual, are available on the web.

Origin:

David Ungar & Randall Smith, 1986.

Date:

Last updated 9/3/98

SETL

Language type:

S - block-structured

Description:

SETL is a high-level procedural language
designed to bring the power of set theory
to programmers. SETL programs are
typically compiled.
The fundamental data types in SETL are:
integers (unlimited precision), reals
(machine precision), strings, booleans,
and the explicit non-value, omega ("om" for
short).
The main data structures are sets and
tuples: sets are unordered but unique,
while tuples are ordered but can contain
duplicates. A special case of the set
type very often employed in programming
is the map, a set of 2-tuples.
The language includes a rich set of
constructs and functions for creating and
manipulating sets and tuples.
SETL is a highly dynamic language;
sets and tuples can be heterogeneous, and
can be nested to arbitrary depth. In
general, variables are typed by the value
they hold; some type checking for operators
is enforced.
Sets and tuples can be created on the fly,
garbage collection is automatic (presumably
by reference counting, since there are no
pointers in the language).
Because it supports generalized notions
of sets and tuples, SETL provides loop
constructs based on them. It also provides
conventional while-do loops, if-then-else
selection, and a case statement.
SETL supports definition of functions and
definition of
new operators. There are no
procedures in SETL, but any function can return
omega.
Most dialects of SETL support a sub-language
that allows the programmer to define how
data structures are to be stored
internally by the compiler; this allows the
user to give guidance to the compiler,
possibly improving performance.
SETL supports module and library features
for large-scale programming. Newer editions
of the language also support named
packages (like Ada), and there are also
dialects that support classes and
object-oriented programming.
Several implementations of SETL are
available, mostly for DOS and UNIX
platforms, but there is also a Macintosh
version. Information on the language,
including tutorials and references, is
available but mostly in downloadable
print formats
rather than web pages.

Origin:

Jacob T. Schwartz, 1969; Courant Institute, 1970.

Date:

Last updated 12/22/97

sh

Language type:

C - Command or Scripting

Description:

The Bourne shell scripting language was
one of the original command languages for
the Unix operating system. It is a
simple interpreted language,
but widely used for
automating complex tasks and assembling
multi-step functionality from individual
Unix tools.
The syntax of sh is line-oriented.
Sh has very limited data typing and scoping
features. Variables are usually called
'parameters'. The only data type for
parameters is string. Parameters
are global and dynamically scoped.
The shell language supports a modest but
complete set of control-flow constructs:
bounded and free loops, if-then-else, and
a powerful case statement. Sh also
supports a rudimentary error handling
facility for catching asynchronous
interrupts.
Modern versions of sh support named
functions, which may not be nested.
Function parameters are the only non-global
variables.
Strangely, sh has no support for computation,
all computations must be carried out by
calling Unix utilities like test
and expr.
The basic boolean construct in sh
programming is the success or failure of
program execution.
The shell language offers extensive special
syntax and features for running programs
and handling their I/O. One of the most
influential of these constructs was the
"pipe", a simple syntax for connecting
the output of one program to the input
of another.
The Bourne shell is included on all Unix
and Linux systems, and
more-or-less complete versions
are available for many other systems.
Documentation is included, and good
books are also available.

Simscript is a simulation language with
both declarative and procedural features,
designed for discrete-event and
hybrid discrete/continuous modelling.
It has been in continuous use and
development since its invention in 1962.
The syntax and semantics of Simscript II are
designed to make simulation programs easy
to write and understand. The
language syntax is "English-like" and
fairly high-level. Like many
simulation systems, items in the system
under study are represented in the language
as attributed
objects. The user defines what
attributes each class of objects possess.
Basic data types for
attributes and procedural code variables include
integers, reals, strings, and pointers.
Composite data types include arrays, sets,
and lists.
All data elements in a Simscript program
are dynamic - memory allocation is fully
automatic. Procedural code can use
simple conditional and iteration
constructs, subroutines, and
functions. Scoping is simple: each entity
and variable belongs to global scope, or is
local to some routine.
Like Simula, Simscript uses a concurrent
process model for discrete-event simulation.
Nodes of a system are represented by
instances of a particular process class,
and can invoked on a time basis or in
response to simulation events.
The language also includes facilities for
data gathering, statistics, random-number
generation, various kinds of I/O, and
process synchronization.
Early versions of Simscript produced
Fortran code output. Simscript II.5
produces C code. In both cases, the
generated code would be compiled and linked
with a run-time library.
Simscript II.5 is a commercial
product sold by CACI Products Company.
Documentation is available from the company
web site, and trial versions of the software
can be downloaded from there, too.

Simula67 is a block-structured procedural
language with some object-oriented programming
features. It was the first language to
supply abstract data type and class support,
and is therefore recognized as one of the
founding elements of object-oriented computing.
Simula syntax is similar to that of Algol,
but with special features and keywords for
record classes and type support. Other
features of Simula include: basic
numeric data types, strings, strong type
checking, basic control structures,
data encapsulation, simple inheritance,
simple I/O support,
some
polymorphism, and special semantics for
discrete-event simulation. The
execution of a Simula program consists
of one or more processes, each of which
is an instance of some class. Objects
can interact with eachother somewhat
independently; Simula supported a
primitive form of concurrency (co-routines).
Simula I was designed in 1962 and
first implemented in 1964; it was an
extension of Algol 60 for discrete-event
simulation. In 1967, the more general-purpose
Simula67 was introduced, with a
wider set of data types and object support.
Simula was standardized in 1977.
Today, the language is controlled by a
small independent standarization body,
the SSG,
dedicated to ensuring compliance by all
Simula language compilers with the
official language definition.
Simula is available free for just about every
general-purpose computing platform. Some
of the Simula implementations are native
compilers, and some are Simula-to-C translators.
Many free add-on libraries and packages
exist, and are available free for Simula
programmers.
Information about Simula, including
programming tutorials and source examples,
is surprisingly widely available on the WWW.

Sina is an academic object-oriented language
designed around the Composition Filters
Object Model.
As an OO language, Sina supplies the usual
features like inheritance, encapsulation,
and abstract data types. The structure of
a Sina program is simply a collection of
classes. Each class may be separated into
an interface and an implementation. Each
interface and implementation can contain
external and internal state,
invariant conditions, methods,
and filters.
Individual methods (and filters) contain
sequential code; the control structures
supported by Sina are: if-then-else, while
loops, and a numerically-oriented for
loop.
Primitive data types supported by Sina
include: strings, numbers, booleans,
and object references. Arrays are not
primitives, but are provided by a
built-in class.
The only implementation of Sina,
called Sina/st, is an
interpreter written in Smalltalk. The
implementation is available free, but
requires a copy of a commercial Smalltalk
system. The current version as of late
1996 was Sina/st 3.1.

SISAL is a functional programming language
designed for parallel processing.
The name SISAL stands for Streams and
Iteration in a Single Assignment Language.
It is intended for use programming
scientific application on multi-processor
supercomputers, and for educational use
in teaching parallel programming.
The lexical structure of SISAL is similar
to that of Pascal. The syntax is simple
and uniform, with special keywords for
controlling arrays and iteration.
Data types in SISAL include integers,
reals, strings, multi-dimensional arrays,
and records.
Control structures in SISAL look
deceptively familiar, but have functional
rather than procedural semantics.
The semantics of the 'for' loop are
particularly rich, although somewhat
complicated.
SISAL is strongly typed, and no implicit
conversions are supported; all data type
casting must be explicitly specified by the
programmer. Other programming
features of SISAL include multi-arity
functions, user-defined data types,
sophisticated array handling, a large
library of built-in math functions,
and streams-oriented I/O.
The mathematical foundations of SISAL
are similar to that of other functional
languages: all computations produce
results, and computations do not produce
side-effects. Further, SISAL programs
are guaranteed to be deadlock-free and
determinate, even in parallel environments.
The main SISAL implementation is an
optimizing compiler with back-ends
targetted for different parallel architectures.
There are also subset SISAL interpreters
for beginner use. All SISAL language
implementations are free. It runs one
a fair variety of platforms, including
many UNIX systems, PC, Macintosh, and
Cray and Intel supercomputers.
Documentation for the language and its
compilers is easily available on the WWW.

Origin:

John Feo et al, Lawrence Livermore National Laboratory, 1990.

Date:

Last updated 11/7/99

SLAM

Language type:

M - Mathematical or Simulation

Description:

SLAM was a discrete system modelling
language, mainly oriented toward discrete
event simulation of service scheduling,
manufacturing, military logistics,
computer architectures, and other
interconnected concurrent systems. SLAM is a
proprietary language owned by Pritsker &
Associates (now Pritsker Corporation).
SLAM went through many versions, the
last being 4.2. The language had a
Fortran-like syntax, with special
operators for defining discrete
event networks. The language offered
a wide variety of network components,
probability distributions, and reporting
options.
SLAM is implemented as a Fortran
preprocessor. Editions are available
for most Unix systems, mainframes, and
Windows PCs. Some versions had
slightly different names, like "Slamsystem."
SLAM has been superseded by newer
products, but is still used in academic
settings to teach queuing system simulation
and related topics. Information on
SLAM is not easily available on the web.

Smalltalk is a dynamic object-oriented
language originally designed in the 1970s.
It was originally designed as an experiment,
but evolved into a powerful
application development language.
Smalltalk is a pure object-oriented language:
all data are encapsulated as objects, and all
operations and functions are performed by
sending messages to objects.
All objects inherit from an
Smalltalk's programming model is very rich
and mature, supporting inheritance,
abstract data types, polymorphism, automatic
memory management with garbage collected,
delegation, reflection, and persistence.
Unlike some newer OOP languages, Smalltalk
is not strongly typed. The language
typically does not enforce type constraints,
and method declarations usually do not
include type declarations.
Fundamental data types supported by the
language include
integers, reals, strings, booleans, and
arrays.
The standard class library distributed with
every Smalltalk system includes a wide
variety of
collection classes (such as vectors,
trees, hash tables, etc.), stream-oriented
I/O facilities, object persistence support, and
graphical user interface classes.
Early Smalltalk implementation were
interpreted, but most modern implementations
employ translation to abstract machine
intermediate codes and/or dynamic native
compilation (so-called "Just-in-time"
code generation).
As of late 1997, an ANSI standard for
Smalltalk was in draft form under the J20
committee. The final standard is expected
in late 1998.
Several commercial and free Smalltalk
implementations exist, for all sorts
of platforms. On of the more popular
free implementations, for Unix systems,
is GNU Smalltalk. IBM and ObjectShare are
the primary commercial Smalltalk vendors.
Good information and documentation
about the language, as well as free
class libraries of all sorts, can be
found on the web.

Origin:

Alan Kay and Xerox Software Concepts Group, 1972.

Date:

Last updated 6/19/98

SML

Language type:

F - Functional or lambda-based

Description:

SML is the standardized definition for
the powerful functional language ML.
See the ML entry for more information.

SNOBOL is a very powerful but eccentric
programming language primarily oriented
towards string data handling. Developed
as a research project at Bell Labs 1960-1962,
it gained a small but loyal following and
has enjoyed modest popularity ever since.
There were various versions of SNOBOL, but
the main one was and is SNOBOL4.
While SNOBOL offers the usualy arithmetic
and variable assignments of conventional
languages, its
essence is string pattern
matching. The language syntax supports
extremely powerful string recognition
and manipulation constructs that allow
many types of data manipulation to be
expressed in SNOBOL very concisely.
Control flow in SNOBOL is mostly done on
the basis of string matches or lack
thereof, but modularity in the form of
subroutines is also part of the language.
Data types offered in the language include
strings, reals, integers, and homogeneous
arrays.
SNOBOL4 is wonderfully documented in the
1971 book The SNOBOL4 Programming Language, 2nd Edition.

Created as an attempt to combine visual, logic,
and set-based programming disciplines, SPARCL
is an academic programming system developed
to aid exploratory programming.
As a logic programming language, SPARCL supports
definition of facts and relationships between
them. The system has three kinds of
clauses: facts, rules, and questions, although
any rule can be queried as a question if the
user wishes. Data types supported by the
language seem to be numbers and atoms.
Execution in SPARCL, as in Prolog,
occurs in response to a question. The
language system performs a unification of
the facts and rules presented by the
visual diagrams. Backtracking is the
unification strategy employed by the current
implementation.
There is only one implementation of
SPARCL, for the Mac, available free
from the language's web site.

Tcl (pronounced 'tickle') is a block-structured
interpreted scripting language intended
for portable
application development and extension.
The name originally stood for 'Tool
Command Language.'
The language and its interpreter were
designed to be easy to use for development
projects, and also easy to bind to other
programs and libraries written in C or C .
Tcl is frequently mentioned along with its
associated graphical toolkit, Tk. The
package, Tcl/Tk, is a complete system for
writing portable GUI applications.
Tcl and Tk are built to allow a programmer
to extend them with additional code written
in C/C , or to embed them into a larger
C/C application to serve as that application's
scripting language.
The syntax of Tcl is fairly simple, but
uses the command language paradigm
of verb-noun rather than the more
common expression-statement paradigm
used by scripting languages like Perl
and JavaScript. This approach makes
the language somewhat unforgiving in
terms of coding style. Tcl was originally
heavily oriented towards creating,
evaluating, and processing
strings. Tcl's syntax includes several
subtly distinguished quoting mechanisms.
Like many interpreters, Tcl has the ability
to create and then execute code on the fly.
Tcl offers a small set of very flexible
data types: numbers, strings, lists, and
associative arrays. In practice,
lists and associative arrays get used
for just about everything.
Tcl includes a conventional complement of
control structures: if-then-else, loop,
switch, and exception handling structures
are all provided (but with some quirks
driven by the command language verb-noun
structure.)
Tcl has extensive I/O capabilities, as
well as good features for invoking and
controlling local utility programs.
Tcl also provides network I/O support,
and mechanisms for asynchronous (event-driven)
scripting. Tcl does not support
a general concurrency or threading model.
Tk is a comprehensive GUI toolkit
offering the usual buttons, menus, labels,
and scrollbars. It also offers higher-level
facilties like lists, a vector-graphic
canvas, a sophisticated text display/editor,
color and clipboard management, and more.
Tcl was originally designed to be a common
scripting language to be embedded in
Unix graphical tools (the inventor of Tcl/Tk,
John Ousterhout, is also famous for his
contributions to the VLSI tool community).
Tcl evolved greatly in the early 1990s,
becoming a powerful scripting language
suitable for crafting whole applications.
In the mid-1990s, it was first ported to
a platform other than Unix, and has since
been ported to over a dozen operating
systems. Tk works under the X Window
System, MS-Windows, and the Macintosh.
Versions of Tcl prior to 8.0 were
strictly interpreted, and suffered from
a variety of performance problems related
to the interpretation process and the
interpreter's data storage mechanisms.
These problems were fixed in version 8.0,
and the language now employs an on-the-fly
bytecode compiler, and the data storage
management has been re-designed and
improved. Other new features in version
8.0 include reflection, separate namespaces,
and various system-dependent enhancements for
MS-Windows.
Information about Tcl/Tk is widely
available on the web, and there are also
a few good books about Tcl programming.
Extensions and add-ons for Tcl are common
and popular, especially extensions that
support object-oriented programming. A
very wide variety of such add-ons are
available free from Tcl download archives.
Various development tools are also
available, some free and some commercial.
Tcl/Tk 8.0 is available free from
Sun Microsystems for Unix, Windows,
Macintosh, and other platforms.

Origin:

John Ousterhout et al, UC Berkeley, 1990.

Date:

Last updated 11/7/99

TECO

Language type:

D - Database or Text-processing

Description:

Teco was an editor and interpreted text
editing language characterized by
extremely terse syntax.
Teco offers extensive facilities for
text manipulations, keyboard handling,
and screen drawing. Built-in data
types include integers,
strings, buffers, dispatch tables.
Some versions had additional data types.
Control structures supported included
simple loop and conditional constructs,
as well as means for defining new functions
(macros) and binding them to user input in
various ways.
Teco is an interpreted language. Original
interpreters were written in platform
assembly language, later ones were written
in C or other languages.
Implementations of Teco are available for
some Unix systems, VMS, MS-DOS, and for
many obsolete DEC operating systems.
Manuals are often included with
distributions.

Telescript is an object-oriented
language and run-time support system
designed for creating
portable GUIs,
messaging applications,
software
agents, remote application scripts,
and other kinds of distributed
computation systems.
The run-time system that supports
Telescript programs is called Magic Cap.
It provides GUI, messaging, network, I/O
and other services.
As a procedural OOP language, Telescript
supports the usual sequential control
constructs, as well as simple data types
like fixed- and floating-point numbers,
and strings.
Telescript supports simple interheritance
and a form of multiple inheritance using a mix-in
set-up like some dialects of Lisp.
All object classes inherit directly or
indirectly from the Object class;
method arguments may also subject to a
simple form of type-predicate constraints.
It also supports simple error handling using
a try/catch syntax.
Telescript also includes notions of
authority and ownership
to provide security restrictions for
software agents. Classes in Telescript
can belong to class families, which are
a form of generic class factory.
Telescript programs are compiled into
native code for a target platform, or into
portable bytecodes for the Telescript
engine (a virtual machine). As of the
end of 1997, Telescript development tools are
restricted to the Macintosh platform, although
the engine is more portable (Windows, some
Unix).
The only implementation of Telescript
is General Magic's Magic Cap product,
the compiler and development environment
are sold by Metrowerks.
Information on the language is available
on the web, but not easy to find. A
great deal of information is available
under General Magic's web site.

Invented to simplify low-level programming
on the Intel x86 line of microprocessors,
Terse is a small block-structured language
with a set of operators tightly bound to
the x86's capabilities.
The basic syntax of Terse is statement-oriented,
with an extensive (and unusual) set of
operators. The data types available in
Terse are the data types supported in the
instruction set of the target x86-series
processor: integers, reals, byte strings,
and various kinds of pointers.
As a venier over assembly, Terse does not
support complex data abstractions; it does
support arrays.
Terse supports a modest set of control-flow
structures based on the branch instructions
available on the x86 operators. It has
conditional and looping structures, and
supports jump tables and other low-level
control structures. Terse supports
subroutines and functions, plus x86
interrupt handlers.
There is only one implementation of Terse,
a commercial system for DOS and Windows
operating systems.

TeX is a descriptive, interpreted language
used to process, format, and typeset
documents. TeX also has many of the
facilities of a block-structured language,
and is used to extend the text formatting
system of which it is a part.
TeX statements (macro calls) are normally
embedded and interspersed through text
to be formatted. Most TeX programming
is confined to macro and extension
packages written to allow TeX users to
create new, improved, or specialized kinds
of documents.
For doing this kind of programming,
TeX offers string and numeric data types,
very simple control flow constructs,
and the ability to define macros (analogous
to subroutines).
TeX is implemented as an interpreted
macro processor for the control of a
general engine for producing typeset
documents. The engine provides very
simple but general-purpose formatting
commands (called Plain TeX),
and facilities for building up more
sophisticated commands in the TeX
language.
While TeX is powerful enough to express
(at least) all primitive recursive
predicates, its syntax makes it ill-suited
for general-purpose computation.
Several commercial and free implementations
of TeX exist. Free versions of
TeX for Unix, Mac, Linux, Windows, and other
systems can be downloaded
from sites on the Comprehensive TeX
Archive Network.

Theta is an object-oriented language with
a sophisticated and
flexible type system, developed by
the MIT Programming Methodology Group.
Theta supports a fairly conventional set
of built-in data types and control
structures. Integers, reals, characters,
strings, booleans, and subroutine
references are all primitive types.
Composite types are parameterized (generic),
and include arrays, sequences, vectors,
records, and structs.
Control structures include conditional
and loop constructs, and simple
exception handling.
The parameterized type system of Theta is
very powerful, and allows a programmer to
cleanly define new abstract type
templates with desired properties.
Object classes in Theta are associated
with user-defined types: a type is
implemented by one or more classes.
Theta supports single inheritance for
classes; the programmer can restrict how
a class may be subclassed (like Java but
more flexibly).
Theta uses a rooted type hierarchy: all
types are subtypes of "any"
(even built-ins like "int").
Routine types are also part of the
hierarchy, and the type rules are used
to enforce method call type conformance.
Types are decoupled from classes.
Theta supports separately compiled modules,
optionally supplying multiple implementations
for a particular type interface.
Memory management in Theta is dynamic
and automatic. Unreferenced objects
are reclaimed by a garbage collector.
The Thor database provides object persistence
for Theta objects.
As of early 1998, the MIT Theta implementation
was not available for download, possibly
because Theta is bound to Thor? The Theta
reference manual is available (link below).

Turing is a structured programming language
designed for teaching computing principles
and for simple graphics. Used mainly in
high schools, Turing is meant to be simple
and usable while supporting good programming
practices.
The syntax of Turing is similar to that
of Pascal, but much more forgiving.
Data types include numbers, characters,
and strings, plus arrays and records.
Like Pascal, Turing also supports variant
records and references.
Looping and conditional constructs are
available in the language, and seem a
little more comprehensive than those in
Pascal.
Subroutines and functions are used to
modularize Turing programs, and recursion
is also supported.
In addition to commonplace structured
programming statements, Turing also supports
specification of
invariants and assertions,
like Eiffel, to help
encourage sound algorithm construction.
Recent versions of Turing have gained
libraries for supporting graphics and
GUIs, animation, and other multi-media
operations.
A variant of Turing called "Turing Plus"
was designed for system programming; it
featured type casting and multi-processing,
plus unsigned numeric types and other
system programming conveniences.
This dialect seems to be no longer available
but many of the features in it seem to have
been rolled into Object-Oriented Turing (OOT).
Turing is available for Windows, Mac,
and Unix operating systems, but only
as a commercial product. There is no
free downloadable version or documentation.
Schools can get free trial licences.

Unified Functions and Objects (UFO) is an
object-oriented functional language
designed for implicit parallelism.
The syntax of UFO is fairly simple and
expression-based; some
lexical aspects are reminiscent of Algol.
All UFO functions
are side-effect-free, but the bodies
of functions allow local variables.
Fundamental data types supported by the
language include integers, floats,
chars and strings,
and booleans. Arrays are also supported,
with list expressions for generating
numeric and other sequences.
Control flow constructs include conditional
expressions and loops; the loop constructs
can generate arrays automatically.
UFO supports class definition with
single inheritance, virtual classes, and
stateless classes (similar to Java
interfaces). Generic, or parameterized,
functions and classes are also supported.
In its role as a functional language, UFO
allows the programmer to define
higher-order functions and build up
Scheme-like functional mechanisms.
UFO has a modest library of built-in classes,
collections,
and I/O facilities.
UFO is available free from the authors,
it is currently at version 1.0.

Until is an interpreted dialect of Forth
designed for portability and for use as
an embedded extension language.
Unlike most Forth implementations,
Until is designed to provide easy access
to underlying operating system services,
and to be easily integrated with C programs.
Source code for the Until implementation
is supposedly available, targetted mainly
at MS-DOS but supposedly portable to Unix
as well.

Visual Basic Scripting Edition is a
subset dialect of Visual Basic; it is
an interpreted, procedural language intended
for creating application extension scripts
and for adding interactivity to web pages.
VBScript's syntax resembles that of
Visual Basic: statements are bounded by
end-of-line, and normal Basic keywords
are used for control structures and
code modularity. VBScript supports a
modest set of data types: various numeric
types, strings, dates, booleans, arrays, and
object references. Variables in VBScript
are typed, but the interpreter does not
do strong type enforcement. VBScript
supports subroutines and functions, and
can interact with objects provided by its
environment (usually a scriptable application).
VBScript does not support the definition of
new object classes, nor does it support
overloading or polymorphism. The language
has fairly good support for handling time, dates,
and strings.
The newest version of VBScript also supports
a dictionary object, an associative array
for storing string data.
VBScript is most commonly employed in
web browsers and web servers from Microsoft.
Under the 32-bit Windows environment, any
application can employ VBScript if it
is installed; Microsoft intends VBScript
to be the baseline or typical scripting
language for simple OLE applications.
The first release of VBScript was part of
Microsoft's Internet Explorer 3.0 product; in
1997 they released VBScript 2.0.
Good information about VBScript, including
a hyperlinked reference manual, in available
from Microsoft's web site. Many good books
about it are also available.

VHDL is a modeling and simulation language
intended for study and design of digital
integrated circuits. The name is an
acronym for VHSIC Hardware Description
Language. The syntax and general
appearance of VHDL are similar to that of
Ada, but the semantic structure is quite
different.
A VHDL model consists of a
hierarchy of entities, these entities
usually directly correspond to the parts of
the digital system under study.
Entities operate in parallel during
simulation; the simulations use a
kind of timed dataflow model that is adjustable
by the user (so as to accurately
represent a real circuit or chip).
The
operation of the various entities
can be very simple, like a small
expression, or very complex. VHDL
supports subroutines and functions as
well as conventional sequential
control structures.
Data types in VHDL include bits,
enumerated sets,
integers, reals, time, arrays,
and records. The support for enumerated
types and their use is very good. (Because
most simulations of digital circuits model the
state of a digital signal with more than just
a bit.)
VHDL has good support for modularity and
for separation of
interface and implementation of entities.
First, it support generics for entities;
and second, the interface to an entity
is always separate from the description
of its operation.
This allows simulation's structure to be
built up once, but simulated for several
different hardware technologies.
A variety of VHDL implementations are
available from commercial CAD vendors.
At least one free implementation is
available for Unix systems as
part of the ALLIANCE
educational VLSI package.

Visual Basic is an advanced
structured dialect of Basic
developed by Microsoft, and intended for
application development.
The syntax of Visual Basic is similar to that
of other modern Basic dialects, but with
many additional features.
The
following primitive data types are
supported: integers, reals, strings,
booleans, currency, dates, and
object references. Variables may
be declared, but need not be. Type
checking can be performed, but is enforced
only for declared variables and parameters.
Composite data
types include arrays and
user-defined records. Control
structures include various conditional
and iteration constructs, and rudimentary
error handling mechanisms.
Memory management in Basic is automatic.
Visual Basic is nominally an interpreted
language, but newer implementations
include native code compilers. During
execution, Visual Basic programs are
normally supported by a run-time library.
Visual Basic is a commercial product.
A subset edition is available free,
the full development environment must
be purchased. Visual Basic runs on
Microsoft Windows platforms. Information
about the language and other resources
for developers are widely available
on the Internet and in print media.

Origin:

Microsoft Corp, 1990.

Date:

Last updated 1/8/98

W

WordBasic

Language type:

A - Application/Macro

Description:

Dialect of Basic used as the
extension language for the
popular Microsoft Word program,
versions 2 through 7. Superseded
by VBA.

Xlisp is a dialect of Lisp; it is
basically a free edition of Common Lisp
with object-oriented extensions.
XLisp is somewhat fragmented, there are
several major implementations available.
They are all free, however, and run on
major platforms including Unix, Windows,
and Macintosh.

Yorick is an interpreted block-structured
language intended for data analysis
and data graphics. It is designed to
be easy to use, but scalable to very
large datasets and very complex computations.
The syntax of Yorick is very simple, and
the language looks somewhat like a simplified
C. Variables need not be declared.
Data types supported include integers,
floating-point numbers, vectors of numbers,
and file handles. The language does
support definition of procedures and
functions, along with a simple
set of conditional and loop control
structures.
Yorick can also be extended with C
code and libraries.
Yorick includes extensive facilities for
creating and manipulating numeric vectors
and datasets. Some versions
can read and write
a variety of
scientific data formats. Yorick has
a broad set of data display and graphing
facilities. One of the language's
main purposes is filtering and
graphing scientific data
obtained from huge experiments and
numeric simulations.
There is only one implementation of Yorick,
available free from LLNL. It runs on Unix
and Linux systems, Macintoshes, and
32-bit Windows.

ZPL is an array programming language
designed for efficient parallel implementation.
It is used for scientific computations.
Basic data types in ZPL include a wide
variety of integer and real numeric types,
strings, and booleans. It also supports
both record aggregate types (like C structs)
and two kinds of arrays: parallel and
non-parallel.
ZPL supports a wide
variety of compound statement
types and implicitly parallel operators.
Its statement syntax is vaguely
similar to that of Pascal or Ada.
Of course, being a parallel language, ZPL
imposes some restrictions on use of
conditional flow control.
Procedures can be defined, and may be
declared as parallel.
The program structure facilities
of ZPL are
very primitive: all code must reside in
a single source file.
The current ZPL implementation is a
translator: the ZPL code is converted to
ANSI C, which is then
compiled with a platform-specific library.

As part of the TUNES project, F. Rideau is examining all existing languages,
operating systems, virtual machines, and UI systems. This language list is
pretty broad, contains both subjective and objective critique of
the various languages, and the related reviews under the main
reviews page are also pretty cool.
[Large flat HTML file, some links]

The largest and most comprehensive list on the net, and a fine job
by the CUI group at University of Geneva and Bill Kinnersley. This list
has a very good search capability, and many of the entries have links
to FTP sites for compilers and tools. Unfortunately, some of the
links on the list are a little out of date, but its source
attribution and journal references are great.[Very large searchable database]