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.

A
ABC
Language type:
S - block-structured

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 topdown 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:
Last updated 12/6/97

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:
O - Object-oriented

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:
Last updated 1/8/03

Alef
Language type:
S - block-structured

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:
Last updated 11/7/99

Algol
Language type:
S - block-structured

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 generalpurpose 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.

Origin:

A. van Wijngaarden et al, 1965-68.

Date:
Last updated 2/28/98

APL
Language type:
M - Mathematical or Simulation

Description:
APL is an interpreted mathematical language characterized by its terse syntax and bizarre nonASCII 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:
Last updated 2/20/98

AppleScript
Language type:
C - Command or Scripting

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:
Last updated 12/14/97

AutoIt
Language type:
C - Command or Scripting

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:
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.

Origin:
Aho, Kernighan, & Weinberger, 1976-77

Date:
Last updated 11/7/99

B
BASIC
Language type:
S - block-structured

Description:
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.

Origin:
John Kemeny & Thomas Kurtz, Dartmouth, 1963-64

Date:
Last updated 6/3/05

BCPL
Language type:
S - block-structured

Description:
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.

Origin:
Martin Richards, Cambridge University, 1966-67.

Date:
Last updated 12/20/97

Befunge
Language type:
T - Threaded or stack-based

Description:
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 Befunge93, 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.

Origin:
Chris Pressey, 1993.

Date:
Last updated 3/2/98

BETA
Language type:
O - Object-oriented

Description:
BETA is a powerful object-oriented language intended for application development. It evolved in the Scandanavian object-oriented programming community, which helped originate objectoriented 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.

Origin:
Hofstader, 1979 (implementation: Cowan, 1994)

Date:
Last updated 12/6/00

C
C
Language type:
S - block-structured

Description:
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.

Origin:
Ritchie and Thompson, 1972-73; Kernighan and Ritchie, 1978

Date:
Last updated 5/27/98

C#
Language type:
O - Object-oriented

Description:
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 runtime 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 Windowsoriented 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 nonstandard 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.

Origin:
Thinking Machines Corp, 1987.

Date:
Last updated 3/25/98

C++
Language type:
O - Object-oriented

Description:
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.

Origin:
Bjarne Stoustrup, AT&T Bell Labs, 1982-85.

Date:
Last updated 6/30/2000

Cecil
Language type:
O - Object-oriented

Description:
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 multimethods, 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.

Origin:
Craig Chambers, 1992.

CFML
Language type:
C - Command or Scripting

Description:

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.

Origin:
J.J. Allaire, 1995.

Date:
Last updated 11/20/99

CHILL
Language type:
S - block-structured

Description:
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.

Origin:
CCITT, 1976.

Date:
Last updated 2/22/01

Cilk
Language type:
P - Parallel or Dataflow

Description:
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 multithreading. 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.

Origin:
Joerg, Leiserson, et al, MIT, 1995

Date:
Last updated 11/7/99

CLAIRE
Language type:
O - Object-oriented

Description:
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 multithreading 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 SYSPROC 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.

Origin:
Rand Corporation, US Navy, 1974?

Date:
Last updated 10/19/98

COBOL
Language type:
S - block-structured

Description:
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: o Basic data types: symbols, numbers (integer, rational, float, complex), characters

o o o o o o o o o o o o

Lists and an extensive set of list operations Arrays (vectors, strings, bit-vectors) and array functions Hash tables and functions for them Various other specialized data types: property lists, paths, streams, readtables, structures Lexical and dynamic scoping Control structure and function definition forms A very rich Macro system Packages and modules basic I/O, file handling facilities, file system interface Compiler usage and environment OOP for Lisp: The Common Lisp Object System (CLOS) Exception handling

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.

Origin:
Guy L. Steele et al, 1984, 1990. Chapman, ANSI sub-committee X3J13, 1991.

Date:
Last updated 12/13/97

Concurrent Clean
Language type:
F - Functional or lambda-based

