This article possibly contains original research .(August 2009) |
Programming languages can be grouped by the number and types of paradigms supported.
A concise reference for the programming paradigms listed in this article.
Language | Other | ||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Ada [2] [3] [4] [5] [6] | 5 | Yes [a 1] | No | No | No | Yes | No | No | Yes | Yes | No | No | Yes [a 2] | No | No | No | No |
ALF | 2 | No | No | No | No | No | Yes | No | No | No | Yes | No | No | No | No | No | No |
AmigaE [ citation needed ] | 2 | No | No | No | No | No | No | No | No | Yes | No | No | Yes [a 2] | No | No | No | No |
APL | 3 | No | No | No | No | No | Yes | No | No | Yes | No | No | No | No | No | No | Array (multi-dimensional) |
BETA [ citation needed ] | 3 | No | No | No | No | No | Yes | No | No | Yes | No | No | Yes [a 2] | No | No | No | No |
C++ | 7 (15) | Yes [7] [8] [9] | Library [10] | Library [11] [12] | Library [13] [14] | Library [15] [16] | Yes | Yes [17] | Yes [a 3] | Yes | Library [18] [19] | Library [20] | Yes [a 2] | Yes [21] | No | Library [22] | Array (multi-dimensional; using STL) |
C# | 6 (7) | Yes | No | Library [a 4] | No | No | Yes [a 5] | No | Yes | Yes | No | Yes | Yes [a 2] | No | No | No | Reactive [a 6] |
ChucK [ citation needed ] | 3 | Yes | No | No | No | No | No | No | No | Yes | No | No | Yes [a 2] | No | No | No | No |
Claire | 2 | No | No | No | No | No | Yes | No | No | No | No | No | Yes [a 2] | No | No | No | No |
Clojure | 5 | Yes [23] [24] | No | No | Yes | No | Yes [25] | Yes [26] | No | No | Library [27] | No | No | Yes [28] | Editor [29] | No | Multiple dispatch, [30] Agents [31] |
Common Lisp | 7 (14) | Library [32] | Library [33] | Library [34] | Yes [35] | Library [36] | Yes | Yes | Yes [37] | Yes | Library [38] | Yes | Yes [a 7] [a 2] [39] | Library [40] | Library [41] | Library [42] | Multiple dispatch, meta-OOP system, [43] Language is extensible via metaprogramming. |
Curl | 5 | No | No | No | No | No | Yes | No | Yes [a 3] | Yes | No | Yes | Yes [a 2] | No | No | No | No |
Curry | 4 | Yes | Yes | No | No | No | Yes | No | No | No | Yes | No | No | No | No | No | No |
D (version 2.0) [44] [45] | 7 | Yes [a 8] | No | No | No | No | Yes | Yes [46] [a 3] | Yes [a 3] | Yes | No | Yes | Yes [a 2] | No | No | No | No |
Delphi | 3 | No | No | No | No | No | No | No | Yes [a 3] | Yes | No | No | Yes [a 2] | No | No | No | No |
Dylan [ citation needed ] | 3 | No | No | No | No | No | Yes | No | No | No | No | Yes | Yes [a 2] | No | No | No | No |
E | 3 | Yes | No | No | No | Yes | No | No | No | No | No | No | Yes [a 2] | No | No | No | No |
ECMAScript [47] [48] (ActionScript, E4X, JavaScript, JScript) | 4 (5) | Partial [a 9] [a 10] | No | No | Library [49] [50] | No | Yes | No | No | Yes | No | Yes | Yes [a 11] | Library [51] [52] | Editor [53] | No | Reactive, [a 12] [54] event driven [a 13] [a 14] |
Erlang | 3 | Yes | No | No | Yes | Yes | Yes | No | No | No | No | No | No | Yes | No | No | No |
Elixir | 4 | Yes | No | No | No | Yes | Yes | Yes | No | No | No | No | No | Yes | No | No | No |
Elm | 6 | Yes | No | Yes | Yes | No | Yes (pure) [a 15] | No | Yes | No | No | No | No | Yes | No | No | Reactive |
F# | 7 (8) | Yes [a 8] | No | Library [a 4] | Yes | No | Yes | No | Yes | Yes | No | Yes | Yes [a 2] | No | No | No | Reactive [a 6] |
Fortran | 4 (5) | Yes | No | No | No | No | Yes [a 15] | No | Yes [a 16] | No | No | No | Yes [a 2] | No | No | No | Array (multi-dimensional) |
Go | 4 | Yes | No | No | No | No | No | No | No | Yes | No | Yes | No | Yes | No | No | No |
Haskell | 8 (15) | Yes | Library [55] | Library [56] | Yes | Library [57] | Yes (lazy) (pure) [a 15] | Yes [58] | Yes | Yes | Library [59] | No | Partial [a 17] | Yes | Yes | Library [60] | Literate, reactive, dependent types (partial) |
Io | 4 | Yes [a 8] | No | No | No | No | Yes | No | No | Yes | No | No | Yes [a 11] | No | No | No | No |
J [ citation needed ] | 3 | No | No | No | No | No | Yes | No | No | Yes | No | No | Yes [a 2] | No | No | No | No |
Java | 6 | Yes | Library [61] | Library [62] | No | No | Yes | No | Yes | Yes | No | Yes | Yes [a 2] | No | No | No | No |
Julia | 9 (17) | Yes | Library [63] | Library [64] [65] | Library [66] | Yes | Yes (eager) | Yes | Yes | Yes | Library [67] | Yes | Yes [a 18] | Yes | No | Library [68] [69] | Multiple dispatch, Array (multi-dimensional); optionally lazy [70] and reactive (with libraries) |
Kotlin | 8 | Yes | No | No | No | No | Yes | Yes | Yes | Yes | No | Yes | Yes | Yes | No | No | No |
LabVIEW | 4 | Yes | No | Yes | No | No | No | No | No | No | No | No | Yes | No | Yes | No | No |
Lava | 2 | No | No | No | No | No | No | No | No | No | No | No | Yes [a 2] | No | Yes | No | No |
LispWorks (version 6.0 with support for symmetric multi-processing, rules, logic (Prolog), CORBA) | 9 | Yes | No | No | No | Yes | Yes | Yes | No | Yes | Yes | Yes | Yes [a 2] | No | No | Yes | No |
Lua [ citation needed ] | 3 | No | No | No | No | No | Yes | No | No | Yes | No | No | Yes [a 11] | No | No | No | No |
MATLAB | 6 (10) | Toolbox [71] | Toolbox [72] | Yes [73] | No | Toolbox [74] | No | Yes [75] | Yes [76] | No | No | Yes [77] | Yes [78] | No | Yes [79] | No | Array (multi-dimensional) |
Nemerle | 7 | Yes | No | No | No | No | Yes | Yes | Yes | Yes | No | Yes | Yes [a 2] | No | No | No | No |
Object Pascal | 4 | Yes | No | No | No | No | Yes | No | No | Yes | No | No | Yes [a 2] | No | No | No | No |
OCaml | 4 | No | No | No | No | No | Yes | No | Yes | Yes | No | No | Yes [a 2] | No | No | No | No |
Oz | 11 | Yes | Yes | Yes | Yes | Yes | Yes | No | No | Yes | Yes | No | Yes [a 2] | Yes | No | Yes | No |
Perl [ citation needed ] | 8 (9) | Yes [80] | Library [81] | Yes [82] | No | No | Yes | Yes | No | Yes | No | Yes [a 2] | Yes [a 2] | Yes | No | No | No |
PHP [83] [84] [85] | 4 | No | No | No | No | No | Yes | No | No | Yes | No | Yes | Yes [a 2] | No | No | No | No |
Poplog | 3 | No | No | No | No | No | Yes | No | No | Yes | Yes | No | No | No | No | No | No |
Prograph | 3 | No | No | Yes | No | No | No | No | No | No | No | No | Yes [a 2] | No | Yes | No | No |
Python | 5 (10) | Library [86] [87] | Library [88] | No | No | Library [89] | Yes | Yes [90] [91] | Yes [92] [93] | Yes | Library [94] | Yes | Yes [a 2] | No | Editor [95] | No | Structured |
R | 4 (6) | Library [96] | No | No | No | Library [97] | Yes | No | No | Yes | No | Yes | Yes | Yes [98] | No | No | Array (multi-dimensional) |
Racket | 10 | Yes [99] | Yes [100] | Yes [101] | No | Yes [102] | Yes | Yes | No | Yes | Yes | Yes | Yes | No | No | No | Lazy [103] |
Raku | 10 | Yes [104] | Yes [105] | Yes [106] | No | Library [107] | Yes | Yes [108] | Yes [109] | Yes | No | Yes [110] | Yes [111] | Yes | No | No | Multiple dispatch, lazy lists, reactive. |
ROOP | 3 | No | No | No | No | No | No | No | No | Yes | Yes | No | No | No | No | Yes | No |
Ruby | 5 | No | No | No | No | No | Yes | Yes | No | Yes | No | Yes | Yes [a 2] | No | No | No | No |
Rust (version 1.0.0-alpha) | 6 | Yes [a 8] | No | No | No | No | Yes | Yes [112] [113] | Yes [114] | Yes | No | No | Yes | No | No | No | Linear, affline, and ownership types |
Sather [ citation needed ] | 2 | No | No | No | No | No | Yes | No | No | No | No | No | Yes [a 2] | No | No | No | No |
Scala [115] [116] | 9 | Yes [a 8] | No | Yes [a 19] | Yes | No | Yes | Yes | Yes | Yes | No | Yes | Yes [a 2] | No | No | No | No |
Simula [ citation needed ] | 2 | No | No | No | No | No | No | No | No | Yes | No | No | Yes [a 2] | No | No | No | No |
SISAL | 3 | Yes | No | Yes | No | No | Yes | No | No | No | No | No | No | No | No | No | No |
Spreadsheets | 2 | No | No | No | No | No | Yes | No | No | No | No | No | No | No | Yes | No | No |
Swift | 7 | Yes | No | No | No | No | Yes | Yes | Yes | Yes | No | Yes | Yes [a 2] | No | No | No | Block-structured |
Tcl with Snit extension [ citation needed ] | 3 | No | No | No | No | No | Yes [117] | No | No | Yes | No | No | Yes [a 11] [118] | No | No | No | No |
Visual Basic .NET | 6 (7) | Yes | No | Library [a 4] | No | No | Yes | No | Yes | Yes | No | Yes | Yes [a 2] | No | No | No | Reactive [a 6] |
Windows PowerShell | 6 | No | No | No | No | No | Yes | No | Yes | Yes | No | Yes | Yes [a 2] | Yes | No | No | No |
Wolfram Language & Mathematica | 13 [119] (14) | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes [120] | No | Yes | Knowledge Based |
Lisp is a family of programming languages with a long history and a distinctive, fully parenthesized prefix notation. Originally specified in the late 1950s, it is the second-oldest high-level programming language still in common use, after Fortran. Lisp has changed since its early days, and many dialects have existed over its history. Today, the best-known general-purpose Lisp dialects are Common Lisp, Scheme, Racket, and Clojure.
In computing, serialization is the process of translating a data structure or object state into a format that can be stored or transmitted and reconstructed later. When the resulting series of bits is reread according to the serialization format, it can be used to create a semantically identical clone of the original object. For many complex objects, such as those that make extensive use of references, this process is not straightforward. Serialization of object-oriented objects does not include any of their associated methods with which they were previously linked.
Metaprogramming is a programming technique in which computer programs have the ability to treat other programs as their data. It means that a program can be designed to read, generate, analyse or transform other programs, and even modify itself while running. In some cases, this allows programmers to minimize the number of lines of code to express a solution, in turn reducing development time. It also allows programs a greater flexibility to efficiently handle new situations without recompilation.
The printf family of functions in the C programming language are a set of functions that take a format string as input among a variable sized list of other values and produce as output a string that corresponds to the format specifier and given input values. The string is written in a simple template language: characters are usually copied literally into the function's output, but format specifiers, which start with a %
character, indicate the location and method to translate a piece of data to characters. The design has been copied to expose similar functionality in other programming languages.
In computer science, future, promise, delay, and deferred refer to constructs used for synchronizing program execution in some concurrent programming languages. They describe an object that acts as a proxy for a result that is initially unknown, usually because the computation of its value is not yet complete.
Concurrent computing is a form of computing in which several computations are executed concurrently—during overlapping time periods—instead of sequentially—with one completing before the next starts.
Programming languages are used for controlling the behavior of a machine. Like natural languages, programming languages follow rules for syntax and semantics.
The following outline is provided as an overview of and topical guide to computer programming:
The following tables provide a comparison of numerical analysis software.
QuickCheck is a software library, specifically a combinator library, originally written in the programming language Haskell, designed to assist in software testing by generating test cases for test suites – an approach known as property testing.
Clojure is a dynamic and functional dialect of the Lisp programming language on the Java platform.
Tensor software is a class of mathematical software designed for manipulation and calculation with tensors.
Haskell is a general-purpose, statically-typed, purely functional programming language with type inference and lazy evaluation. Designed for teaching, research, and industrial applications, Haskell has pioneered a number of programming language features such as type classes, which enable type-safe operator overloading, and monadic input/output (IO). It is named after logician Haskell Curry. Haskell's main implementation is the Glasgow Haskell Compiler (GHC).
Qore is an interpreted, high-level, general-purpose, garbage collected dynamic programming language, featuring support for code embedding and sandboxing with optional strong typing and a focus on fundamental support for multithreading and SMP scalability.
Julia is a high-level, general-purpose dynamic programming language, most commonly used for numerical analysis and computational science. Distinctive aspects of Julia's design include a type system with parametric polymorphism and the use of multiple dispatch as a core programming paradigm, efficient garbage collection, and a just-in-time (JIT) compiler.
The table shows a comparison of functional programming languages which compares various features and designs of different functional programming languages.
Nim is a general-purpose, multi-paradigm, statically typed, compiled high-level systems programming language, designed and developed by a team around Andreas Rumpf. Nim is designed to be "efficient, expressive, and elegant", supporting metaprogramming, functional, message passing, procedural, and object-oriented programming styles by providing several features such as compile time code generation, algebraic data types, a foreign function interface (FFI) with C, C++, Objective-C, and JavaScript, and supporting compiling to those same languages as intermediate representations.