Research Language Overviews

This list is intentionally biased towards sequential functional, logic, and object-oriented languages whose design and implementation are the subject of active research. Other language overviews are summarized at the bottom. (Anybody want to compile a similar list for parallel languages?)

Additional language design and implementation projects are described on the research projects page.

Language Overviews

Ada 95
Support for strong type checking, modularity, genericity, object-oriented programming, parallelism, distribution, multi-language programming, system programming, numerics, exceptions, clear syntax, ISO standard approved in February 1995 with a strong validation suite.
The BETA page at Aarhus University.
BETA is a strongly-typed, object-oriented language supporting both procedural and functional programming. BETA's abstraction mechanisms include support for identification of objects, classification, and composition. Numerous abstraction mechanisms, such as classes, procedures, functions, coroutines, processes, exceptions etc., are all unified into a single abstraction mechanism: the pattern.
The Cecil page at the University of Washington
Cecil is a pure object-oriented language intended to support rapid construction of high-quality, extensible software. Cecil combines multi-methods with a simple object model, module-based encapsulation, and optional static type checking.
Dylan pages at Carnegie Mellon, Apple Computer, and Harlequin
Dylan is an object-oriented dynamic language resembling Scheme and CLOS.
An overview of dynamic languages at Apple Computer.
Dynamic languages typically offer run-time type information, automatic storage management, and interactive development environments.
The Eiffel page.
Eiffel is a pure object-oriented language featuring multiple inheritance, polymorphism, static typing and dynamic binding, genericity (constrained and unconstrained), a disciplined exception mechanism, systematic use of assertions to promote programming by contract, and deferred classes for high-level design and analysis.
The Elf Meta-Language page at Carnegie Mellon
Elf is a constraint logic programming language based on the LF Logical Framework. It is intended as a uniform meta-language for specifying, implementing, and proving properties of programming languages and logics.
The Erlang page at Ericsson.
Erlang is a mostly functional symbolic programming language featuring modules, concurrency, distribution, and dynamic reconfiguration.
The Forth page at the University of Paisley
Forth is an interactive programming environment and programming language supporting compile-time and run-time language extensions.
Functional languages FAQ (Frequently Asked Questions)
The Gentle page at GMD.
Gentle is a programming language for compiler writers. It provides a uniform notation for grammar specifications and mappings to abstract syntax, transformation based on pattern matching and structural induction, as well as code generation driven by cost annotations. The Gentle Compiler Construction System translates high-level compiler descriptions into efficient and portable C, Lex, and Yacc code.
The Haskell FAQ, language definition, and tutorial.
Haskell is a polymorphic lazy functional language with overloading.
The Fudget library is a toolkit for concurrent programming of graphical user interfaces, client/servers and more in Haskell. It is implemented in a purely functional way in Haskell, without using state, threads or other extensions for concurrency or imperative programming.
The High Performance Fortran Language Specification
An extension of Fortran that supports data parallel programming.
The Hope page at Imperial College.
Hope is a functional programming language with polymorphic typing, algebraic types, pattern matching and higher-order functions.
The Java White Paper at Sun
Java is an object-oriented, distributed, robust, secure, architecture neutral, multithreaded, and dynamic language.
The lambda Prolog page at UPenn
An extension to Prolog featuring higher-order programming, polymorphic types, modules, abstract datatypes, and direct support for lambda-terms. Based upon the intuitionistic theory of higher-order hereditary Harrop formulas.
LISP is a family of dynamically typed functional languages. Common LISP has a rich set of data types and operations and an object-oriented programming facility (CLOS).
The Lygon page at the University of Melbourne
Lygon is a logic programming language that is based on linear logic. Lygon's features include a clean declarative notion of state and the ability to express problems involving concurrency. In addition, the availability of use once predicates allows simple solutions to problems such as graph manipulation.
The Mercury page at the University of Melbourne
Mercury is a purely declarative logic programming language that is strongly typed and strongly moded and features a module system and determinism declarations.
Modula-3 home page at DEC SRC
Modula-3 is a systems programming language that supports interfaces, objects, generics, lightweight threads of control, the isolation of unsafe code, garbage collection, exceptions and subtyping.
The Napier88 page at the University of St Andrews.
Napier88 is a persistent programming language and environment with strong typing, type completeness, higher order procedures, parametric polymorphism, existential datatypes, infinite union types for system evolution, and support for graphics, distribution and concurrency.
The NESL page at Carnegie Mellon
NESL is a mostly functional data-parallel language loosely based on ML. It has polymorphic types, a limited form of higher-order functions, a built-in performance model, and supports nested parallelism.
The Obliq home page at DEC SRC.
Obliq is a lexically-scoped untyped interpreted language that supports distributed object-oriented computation. Obliq objects have state and are local to a site. Obliq computations can roam over the network, while maintaining network connections.
The Occam Archive at Oxford.
Occam is a parallel computing language based on CSP.
The Oz page at DFKI
Oz is a concurrent constraint programming language designed for applications that require complex symbolic computations, organization into multiple agents, and soft real-time control.
The Pict page at Indiana University.
Pict is a concurrent programming language based on the pi-calculus. Its type system integrates a number of features found in recent work on theoretical foundations for typed object-oriented languages: higher-order polymorphism, simple recursive types, subtyping, and a powerful partial type inference algorithm.
The Pizza page at the University of Karlsruhe
Pizza is a superset of Java that features parametric polymorphism, higher-order functions, and algebraic types.
Prometheus is a high-level programming language designed for AI, mathematics, logic, and list and string processing.
The Python Programming Language page at CWI
An interpreted, interactive, object-oriented language that incorporates modules, exceptions, dynamic typing, very high level dynamic data types, and classes.
The Sather page at Berkeley.
Sather in an object-oriented language with parameterized classes, strong static typing, multiple inheritance, higher-order functions, and exception handling.
The Scheme page at MIT, the Scheme Repository at Indiana, and a short introduction to Scheme.
Scheme is a dialect of LISP that stresses conceptual elegance and simplicity.
The Sisal tutorial at Lawrence Livermore
Sisal is a functional language intended for scientific programs on parallel supercomputers. Most Sisal programs outperform equivalent Fortran programs compiled using automatic vectorizing and parallelizing software.
The Standard ML page at Carnegie Mellon
A functional language with static polymorphic typing and parameterized modules.
[This page and others are served by The FoxNet Web Server, which is written completely in an extension of SML (e.g. even the TCP/IP protocol stack).]
Dialects of ML include Caml and Objective Caml
The Theta page at MIT
Theta is an object-oriented programming language featuring separate type and class hierarchies, multiple super-types, single inheritance, parametric polymorphism, and subtype polymorphism.

Other Language Overviews

Back to the language research page

Additions and corrections are welcome!
Mark Leone (