Description:
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 ABCbytecodes (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.

Origin:
Royal Signals & Radar Establishment, Malvern UK, 1964-66. Woodward et al, 1970.

Date:
Last updated 3/1/98

CorelScript
Language type:
A - Application/Macro

Description:

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 MSWindows 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.

Origin:
C.A.R. Hoare, 1978.

Date:
Last updated 12/12/97

cT
Language type:
S - block-structured

Description:
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 eventdriven 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.

Origin:
Andersen, Sherwood et al, Carnegie-Mellon, 1990-94

Date:
Last updated 1/25/98

Curry
Language type:
F - Functional or lambda-based

Description:
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. Like many functional languages, Curry supports a declarative I/O model. This kind of model basically represents input and output operations as expressions involving 'the World'. Some of the advanced features of Curry are listed below. o o o o o o o o Functional composition Predicate constraints Nested Expressions Higher-order functions Concurrency Lazy evaluation residuation Narrowing

Curry can also call external functions, which offers a way to support the advanced logical model with more traditional programming. As an academic project, implementations of Curry are available free. Documentation is available on the web, but almost exclusively in DVI format.

Origin:
Michael Hanus,RWTH Aachen, Germany, 1997

Date:
Last updated 8/8/99

D
Dylan
Language type:
O - Object-oriented

Description:
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.

Origin:
Apple Computer, 1992

Date:
Last updated 12/16/97

Dynace
Language type:
O - Object-oriented

Description:
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.

Origin:
B. McBride, Algorithms Corporation, 1993-96.

Date:
Last updated 8/9/02

E
Eiffel
Language type:
O - Object-oriented

Description:
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.

Origin:
Bertrand Meyers, 1986-92.

Date:
Last updated 12/16/97

Elisp
Language type:
A - Application/Macro

Description:
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.

Origin:
Richard Stallman, GNU Project, 1985.

Date:
Last updated 12/16/97

Erlang
Language type:
F - Functional or lambda-based

Description:
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.

Origin:
J. Armstrong and R. Virding, Ellemtel System Laboratories, 1990

Date:

Last updated 9/28/02

Escher
Language type:
F - Functional or lambda-based

Description:
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.

Origin:
J.W. Lloyd, University of Bristol, 1995.

Date:
Last updated 2/19/98

Esterel
Language type:
P - Parallel or Dataflow

Description:
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.

Origin:
G. Berry, L. Cosserat, et al, CMA France, 1983

Date:
Last updated 11/24/98

Euphoria
Language type:
C - Command or Scripting

Description:
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 metaexpressions (rules). This is indicative of its early status in the evolution of symbolic computation, and despite its comparative lack of features it was influential on the field on its immediate successors (e.g. Reduce, Macsyma). FORMAC was used up until the early 1990s.

Origin:
Jean Sammet et al, IBM, 1964.

Date:
Last updated 3/11/98

Forms/3
Language type:
V - Visual or graphical

Description:
Forms/3 is an interpreted visual programming language with an expression-oriented interface and mostly declarative semantics. It is an academic research language. Elements of a Forms/3 form are called cells. Cells can hold powerful functions. The syntax for cell contents is fairly simple, but includes fair support for arithmetic and general sequential programming, as well as various graphical operations. Every cell has a current value. Data types supported in Forms/3 are strings, integers, reals, and booleans. Cell expressions can directly manipulate the appearance and other characteristics of graphical objects in the Forms/3 workspace. Like many other visual languages, Forms/3 embodies a notion of time; it can be compared to a visual simulation system in that respect. Forms/3 allows time to be run both forward and backwards; it also supports semantics for reacting to asynchronous events. One interpreter for Forms/3 exists, it is written in Common Lisp and runs on Unix workstations. The system is available at no charge from the authors.

Origin:
Burnett and Ambler, 1991.

Date:
Last updated 6/12/99

Forth
Language type:
T - Threaded or stack-based

Description:
Forth is an interpreted stack-based language with a very simple syntax and elegant abstract exection model. Designed for efficiency and simplicity, Forth is noted for the very small size of the language system. A Forth program is a sequence of words. Each word is independent, and causes some specified action. Even constants are words: the word "12" is just a command to push the number 12 onto the data stack. Sequences of words can be grouped as procedures, and employed to build up modular programs. In order for this to work, of course, operators and operands must be given in reverse polish order (operands followed by operator). All data manipulation takes place on the data stack, so Forth offers several operations for manipulating the stack. Forth implementations vary in the range of data types they provide, but most provide a conventional set of numeric and string types, plus arrays. Forth offers regular control structures: If-Else, While-Do, and For-Next, albeit with peculiar ordering of the keywords. Most dialects of Forth provides simple file handling and I/O support. Forth is also meant to be extensible at every level. Programmers can define new words, and implement them in Forth itself, in some other high-level language, or in machine code. Information about Forth is widely available on the Internet. There are several commercial and implementations, many available from here.

Origin:
Charles H. Moore, 1969-1971.

Date:
Last updated 2/28/98

FORTRAN
Language type:
S - block-structured

Description:
FORTRAN (from FORmula TRANSlation) is one of the oldest programming languages. Originally developed in the late 1950s, FORTRAN has moved through many versions and is still popular even today. FORTRAN is characterized by its good support for mathematics, especially floating-point computation, its lack of modular programming structures, and implicit declarations, and odd control-flow constructs. FORTRAN is normally case-insensitive. In older versions of the language, the position of text on lines was significant; Fortran90 and later versions support freeform 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.

Origin:
John Backus, 1977.

Date:
Last updated 12/3/97

G
Goedel
Language type:
L - Rule-based or logical

Description:
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 crossmodule 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.

Origin:
G. Gordon, IBM, 1961.

Date:
Last updated 1/2/98

H
Haskell
Language type:
F - Functional or lambda-based

Description:
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.

Origin:
Haskell Committee (Hughes, Wadler, Peterson et al), 1990.

Date:
Last updated 12/21/97

Hope
Language type:
F - Functional or lambda-based

Description:
Hope is a small, simple functional language based function composition and on the idea of 'callby-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.

Origin:
Burstall 1978, Perry, Kewley et al 1985.

Date:
Last updated 1/4/2000

HyperTalk
Language type:
C - Command or Scripting

Description:
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 enduser 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.

Origin:
Atkinson and Winkler, Apple Computer, 1986?

Date:
Last updated 12/7/97

I
ICI
Language type:
S - block-structured

Description:
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.

Origin:
Tim Long, 1992

Date:
Last updated 1/24/98

Icon
Language type:
S - block-structured

Description:
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 goaldirected 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.

Origin:
R.E. Griswold, 1977.

Date:
Last updated 3/19/98

INTERCAL
Language type:
S - block-structured

Description:

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: 1. 2. 3. 4. 5. 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 CIntercal 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.

Origin:
Teitelman and Masinter, Xerox PARC, 1965-1975

Date:
Last updated 12/13/97

J

J
Language type:
M - Mathematical or Simulation

Description:
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.

Origin:
R.K.W. Hui et al, and J Software Inc, 1990.

Date:
Last updated 2/20/98

Java
Language type:
O - Object-oriented

Description:
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.

Origin:
Gosling et al, Sun Microsystems, 1994-95.

Date:
Last updated 10/11/06

JavaScript
Language type:
C - Command or Scripting

Description:
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.

Origin:
Jules Schwartz et al, SDC, 1959-60.

Date:
Last updated 9/26/01

L

Leda
Language type:
O - Object-oriented

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: 1. 2. 3. 4. 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:
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 psiterms. 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:
Last updated 3/17/98

Limbo
Language type:
S - block-structured

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:
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.

Origin:
Macromedia Inc (formerly Macromind?), 1991-96.

Date:
Last updated 12/16/97

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:
McCarthy et al, 1956-61

Date:
Last updated 12/16/97

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 multitasking 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:
Papert et al, MIT, 1967.

Date:
Last updated 12/16/97

LotusScript
Language type:
A - Application/Macro

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:
Last updated 1/3/98

Lua
Language type:
C - Command or Scripting

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:
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.

Date:
Last updated 12/12/97

Magma

Language type:
M - Mathematical or Simulation

Description:
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.

Origin:
J. Cannon, et al, 1993.

Date:
Last updated 1/10/98

Mathematica
Language type:
M - Mathematical or Simulation

Description:
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: o o o o Rule-based semantics will pattern-matching Variety of data types: symbols, several kinds of numbers, lists, vectors, arrays, graphics objects, strings, etc... Full set of procedural control-flow constructs Facilties for reflection and on-the-fly construct of code

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.

Origin:
Stephen Wolfram, 1987.

Date:
Last updated 3/11/98

Mawl
Language type:
C - Command or Scripting

Description:
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.

Origin:
D.A. Ladd, J.C. Ramming, T. Ball, 1995.

Date:
Last updated 3/7/98

Mercury
Language type:
L - Rule-based or logical

Description:
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.

Origin:
David Turner, University of Kent, 1985.

Date:
Last updated 2/25/98

ML
Language type:

F - Functional or lambda-based

Description:
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 patternmatching 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.

Origin:
Standard ML, Milner and Tofte, 1990.

Date:
Last updated 9/23/01

Modula 3
Language type:
O - Object-oriented

Description:
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.

Origin:
Luca Cardelli et al, Olivetti and DEC, 1988.

Date:
Last updated 12/30/97

Modula-2
Language type:
S - block-structured

Description:
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.

Origin:
Niklaus Wirth, 1980.

Date:
Last updated 3/29/03

MUMPS
Language type:
D - Database or Text-processing

Description:
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.

Origin:
Octo Barnett M.D. et al, Mass. General Hospital, 1969.

Date:
Last updated 12/16/97

N
NESL
Language type:
P - Parallel or Multi-programming

Description:
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.

Origin:
Guy Blelloch, Carnegie-Mellon, 1992-93

Date:
Last updated 12/23/97

NIAL
Language type:
F - Functional or lambda-based

Description:
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.

Origin:
M. A. Jenkins et al, Queen's University Ontario, 1981-86.

Date:
Last updated 1/6/98

O
Oberon
Language type:
O - Object-oriented

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:
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.

Origin:
Brad J. Cox, 1984-85 ?

Date:
Last updated 12/12/97

Obliq
Language type:
O - Object-oriented

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 precompiled 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:
Luca Cardelli, DEC, 1993

Date:
Last updated 12/29/97

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:
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.

Origin:
Charles Forgy et al, 1977.

Date:
Last updated 12/22/97

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:
Last updated 2/15/98

Oz
Language type:
P - Parallel or Dataflow

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:
Last updated 9/3/98

P
Pascal
Language type:
S - block-structured

Description:
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.

Origin:
Novell Corporation, 1995?

Date:
Last updated 1/24/98

Perl
Language type:
C - Command or Scripting

Description:
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. o o o o o o o data types: strings, numbers, lists, associative arrays, references, globs data types: objects * conventional math and arithmetic functions subroutines, variable argument lists dynamic memory handling with garbage collection extensive file I/O facilities extensive system interface support

o o o o o o o

regular expression pattern matching and substitution very extensive data output formatting capabilities various loops and conditional constructs object definition and inheritance * separable namespaces (packages) * lexical and dynamic scope local variables * on-the-fly code evaluation and error handling

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. Addon 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.

Origin:
Larry Wall, 1986

Date:
Last updated 12/16/97

PHP
Language type:
C - Command or Scripting

Description:
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.

Origin:
R. Lerdorf, 1995.

Date:
Last updated 11/13/99

Pict
Language type:
P - Parallel or Dataflow

Description:
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: o o o most of the Posix-standard operating system facilities image handling X11 windows and graphics

For composing larger programs, Pict has a simple import module import facility.

Origin:
B.C. Pierce, D.N. Turner, 1993

Date:
Last updated 9/11/99

Pike
Language type:
O - Object-oriented

Description:
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: o o o o o o o o o o 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: o o o o o o o o o o o o 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).

