Welcome to the Dictionary of Programming Languages, a compendium
of computer coding methods assembled to provide information and
aid your appreciation for computer science history.
Browse the dictionary by clicking on a section:
A
B
C
D
E
F
G
H
I
JK
L
M
N
O
P
QR
S
T
UV
WXYZ+
Get a full dump of the dictionary:
List of Names
Short Form
Full Form
- A
-
ABC
- Language type:
- Description:
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.
- Origin:
Geurts and Pemberton, 1987, after Geurts and Meertens, 1975-82
- Date:
-
ACSL
- Language type:
M - Mathematical or Simulation
- Description:
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.
- Origin:
Mitchell and Gauthier Associates, 1981
-
Ada
- Language type:
- Description:
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.
- Origin:
Jean Ichibah et al, 1978-1983.
- Date:
-
Alef
- Language type:
- Description:
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.
- Origin:
P. Winterbottom et al, Bell Labs (Lucent), 1995?
- Date:
-
Algol
- Language type:
- Description:
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:
- Algol68
- Language type:
- 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.
- Origin:
A. van Wijngaarden et al, 1965-68.
- Date:
-
APL
- Language type:
M - Mathematical or Simulation
- Description:
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,
- Origin:
Iverson et al, IBM, 1960s
- Date:
-
AppleScript
- Language type:
- Description:
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.
- Origin:
Apple Computer, 1993 (MacOS System 7), 1994 (MacOS 7.5)
- Date:
-
AutoIt
- Language type:
- Description:
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:
- Date:
- Autolisp
- Language type:
- 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:
- Date:
- 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.
- Origin:
Aho, Kernighan, & Weinberger, 1976-77
- Date:
- T
- T
- Language type:
F - Functional or lambda-based
- Description:
T was an implementation of Scheme originally
developed at Yale University.
- Date:
-
Tcl
- Language type:
- Description:
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:
- 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.
- Origin:
Digital Equipment Corp, 1980?
- Date:
-
Telescript
- Language type:
- Description:
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.
- Origin:
- Date:
-
Terse
- Language type:
- Description:
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.
- Origin:
- Date:
-
TeX
- Language type:
- Description:
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.
- Origin:
Donald Knuth, 1978, 1982.
- Date:
-
Theta
- Language type:
- Description:
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).
- Origin:
Barbara Liskov et al, MIT, 1994.
- Date:
-
Turing
- Language type:
- Description:
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.
- Origin:
R.C. Holt et al, Univ. of Toronto, 1987
- Date:
- O
-
Oberon
- Language type:
- Description:
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:
- Objective-C
- Language type:
- 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.
- Origin:
- Date:
-
Obliq
- Language type:
- Description:
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.
- Origin:
- Date:
-
occam
- Language type:
P - Parallel or Multi-programming
- Description:
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:
- 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.
- Origin:
Charles Forgy et al, 1977.
- Date:
-
Orca
- Language type:
P - Parallel or Multi-programming
- Description:
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.
- Origin:
Bal, Kaashoek, Tannenbaum et al, 1985-90.
- Date:
-
Oz
- Language type:
- Description:
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.
- Origin:
G. Smolka with Schulte, Henz, Muller, Wurtz et al, DFKI, 1994-97.
- Date:
- T
- T
- Language type:
F - Functional or lambda-based
- Description:
T was an implementation of Scheme originally
developed at Yale University.
- Date:
-
Tcl
- Language type:
- Description:
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:
- 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.
- Origin:
Digital Equipment Corp, 1980?
- Date:
-
Telescript
- Language type:
- Description:
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.
- Origin:
- Date:
-
Terse
- Language type:
- Description:
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.
- Origin:
- Date:
-
TeX
- Language type:
- Description:
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.
- Origin:
Donald Knuth, 1978, 1982.
- Date:
-
Theta
- Language type:
- Description:
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).
- Origin:
Barbara Liskov et al, MIT, 1994.
- Date:
-
Turing
- Language type:
- Description:
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.
- Origin:
R.C. Holt et al, Univ. of Toronto, 1987
- Date:
- A
-
ABC
- Language type:
- Description:
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.
- Origin:
Geurts and Pemberton, 1987, after Geurts and Meertens, 1975-82
- Date:
-
ACSL
- Language type:
M - Mathematical or Simulation
- Description:
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.
- Origin:
Mitchell and Gauthier Associates, 1981
-
Ada
- Language type:
- Description:
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.
- Origin:
Jean Ichibah et al, 1978-1983.
- Date:
-
Alef
- Language type:
- Description:
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.
- Origin:
P. Winterbottom et al, Bell Labs (Lucent), 1995?
- Date:
-
Algol
- Language type:
- Description:
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:
- Algol68
- Language type:
- 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.
- Origin:
A. van Wijngaarden et al, 1965-68.
- Date:
-
APL
- Language type:
M - Mathematical or Simulation
- Description:
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,
- Origin:
Iverson et al, IBM, 1960s
- Date:
-
AppleScript
- Language type:
- Description:
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.
- Origin:
Apple Computer, 1993 (MacOS System 7), 1994 (MacOS 7.5)
- Date:
-
AutoIt
- Language type:
- Description:
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:
- Date:
- Autolisp
- Language type:
- 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:
- Date:
- 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.
- Origin:
Aho, Kernighan, & Weinberger, 1976-77
- Date:
- L
-
Leda
- Language type:
- Description:
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.
- Object-oriented - abstract data types,
classes, and single
inheritance are supported.
- Functional - functions are first-class
values, and Leda can do currying and other
functional operations
- Logical - Definition of logical rules
is supported, with conventional backtracking
goal search.
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:
- 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.
- Origin:
Hassan Ait-Kaci, MCC Texas, 1993.
- Date:
-
Limbo
- Language type:
- Description:
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:
- Lingo
- Language type:
- 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.
- Origin:
Macromedia Inc (formerly Macromind?), 1991-96.
- Date:
-
Lisp
- Language type:
F - Functional or lambda-based
- Description:
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.
- Origin:
- Date:
-
Logo
- Language type:
F - Functional or lambda-based
- Description:
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.
- Origin:
- Date:
-
LotusScript
- Language type:
- Description:
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.
- Origin:
Lotus Development Corp, 1995.
- Date:
-
Lua
- Language type:
- Description:
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:
- 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:
- 54 entries retrieved.
Information about the dictionary:
Here are some other sites that have surveys or dictionaries
of programming languages.
-
NCSA Computing Languages List
-
Pretty broad list, with short descriptions and links for most entries. Also
includes some data-description and formatting languages.
[Large flat HTML file with links]
-
Tunes Review of Programming Languages
-
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]
-
-
More Programming Language Resource Links..
-
Some more resource links with descriptions.
-
-
WWW Virtual Library: Computing, Programming Languages
-
A nice list, not exceptionally broad, but with links for every topic.
[Large flat HTML file, many links]
Descriptions in this dictionary are ©1997-99 Neal Ziring. Some
examples copyright of their respective authors. Some
technologies and languages are trademarked. Permission to
copy descriptions is granted as long as authorship credit is preserved.
Comments on this dictionary, corrections and suggestions, are all welcome.
Please use email, the address is ziring@home.com
[Ziring MicroWeb Home]
[Dictionary Start]
[Sign Guestbook]
Dictionary and script maintained by Neal Ziring, last major modifications 3/18/98. Most recent
additions to dictionary and master list, 1/00.