|
|
There are currently
many different programming languages being used on the Web.
Each one has its own particular strengths and weaknesses. A
programming language should both provide means to describe primitive
data and procedures and means to combine and abstract those
into more complex ones. Programming is used on Web sites to
add intelligence and increased interactivity.
MVI Solutions uses
each of these programming languages in the areas where they
are most applicable. Click here to learn more about MVI Solutions's
computer programming languages
or click here to learn more about
Web programming languages.
Below is MVI Solutions's comprehensive list of programming languages, for additional information contact us at: info@mediavue.net.
| ABC |
ABEL |
ADL |
| Aleph |
Algol 60 |
Algol 88 |
| APL |
AppleScript |
ASP |
| Assembly |
Awk |
BASIC |
| Befunge |
BETA |
Bigwig |
| Bistro |
Blue |
C |
| C++ |
C-Sharp |
Caml |
| Cecil |
CHILL |
Clarion |
| Clean |
Clipper |
CLU |
| Cobol |
CobolScript |
Cocoa |
| Comparison and Review |
Compiled |
Component Pascal |
| Concurrent |
Constraint |
Curl |
| D |
Database |
Dataflow |
| Declarative |
Delphi |
Directories |
| DOS Batch |
Dylan |
E |
| Eiffel |
ElastiC |
Erlang |
| Euphoria |
Forth |
Fortran |
| Frontier |
Functional |
Garbage Collected |
| Goedel |
Hardware Description |
Haskell |
| HTML |
HTMLScript |
HyperCard |
| ICI |
Icl |
IDL |
| Imperative |
Intercal |
Interface |
| Interpreted |
Java |
JavaScript |
| LabVIEW |
Lagoona |
Language-OS Hybrids |
| Leda |
Limbo |
Lisp (351) |
| Logic-based |
Logo |
Lua |
| m4 |
Markup |
MATLAB |
| Mercury |
Miranda |
Miva |
| ML |
Modula-2 |
Modula-3 |
| Multiparadigm |
Mumps |
Oberon |
| Obfuscated /td>
| Object-Oriented |
Objective-C |
| Objective Caml |
Obliq |
Occam |
| Open Source |
Oz |
Parallel |
| Pascal |
Perl |
PHP |
| Pike |
PL |
PL-SQL |
| Pliant |
POP-11 |
Postscript |
| PowerBuilder |
Procedural |
Prograph |
| Prolog |
Proteus |
Prototype-based |
| Python |
REBOL |
Reflective |
| Regular Expressions |
Rexx |
Rigal |
| RPG |
Ruby |
S-Lang |
| SAS |
Sather |
Scheme |
| Scripting |
Self |
SETL |
| SGML |
Simula |
Sisal |
| Smalltalk |
Snobol |
Specification |
| SQL |
Squeak |
T3X |
| Tcl-Tk |
Tempo |
TOM |
| TRAC |
Turing |
UML |
| VBA |
Verilog |
VHDL |
| Visual |
Visual Basic |
Visual DialogScript |
| Visual FoxPro |
Water |
Wirth |
| XML |
XOTcl |
YAFL |
|
Yorick |
|
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 top-down programming, ABC supports 'refinement', a mechanism for declaring operations in-line and defining them later in the code.
ABC the language is not really distinct from its programming environment (some dialects of Basic, and many of Lisp, also have this property). Expressions or statements in ABC can be part of function or predicate, or can be given directly to the environment for immediate execution.
ABC's high-level operators and data structures allow many kinds of computations to be expressed very succintly. ABC has been used to write simple natural language parsers and databases.
ABC is available for some Unix systems, MS-DOS, and for the Macintosh. Some information is available on the web, and there are also books about the language.
ACSL
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.
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.
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.
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 general-purpose industial and scientific programming.
Dialects of Algol include the original Algol58, Algol60, Algol68, ABC Algol, Algol W, S-Algol, and many other variants. Algol58 was originally called the "International Algebraic Language" (IAL).
Data types supported by Algol60 include booleans, various sizes of integers and reals, and strings. Support for strings was limited in standard Algol, but later dialects and implementations added more support. Algol60 was strongly typed in the sense that the compiler checked parameter types in expressions and subroutine calls. It did not permit the declaration of new data 'types' or data structures. Arrays are the only composite data type in Algol60. Algol60 supported highly regular block structure and a complete set of control structures: if-then-else, case, while loops. One of Algol's main contribution to programming was the introduction of block nesting and lexical scoping of local and block variables. Algol60 did not support any kind of general memory management or dynamic memory allocation.
Various implementations of some Algol dialects are still available commercially. Information on the web seems sparse, but some documentation of Algol68 is available. Of course, many old programming books describe the language.
Algol68
Language type: S - block-structured
Description:
Algol68 was a greatly expanded and enhanced version of the Algol block-structured language. Many capabilities were added to the sound framework of Algol60 to create a much more capable language for general application and systems programming.
Algol68 introduced a large number of new features over previous versions: formalized syntax and semantics, parallel programming constructs, new data types and structuring methods, and type declarations. Primitive data types supported by Algol68 include booleans, chars, strings, integers, reals, complex numbers and references. Dynamic arrays, structures, and unions are available for building complex data structures. Algol68 also supports separate compilation modules, as Algol60 did. Also like its predecessor, Algol68 is very strongly typed.
A few implementations of Algol 68 and various dialects of it exist, including some for PCs and mainframes.
APL
Language type: M - Mathematical or Simulation
Description:
APL is an interpreted mathematical language characterized by its terse syntax and bizarre non-ASCII character set. It is very strong in all forms of arithmetic and matrix manipulation.
APL was invented in the 1960s, and has enjoyed some modest popularity ever since. Commercial and free APL implementations exist for most modern platforms.
The original APL has been partly superseded by advanced variants, such as APL2, J,
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, an 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.
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.
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.
BASIC
Language type: S - block-structured
Description:
The Beginners All-purpose Symbolic Instruction Code (BASIC) was designed by two graduate students at Dartmouth 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, string, and array datatypes, but no structures or objects.
Basic has enjoyed steady popularity and usage since about 1965, and has evolved greatly since then. Modern Basic dialects, such as Visual Basic, eschew line numbers, support objects, libraries, GUIs, databases, optimizing compilers, garbage collected dynamic memory management, and much more. Basic was and still still is loosely typed, and has poor support for enforcing program portability.
Dialects and subsets of Basic are often designed as extension or macro languages for programming systems on PCs.
BCPL
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.
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 Befunge-93, the grid was fixed in size: 80x24, but Befunge-97 allows an unlimited-size grid.
In Befunge-93, the data types supported were 32-bit integers and bytes, but Befunge-97 supports only machine-width integers. Befunge-97 also supports a broad set of interpreter directives (very roughly analogous to assembler directives or C preprocessor directives) to help the programmer take advantage of the larger grid.
Several free implementations of both old Befunge-93 and newer Befunge-97 exist, some explicitly for PCs and at least one that is highly portable (based on Perl). Fairly good documentation and some example programs are available on the web.
BETA
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 object-oriented programming with Simula.
BETA language features include: strong type checking, inheritance, concurrency, object persistence, runtime type identification, garbage collection, polymorphism, and GUI support. The syntax of BETA is somewhat like Pascal and somewhat like C. Punctuation symbols are used for many syntactic elements in place of keywords, giving the code a terse, compact appearance.
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.
BLooP
Language type: S - block-structured
Description:
BLooP was a very simple recursive block structured language invented by Douglas Hofstadter for his book Godel, Escher, Bach. It features simple subroutine structure, very simple number and boolean handling, and recursion. The interesting aspect of BLooP was that it offered only bounded loop constructs, and was therefore incapable of expressing certain general recursive computations.
C
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.
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 run-time checking; unlike Java, C# supports C-style unsafe pointers, but only within specially designate code sections. C# supports a string type that is an object, but otherwise tightly integrated with the rest of the language (just like Java).
C# supports single inheritance, overloading, overriding, reflection, and polymorphism. Overriding must be done explicitly. Because C# was intended mainly to support development on Windows operating systems, the C# object model is designed to correspond directly with Microsoft's COM/DCOM object mode. C# also supports an interesting mechanism, called properties, that allow a coder to expose object methods but permits the user of those objects to treat them as object data attributes, reminiscent of CORBA IDL and the Self language. Other features supported by C# include structs, indexers, operator overloading, and control over parameter passing.
C# is also designed to run on Microsoft's Common Language Runtime (CLR), a Windows-oriented set of standard packages and object libraries. These standard packages available to C# include a wide variety of data structures, I/O facilites, network support, system interaction support, GUI objects (highly Windows-specific), web services, COM, and much more. C# fully supports exception handling, although exceptions are not always used consistently in the standard packages.
C# provides garbage collection and automatic memory management.
For creating code for handling GUI events and other external triggers, C# offers a novel form of delegation. This is probably the most complex feature of the language, and has not counterpart in C++ or Java, although Objective-C has something equivalent.
Another novel features of C#, which is actually part of the Common Language Runtime, is the notion of Attributes. Attributes are meta-data about code, communications from the programmer to the compiler and run-time system. In C, such things are often done with pragmas and non-standard keywords; in Java, marker interfaces are used. Attributes are much richer than any similar capability in comparable languages. They also add a very complex facet to the language, one which many developers will not need. Fortunately, it is possible to write many C# programs without uses attributes at all.
Currently, the only full implementation of C# is provided by the Microsoft .net compilers. Microsoft makes a command-line compiler available free, under the unintuitive name of the ".Net Framework SDK". Other implementations are under development.
C*
Language type: P - Parallel or Multi-programming
Description:
C* is a dialect of C featuring extended syntax and semantics for supporting parallel processing. It was designed for application development on the Connection Machine line of SIMD massively parallel computers.
Two fundamental added features distinguish C* from standard C: parallel data elements, and parallel computation domains. Each variable in a C* routine is either a 'mono' (scalar) or a 'poly' (parallel) variable. The programmer can define any number of named domains, with domain-local parallel and scalar variables, and then define computations that take place in those domains.
C* supports the same data types and control structures as C.
C* is a commercial product, it was sold along with the Connection Machine CM2 and CM5 systems. No documentation seems to be available on the web.
C++
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.
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 multi-methods, dynamic inheritance, and optional static type checking. Unlike most OOP systems, Cecil allows subtyping and code inheritance to be used separately, thus allowing run-time or external extension of object classes or instances. Like Objective-C, all object services in Cecil are invoked by message passing, and the language supports run-time class identification. These features allow Cecil to support dynamic, exploratory programming styles. Parameterized types and methods (generics, polymorphism), garbage collection, and delegation are also supported.
Cecil also supports a module mechanism for isolation of independent libraries or packages. Cecil does not presently support threads or any other form of concurrency.
A standard library for Cecil is also part of the project, it includes various collection, utility, system, I/O, and GUI classes.
The latest version of the Cecil language definition is 2.1, dated 3/97. Cecil currently runs on Unix and Linux systems.
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.
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.
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 multi-threading. The main facilities that Cilk adds to C are the ability to spawn function calls in parallel, and the ability to synchronize the parallel calls.
Cilk is available free in source form from the Cilk Project web site. It runs on multi-processor Unix and Linux systems, and has also been ported to Windows NT.
CLAIRE
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 multi-threading or extensive operating system interactions (which probably helps it stay portable).
The current version of Claire, as of early 1998, was 2.1. 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.
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.
CMS-2
Language type: S - block-structured
Description:
CMS-2 is a general-purpose programming language used almost exclusively for real-time and embedded applications for the US Navy.
A CMS-2 module consists of two sections: a global declarations "SYS-DD" block and a code "SYS-PROC" block. Both global and local data, as well as procedures, can appear in the SYS-PROC block. Depending on the compiler, there are various facilities for source code inclusion and cross-module linking.
Data types in CMS-2 include: integer, fixed-point and floating-point numbers, fixed-length strings, and enumerations. Identifiers are strongly typed, but unlike Pascal and Ada most versions of CMS-2 had facility for type declaration. The only aggregate data type in CMS-2 is the array.
CMS-2 has a conventional complement of imperative control-flow statements, but with peculiar syntax. Loop statements offer special exit/resume facilities; it is even possible to resume a loop after having exited it! CMS-2 also offers several kinds of index jump table statements (like Fortran's computed GOTO but more complicated).
Over a dozen implementations of CMS-2 were created in the 1970s and 1980s for various US Navy system architectures. A few are still available for sale today through the Navy NUWC. There do not appear to be a free compiler.
COBOL
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).
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:
Basic data types: symbols, numbers (integer, rational, float, complex), characters
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.
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 ABC-bytecodes (roughly RTL-level), which the platform-specific Clean code generator then translates to a native executable.
Fairly good documentation about the language is available at the Clean home site, but most of it is in downloadable PDF rather than HTML.
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.
CORAL 66
Language type: S - block-structured
Description:
Coral66 was a compiled structured programming language, of the Algol family, used for real-time system development.
Not much is available about Coral, but it is described as a small, simple language derived from Algol and Jovial. It supported conventional control structures, subroutines, and machine data types like integers, floats, and pointers. It also included a facility for adding in-line assembly code, possibly due to its typical use for writing embedded control software.
Coral was implemented for many different mini-computers in the 1970s, and was also available on the VAX under VMS. No free Coral66 compilers seem to be available today.
CorelScript
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 MS-Windows OLE automation facility, allowing a CorelSCRIPT program to invoke and control any OLE-capable Windows application.
CorelSCRIPT is a commercial product available only with Corel Corporation products. Meager information about the language is available on the WWW.
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.
CSP
Language type: M - Mathematical or Simulation
Description:
CSP is a simple and elegant language for describing parallel computations and their interactions. It evolved from a formal notation used to discuss communicating independent entities into a formal language for describing parallel systems, simulating them, and reasoning about them.
CSP offers a modest set of conventional computer language features: numberic variables, symbols, and the usual sequential control structures. CSP's strength is in its support for defining parallelism: definitions of processes and communcation buffers.. The fundamental notion of a guarded command was introduced by CSP, and serves as a powerful model for regulating and synchronizing concurrent processes. All of the facilities in CSP were carefully chosen to permit formal proofs about deadlock-freedom and other properties of CSP models.
Because CSP was invented as a formal notation, without many practical features, implementations are rare. Information about CSP is available scattered around the Internet, but journal articles and books have much more detail. One commercial implementation of CSP is used for verifying digital logic design.
cT
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 event-driven execution.
cT is supported by a large library of built-in commands for handling images, videos, sounds, fonts, and other kinds of graphics data, file I/O, network communication, and system interfacing. For portability, cT programs are compiled into a binary intermediate form, to be run by the "cT executor". This is similar to the approach used by Java, except that re-compilation on each platform is recommended.
The cT language is supported by a comprehensive programming environment that provides incremental compilation, interactive debugging, and a visual editor.
cT is available free for Unix systems (X11) from CMU. It is available commercially for Windows and the Macintosh.
Curry
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
FORMAC
Language type: M - Mathematical or Simulation
Description:
FORMAC is a dialect of FORTRAN with an extensive set of extensions for symbolic computation and expression manipulation. It was designed and implemented in the 1960s to support scientific and engineering computing on IBM mainframes.
As a kind of symbolic dialect of FORTRAN IV, the original FORMAC had syntax and overall program structure similar to FORTRAN. Data types supported included all the FORTRAN numeric types, plus rational numbers, symbols, arrays, and expressions. FORMAC programs could include subroutines and functions, and could use other FORTRAN facilities like common areas.
FORMAC was originally implemented as a preprocessor on top of FORTRAN; the formulae and symbolic function calls were transformed into calls to a symbolic manipulation library. For I/O, FORMAC could take advantage of all the usual FORTRAN facilities, and could also print its symbolic expressions.
In the late 1960s, IBM researchers created a similar proprocessor for PL/I, imaginatively named PL/I-FORMAC.
Unlike later symbolic math systems, FORMAC supported creation of expressions but not meta-expressions (rules). This is indicative of its early status in the evolution of symbolic computation, and despite its comparative lack of features it was influential on the field on its immediate successors (e.g. Reduce, Macsyma). FORMAC was used up until the early 1990s.
Forms/3
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.
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.
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 free-form input.
FORTRAN has had many versions over the years, some of the most popular being: FORTRAN I, FORTRAN II, FORTRAN IV, FORTRAN 77, and Fortran90. The current standard is Fortran 95 (ISO/IEC 1539-1), and it includes many modern structured programming features in a traditional Fortran framework. Many specialized and parallel-processing versions of FORTRAN have also been created.
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.
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 cross-module type enforcement.
Gödel is also intended for research into program generation and transformation, parallel constraint programming, and meta-programming.
The only existing implementation of the language was written on top of Prolog.
A substantial implementation of Gödel is available in source form, as well as binaries for various Unix systems. Some documentation and example programs come with the distribution, but real descriptions of the language are limited to hardcopy books.
GPSS
Language type: M - Mathematical or Simulation
Description:
GPSS, the General Purpose Simulation System, is a family of mostly-declarative languages designed for discrete-event simulation and system modelling.
A GPSS simulation program consists of a set of blocks, and connections between them. Block types include generators, queues, servers, selectors/routers, data collectors, timing and computational nodes, and various other types. Data types supported in simulation models varied between versions, but usually included integers, reals, strings, and records. GPSS systems always had sophisticated random sample generators to model various probability distributions that arise in modelling of real-world processes.
Some versions of GPSS are still available for sale commercially, no free versions seem to be available. Documentation for the language is not easily available on-line.
Haskell
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.
Hope
Language type: F - Functional or lambda-based
Description:
Hope is a small, simple functional language based function composition and on the idea of 'call-by-pattern.' A Hope program consists of a set of modules, each of which can contain sets of recursion equations. Current implementations of Hope use full lazy evaluation. Unlike some of the original functional languages, Hope is strongly typed.
There were a couple of dialects of Hope, corresponding to different groups' implementations. The one that seems available today was originally called Hope .
Data types supported by Hope include numbers, symbols, strings, lists, and tuples. (Constituents of a list must be all the same type, while tuples can be heterogenous.) A Hope programmer can define their own primitive and aggregate types. This ability to create true abstract data types is a novel feature in functional languages. Modern implementations of Hope use lazy evaluation.
A free implementation of the Hope interpreter is available for MS-DOS, Unix, and Macintosh.
HyperTalk
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 end-user performs some action or when a certain condition obtains. HyperTalk supports the notion of add-on 'external' functions and commands; these are roughly analogous to library modules in a language like C.
HyperCard 2 compiles individual HyperTalk functions into intermediate codes the first time the function is called. This is done to reduce start-up time for HyperCard applications.
There are several versions of HyperTalk. The two main versions from Apple correspond to HyperCard releases 1 and 2. Aldus SuperCard supports a superset of HyperTalk called SuperTalk. Commercial implementations of both are available for the Macintosh. At one time, SuperCard was also available for MS-Windows, but that may not be true anymore.
ICI
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.
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 goal-directed backtracking. Built-in data types in the language are integers, reals, strings (text), sets, lists, arrays, associative tables, files, and records. Icon variables are typed, but the language performs automatic type casting, so it cannot be said to support strong type checking in the sense of Ada or Modula-2. Icon also supports a very simple form of exception handling; procedures can return one or many values, or they can fail. Failures do not automatically propogate up the procedure call stack as they do in Java or C++.
Icon is not object-oriented, but an object-oriented extension called Idol has been available since 1996.
Icon is normally interpreted, but there is also a translator that generates compilable C code from Icon code. Icon was originally implemented for UNIX, but has been ported to VMS, MS-DOS, 32-bit MS-Windows, OS/2, and the Macintosh.
Icon is distributed with a standard library; most platforms also support a GUI library. The Icon distribution also includes example programs and documentation. Icon implementations are available free from the U. of Arizona ftp site.
INTERCAL
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:
binary bit-level interleave
binary bit selection with packing
unary bit-wise and
unary bit-wise or
unary bit-wise exclusive-or
Strangely enough, this set of operators can be used to build normal integer arithmetic. Data-flow constructs in Intercal are similarly conventional, that is to say, unique. One kind of Goto is provided that pushes its return address onto a fixed-size stack. Mechanisms for disabling statement, both unconditionally and with fixed probability, are also provided. Later versions of Intercal also provide the unique 'Come From' statement. While Intercal does not support subroutines, a similar facility can be constructed with some effort.
Intercal does provide I/O, after a fashion. The original edition of the language could read and write only numbers, and had the interesting disability of being totally unable to read in its own output. Later versions of Intercal provide a bit-oriented I/O facility that based on a model of the differential movement of a Turing machine tape.
The Intercal reference defines a standard library for operations that are difficult to implement in the language, like addition, subtraction, multiplication, and random number generation.
Intercal was originally implemented for IBM mainframes, but since about 1990 a version called C-Intercal has been available for Unix platforms. An implementation is also available for MS-DOS. Information about Intercal is freely available on the web, and documentation and sample programs are included with the distribution.
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.
Java
Language type: O - Object-oriented
Description:
Java is a simple, 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.2 (aka Java Platform 2), includes nested classes, persistence, and reflection 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 also has no facility for generic functions, but since the language imposes a rooted class hierarchy (all object classes inherit from the root class 'Object'), any need for generics is greatly reduced.
Java 1.1 added powerful reflection and object class manipulation capabilities, and uses these to support object serialization I/O.
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, and system interfaces.
Java is typically compiled to platform-independent byte-codes. 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 JDK, it is free.
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".
Jovial
Language type: S - block-structured
Description:
Jovial is a block-structured procedural language derived from early versions of Algol. It provided Algol-like data types and syntax, with structural extensions for large-scale software engineering and for real-time systems.
Jovial is standardized. The original 1973 specification was US MIL-STD-1589, and the most recent 1984 edition of the language standard is MIL-STD-1589C.
At least one commercial JOVIAL is still available, and others are certainly still in use at various aerospace companies. Detailed information about the language does not seem to be available on the web.
Leda
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:
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.
LIFE
Language type: L - Rule-based or logical
Description:
LIFE is an interpreted logic programming language, related to Prolog, with features for functional and object-oriented programming. Intended mainly as a research vehicle, LIFE integrates inheritance, functional, and constraint rule programming styles into a logic programming framework.
The syntax of LIFE is similar to that of Prolog, and its logic semantics are also related to Prolog. Prolog uses indexed Herbrand terms as its primary data element, but LIFE uses extensible psi-terms. Primitive data types supported by LIFE include booleans, integers, floats, symbols, strings, and sorts (a sort is a kind of type descriptor). In addition to psi-terms, LIFE supports lists with the same syntax as Prolog. As a functional language, LIFE supports higher-order functions, currying, and similar operations. It does not support lazy evaluation.
An implementation of the LIFE language is available for free download, it is written in C and works on Unix systems. A programmer's manual and various scholarly papers are also available.
Limbo
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.
Lingo
Language type: A - Application/Macro
Description:
Lingo is the application scripting and extension language used in Macromedia Inc. authoring and presentation products. It is a procedural, event-driven language with English-like syntax and some object-oriented programming features.
Lingo supports a small set of data types primitive data types: numbers, strings, and lists. Lingo also support objects; the language is defined with a large set of pre-defined object classes that pertain to the language's application domains: multimedia, animation, and user interaction. Lingo also supports definition of new object classes, a kind of simple polymorphism, and a form of delegation. Lingo does not support persistence or multiple inheritance.
In Lingo, objects store all of their data on property lists, and also can act on certain kinds of events (such as mouse clicks).
The only implementation of Lingo is the commercial one supplied by Macromedia with its Director product and related products. Documentation from the vendor is modest, but several good books about the language and its use in the Director environment are available. General information about Lingo on the WWW is not widely available, but some does exist.
Lisp
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.
Logo
Language type: F - Functional or lambda-based
Description:
Logo is a functional language designed teach programming and problem-solving principles to children. It is a functional language, related to Lisp, with a simple syntax and a graphics-oriented feature set.
The Logo language provides a set of built-in procedures, a means to create new procedures, a simple data framework with symbols, numbers, and lists, and simple control structures. The language is surprisingly small, but like Lisp can be used to create very complex behavior.
A central concept in Logo is the turtle. Logo was designed for use with a graphics display, and the turtle wanders around the display under the control of the Logo program, drawing lines. Some of the most fundamental statements in Logo move and rotate the turtle. By using Logo's recursive nature, a programmer can cause the turtle to draw all sorts of figures.
Commercial and free implementations of Logo are available for PC/Windows, Macintosh, and UNIX platforms.
New releases of Logo implementations in 1993 and later have added sound, images, and multi-tasking to the basic language. Massively parallel, hardware-embedded, and object-oriented extended implementations of Logo have also been developed. Logo has been used primarily for education, but has also been employed for AI research, robotics, and graphics creation.
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.
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.
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.
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.
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:
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.
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.
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.
Miranda
Language type: F - Functional or lambda-based
Description:
Miranda is an interpreted pure-functional language, intended both for teaching functional programming and for application development.
As a pure functional language, Miranda has no conventional imperative control constructs. Instead, Miranda 'scripts' consist of a set of equations that define various data structures and operations. Data types available in Miranda include booleans, identifiers (symbols), integers, characters, reals, strings, lists, tuples, and functions. Miranda is strongly typed, in the sense that all functions enforce type constraints. Lists are extremely important in Miranda, as they are in many functional languages. Miranda provides a powerful definition syntax for lists called list comprehensions.
Unlike Lisp and the original version of ML, Miranda uses lazy evaluation for all expressions. This allows the language system to support infinite lists and indefinite parameters. Miranda supports many of the higher-order features expected of an advanced functional language: curried functions, first-class functions, sophisticated pattern matching on rule application, and definition of algebraic types.
The syntax of Miranda is very terse and compact. The language has no special statement syntax, everything is an expression. The basic syntax for function application is prefix, but infix notation can also be used in most cases.
The only implementation of Miranda is the commercial one, it is available for most Unix systems including Linux. Information about Miranda is fairly easy to find on the web, but the language system does not seem to be available for download anywhere. Apparently it must be purchased commercially. There are several good computer science books about Miranda.
ML
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 pattern-matching approach to function application.
The name ML originally stood for Meta-Language.
ML developed in several ways during the mid to late-1980s; a common dialect and base set of features were standardized as SML in 1990. The standard was revised in 1997, language systems that comply with the new standard are called SML'97 implementations.
Information on ML is easily available on the Internet. Several free implementations of ML exist for most platforms, some of the most popular are SML/NJ, CAML, and Moscow-ML. At least one commercial implementation, from Harlequin Group is also available.
Modula 3
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.
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.
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 e | |