Origin:
George Radin, IBM, 1964.

Date:
Last updated 12/4/97

Postscript
Language type:
T - Threaded or stack-based

Description:
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 lookahead 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.

Origin:
John Warnock et al, Adobe Systems, 1982.

Date:
Last updated 12/16/97

Prolog
Language type:
L - Rule-based or logical

Description:
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.

Origin:
D.H. Warren 1977, R. Kowalski 1979, Clocksin and Mellish 1980-84

Date:
Last updated 12/7/97

Python
Language type:
O - Object-oriented

Description:
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.

Origin:
G. van Rossum, 1991.

Date:
Last updated 8/4/100

Q
QBasic
Language type:
S - block-structured

Description:
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: o o o 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.

Origin:
John Carmack et al, id Software, 1996.

Date:
Last updated 12/13/97

R
REBOL
Language type:
F - Functional or lambda-based

Description:
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.

Origin:
C. Sassenrath, 1997.

Date:
Last updated 10/17/98

Reduce
Language type:
M - Mathematical or Simulation

Description:
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.

Origin:
Anthony Hearn, RAND Corp, 1963.

Date:
Last updated 9/28/98

Rexx
Language type:
C - Command or Scripting

Description:
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.

Origin:
M. Cowlishaw, IBM, 1979 - 1985.

