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.
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.
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.
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.
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.
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.
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.
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.
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
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).
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.
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 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.
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.
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.
Oz is a concurrent constraint programming language designed for
applications that require complex symbolic computations, organization
into multiple agents, and soft real-time control.
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.
An interpreted, interactive, object-oriented language that incorporates modules, exceptions, dynamic typing, very high level dynamic data types, and classes.
Sather in an object-oriented language with parameterized classes,
strong static typing, multiple inheritance, higher-order functions,
and exception handling.
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.
Theta is an object-oriented programming language featuring
separate type and class hierarchies, multiple super-types, single
inheritance, parametric polymorphism, and subtype polymorphism.