Date:
Last updated 12/16/97

RPG
Language type:
D - Database or Text-processing

Description:
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.

Origin:
IBM, 1965.

Date:
Last updated 3/28/100

Ruby
Language type:
O - Object-oriented

Description:
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.

Origin:
Y. Matsumoto and others, 1993-95.

Date:
Last updated 12/13/01

S
S
Language type:
M - Mathematical or Simulation

Description:
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.

Origin:
R.A. Becker et al, 1977-84.

Date:
Last updated 1/6/98

Sather
Language type:
O - Object-oriented

Description:
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. o o o o o o o Exception handling Closures and iterators Multiple inheritance (subtyping) Supertyping Operator overloading Immutable classes Abstract and partial classes

o

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.

Origin:
S.M. Omohundro, C-C Lim, et al, UC Berkeley, 1990.

Date:
Last updated 12/31/97

Scheme
Language type:
F - Functional or lambda-based

Description:
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.

Origin:
Gerald Sussman & Guy Steele, 1975.

Date:
Last updated 12/16/97

Self
Language type:
O - Object-oriented

Description:
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-thefly 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.

Origin:
Steve Bourne, 1971

Date:
Last updated 2/6/98

Simscript
Language type:
M - Mathematical or Simulation

Description:
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.

Origin:
H. Markowitz et al, Rand Corporation, 1962.

Date:
Last updated 1/3/98

SIMULA
Language type:
O - Object-oriented

Description:
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.

Origin:
Ole Dahl and Kristen Nygaard, NCC Olso, 1964-67.

Date:
Last updated 12/10/97

Sina
Language type:
O - Object-oriented

Description:

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.

Origin:
A. Tripathi et al, 1989.

Date:
Last updated 6/19/98

SISAL
Language type:
F - Functional or lambda-based

Description:
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.

Origin:
A.A.B. Pritsker et al, 1976-77

Date:
Last updated 1/2/98

Smalltalk
Language type:
O - Object-oriented

Description:
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.

Date:
Last updated 12/13/97

SNOBOL
Language type:
D - Database or Text-processing

Description:
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.

Origin:
Griswold and Faber, Bell Labs, 1962.

SPARCL
Language type:
V - Visual or graphical

Description:
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.

Origin:

L. Spratt, U. of Kansas, 1993.

Date:
Last updated 8/8/98

SPITBOL
Language type:
D - Database or Text-processing

Description:
SPITBOL was a compiled variant of SNOBOL, available for DEC computers and some other systems. Later marketed for UNIX workstations by Catspaw, Inc.

Origin:
Dewar et al, 1971.

T
T
Language type:
F - Functional or lambda-based

Description:
T was an implementation of Scheme originally developed at Yale University.

Date:
Last updated 12/19/97

Tcl
Language type:
C - Command or Scripting

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 (eventdriven) 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.

Origin:
Digital Equipment Corp, 1980?

Date:
Last updated 1/10/98

Telescript
Language type:

O - Object-oriented

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:
General Magic, Inc, 1995

Date:
Last updated 12/19/97

Terse
Language type:
S - block-structured

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:
Jim Neil, 1987.

Date:
Last updated 11/7/99

TeX
Language type:

A - Application/Macro

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:
Last updated 12/20/97

Theta
Language type:
O - Object-oriented

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:

Last updated 1/8/98

Turing
Language type:
S - block-structured

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:
Last updated 11/21/98

U
UFO
Language type:
O - Object-oriented

Description:
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.

Origin:
J. Sargeant et al, 1996.

Date:
Last updated 5/29/98

Until
Language type:
T - Threaded or stack-based

Description:
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.

Origin:
N.E. Smith, 1991.

Date:
Last updated 2/19/98

V
VBScript
Language type:
A - Application/Macro

Description:
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.

Origin:
Microsoft Corporation, 1995 ?

Date:
Last updated 12/23/97

VHDL
Language type:
M - Mathematical or Simulation

Description:
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.

Origin:
M.R. Shahdad et al, 1985; IEEE Standard 1076, 1987.

Date:
Last updated 10/25/07

Visual Basic
Language type:
S - block-structured

Description:
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.

Origin:
Microsoft, 1992?

Date:
Last updated 12/6/97

X
xlisp
Language type:
F - Functional or lambda-based

Description:
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.

Origin:
David Betz, 1985.

Date:
Last updated 12/29/97

Y
Yorick
Language type:
M - Mathematical or Simulation

Description:
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.

Origin:
Lawrence Livermore National Laboratory, 1994?

Date:
Last updated 12/19/97

Z
ZPL
Language type:
P - Parallel or Dataflow

Description:
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.

Origin:
Snyder et al, University of Washington, 1993.

Date:
Last updated 9/12/98

146 entries retrieved.

Master your semester with Scribd & The New York Times

Special offer for students: Only $4.99/month.

Master your semester with Scribd & The New York Times

Cancel anytime.