Comparison of multi-paradigm programming languages

Last updated

Programming languages can be grouped by the number and types of paradigms supported.

Contents

Paradigm summaries

A concise reference for the programming paradigms listed in this article.

Language overview

List of multi-paradigm programming languages
Language
Paradigm count
Concurrent
Constraints
Dataflow
Declarative
Distributed
Functional
Metaprogramming
Generic
Imperative
Logic
Reflection
Object-oriented
Pipelines
Visual
Rule-based
Other
Ada [2] [3] [4] [5] [6] 5Yes [a 1] NoNoNoYesNoNoYesYesNoNoYes [a 2] NoNoNoNo
ALF 2NoNoNoNoNoYesNoNoNoYesNoNoNoNoNoNo
AmigaE
[ citation needed ]
2NoNoNoNoNoNoNoNoYesNoNoYes [a 2] NoNoNoNo
APL 3NoNoNoNoNoYesNoNoYesNoNoNoNoNoNoArray (multi-dimensional)
BETA
[ citation needed ]
3NoNoNoNoNoYesNoNoYesNoNoYes [a 2] NoNoNoNo
C++ 7 (15)Yes [7] [8] [9] Library [10] Library [11] [12] Library [13] [14] Library [15] [16] YesYes [17] Yes [a 3] YesLibrary [18] [19] Library [20] Yes [a 2] Yes [21] NoLibrary [22] Array (multi-dimensional; using STL)
C# 6 (7)YesNoLibrary [a 4] NoNoYes [a 5] NoYesYesNoYesYes [a 2] NoNoNoReactive [a 6]
ChucK
[ citation needed ]
3YesNoNoNoNoNoNoNoYesNoNoYes [a 2] NoNoNoNo
Claire 2NoNoNoNoNoYesNoNoNoNoNoYes [a 2] NoNoNoNo
Clojure 5Yes [23] [24] NoNoYesNoYes [25] Yes [26] NoNoLibrary [27] NoNoYes [28] Editor [29] No Multiple dispatch, [30] Agents [31]
Common Lisp 7 (14)Library [32] Library [33] Library [34] Yes [35] Library [36] YesYesYes [37] YesLibrary [38] YesYes [a 7] [a 2] [39] Library [40] Library [41] Library [42] Multiple dispatch, meta-OOP system, [43] Language is extensible via metaprogramming.
Curl 5NoNoNoNoNoYesNoYes [a 3] YesNoYesYes [a 2] NoNoNoNo
Curry 4YesYesNoNoNoYesNoNoNoYesNoNoNoNoNoNo
D (version 2.0) [44] [45] 7Yes [a 8] NoNoNoNoYesYes [46] [a 3] Yes [a 3] YesNoYesYes [a 2] NoNoNoNo
Delphi 3NoNoNoNoNoNoNoYes [a 3] YesNoNoYes [a 2] NoNoNoNo
Dylan
[ citation needed ]
3NoNoNoNoNoYesNoNoNoNoYesYes [a 2] NoNoNoNo
E 3YesNoNoNoYesNoNoNoNoNoNoYes [a 2] NoNoNoNo
ECMAScript [47] [48] (ActionScript, E4X, JavaScript, JScript)4 (5)Partial [a 9] [a 10] NoNoLibrary [49] [50] NoYesNoNoYesNoYesYes [a 11] Library [51] [52] Editor [53] NoReactive, [a 12] [54] event driven [a 13] [a 14]
Erlang 3YesNoNoYesYesYesNoNoNoNoNoNoYesNoNoNo
Elixir 4YesNoNoNoYesYesYesNoNoNoNoNoYesNoNoNo
Elm 6YesNoYesYesNoYes (pure) [a 15] NoYesNoNoNoNoYesNoNoReactive
F# 7 (8)Yes [a 8] NoLibrary [a 4] YesNoYesNoYesYesNoYesYes [a 2] NoNoNoReactive [a 6]
Fortran 4 (5)YesNoNoNoNoYes [a 15] NoYes [a 16] NoNoNoYes [a 2] NoNoNoArray (multi-dimensional)
Go 4YesNoNoNoNoNoNoNoYesNoYesNoYesNoNoNo
Haskell 8 (15)YesLibrary [55] Library [56] YesLibrary [57] Yes (lazy) (pure) [a 15] Yes [58] YesYesLibrary [59] NoPartial [a 17] YesYesLibrary [60] Literate, reactive, dependent types (partial)
Io 4Yes [a 8] NoNoNoNoYesNoNoYesNoNoYes [a 11] NoNoNoNo
J
[ citation needed ]
3NoNoNoNoNoYesNoNoYesNoNoYes [a 2] NoNoNoNo
Java 6YesLibrary [61] Library [62] NoNoYesNoYesYesNoYesYes [a 2] NoNoNoNo
Julia 9 (17)YesLibrary [63] Library [64] [65] Library [66] YesYes (eager)YesYesYesLibrary [67] YesYes [a 18] YesNoLibrary [68] [69] Multiple dispatch,
Array (multi-dimensional); optionally lazy [70] and reactive (with libraries)
Kotlin 8YesNoNoNoNoYesYesYesYesNoYesYesYesNoNoNo
LabVIEW 4YesNoYesNoNoNoNoNoNoNoNoYesNoYesNoNo
Lava 2NoNoNoNoNoNoNoNoNoNoNoYes [a 2] NoYesNoNo
LispWorks (version 6.0 with support for symmetric multi-processing, rules, logic (Prolog), CORBA)9YesNoNoNoYesYesYesNoYesYesYesYes [a 2] NoNoYesNo
Lua
[ citation needed ]
3NoNoNoNoNoYesNoNoYesNoNoYes [a 11] NoNoNoNo
MATLAB 6 (10)Toolbox [71] Toolbox [72] Yes [73] NoToolbox [74] NoYes [75] Yes [76] NoNoYes [77] Yes [78] NoYes [79] NoArray (multi-dimensional)
Nemerle 7YesNoNoNoNoYesYesYesYesNoYesYes [a 2] NoNoNoNo
Object Pascal 4YesNoNoNoNoYesNoNoYesNoNoYes [a 2] NoNoNoNo
OCaml 4NoNoNoNoNoYesNoYesYesNoNoYes [a 2] NoNoNoNo
Oz 11YesYesYesYesYesYesNoNoYesYesNoYes [a 2] YesNoYesNo
Perl
[ citation needed ]
8 (9)Yes [80] Library [81] Yes [82] NoNoYesYesNoYesNoYes [a 2] Yes [a 2] YesNoNoNo
PHP [83] [84] [85] 4NoNoNoNoNoYesNoNoYesNoYesYes [a 2] NoNoNoNo
Poplog 3NoNoNoNoNoYesNoNoYesYesNoNoNoNoNoNo
Prograph 3NoNoYesNoNoNoNoNoNoNoNoYes [a 2] NoYesNoNo
Python 5 (10)Library [86] [87] Library [88] NoNoLibrary [89] YesYes [90] [91] Yes [92] [93] YesLibrary [94] YesYes [a 2] NoEditor [95] No Structured
R 4 (6)Library [96] NoNoNoLibrary [97] YesNoNoYesNoYesYesYes [98] NoNoArray (multi-dimensional)
Racket 10Yes [99] Yes [100] Yes [101] NoYes [102] YesYesNoYesYesYesYesNoNoNoLazy [103]
Raku 10Yes [104] Yes [105] Yes [106] NoLibrary [107] YesYes [108] Yes [109] YesNoYes [110] Yes [111] YesNoNoMultiple dispatch, lazy lists, reactive.
ROOP 3NoNoNoNoNoNoNoNoYesYesNoNoNoNoYesNo
Ruby 5NoNoNoNoNoYesYesNoYesNoYesYes [a 2] NoNoNoNo
Rust (version 1.0.0-alpha)6Yes [a 8] NoNoNoNoYesYes [112] [113] Yes [114] YesNoNoYesNoNoNoLinear, affline, and ownership types
Sather
[ citation needed ]
2NoNoNoNoNoYesNoNoNoNoNoYes [a 2] NoNoNoNo
Scala [115] [116] 9Yes [a 8] NoYes [a 19] YesNoYesYesYesYesNoYesYes [a 2] NoNoNoNo
Simula
[ citation needed ]
2NoNoNoNoNoNoNoNoYesNoNoYes [a 2] NoNoNoNo
SISAL 3YesNoYesNoNoYesNoNoNoNoNoNoNoNoNoNo
Spreadsheets 2NoNoNoNoNoYesNoNoNoNoNoNoNoYesNoNo
Swift 7YesNoNoNoNoYesYesYesYesNoYesYes [a 2] NoNoNoBlock-structured
Tcl with Snit extension
[ citation needed ]
3NoNoNoNoNoYes [117] NoNoYesNoNoYes [a 11] [118] NoNoNoNo
Visual Basic .NET 6 (7)YesNoLibrary [a 4] NoNoYesNoYesYesNoYesYes [a 2] NoNoNoReactive [a 6]
Windows PowerShell 6NoNoNoNoNoYesNoYesYesNoYesYes [a 2] YesNoNoNo
Wolfram Language & Mathematica 13 [119] (14)YesYesYesYesYesYesYesYesYesYesYesYesYes [120] NoYesKnowledge Based

See also

Notes

  1. rendezvous and monitor-like based
  2. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 class-based
  3. 1 2 3 4 5 template metaprogramming
  4. 1 2 3 using TPL Dataflow
  5. only lambda support (lazy functional programming)
  6. 1 2 3 using Reactive Extensions (Rx)
  7. multiple dispatch, method combinations
  8. 1 2 3 4 5 actor programming
  9. promises, native extensions
  10. using Node.js' cluster module or child_process.fork method, web workers in the browser, etc.
  11. 1 2 3 4 Prototype-based
  12. using Reactive Extensions (RxJS)
  13. in Node.js via their events module
  14. in browsers via their native EventTarget API
  15. 1 2 3 purely functional
  16. parameterized classes
  17. immutable
  18. multiple dispatch, not traditional single
  19. Akka Archived 2013-01-19 at the Wayback Machine

Citations

  1. Bragg, S.D.; Driskill, C.G. (20–22 September 1994). "Diagrammatic-graphical programming languages and DoD-STD-2167A". Proceedings of AUTOTESTCON '94 (IEEEXplore). Institute of Electrical and Electronics Engineers (IEEE). pp. 211–220. doi:10.1109/AUTEST.1994.381508. ISBN   978-0-7803-1910-3. S2CID   62509261.
  2. Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3, Section 9: Tasks and Synchronization
  3. Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3 Annex E: Distributed Systems
  4. Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3, Section 12: Generic Units
  5. Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3, Section 6: Subprograms
  6. Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3, 3.9 Tagged Types and Type Extensions
  7. Thread support
  8. Atomics support
  9. Memory model
  10. Gecode
  11. SystemC
  12. Boost.Iostreams
  13. Boolinq
  14. "AraRat" (PDF). Archived from the original (PDF) on 2019-08-19. Retrieved 2019-09-15.
  15. OpenMPI
  16. Boost.MPI
  17. Boost.MPL
  18. LC++
  19. Castor Archived 2013-01-25 at the Wayback Machine
  20. Reflect Library
  21. N3534
  22. Boost.Spirit
  23. Clojure - Concurrent Programming
  24. Clojure - core.async
  25. Clojure - Functional Programming
  26. Clojure - Macros
  27. Clojure - core.logic
  28. Clojure - Threading Macros Guide
  29. "Light Table". 2019-04-08.
  30. Multimethods and Hierarchies
  31. Agents and Asynchronous Actions
  32. many concurrency paradigms implemented as language extensions
  33. constraint programming inside CL through extensions
  34. dataflow extension
  35. by creating DSLs using the built-in metaprogramming; also see note on functional, constraint and logic paradigms, which are part of declarative
  36. MPI, etc via language extensions
  37. template metaprogramming using macros (see C++)
  38. Prolog implemented as a language extension
  39. Common Lisp Object System see Wikipedia article on CLOS, the Common Lisp Object System.
  40. implemented by the user via a short macro, example of implementation
  41. - Visual programming tool based on Common Lisp
  42. rule-based programming extension
  43. Archived 2018-04-26 at the Wayback Machine through the Meta Object Protocol
  44. D Language Feature Table
  45. Phobos std.algorithm
  46. D language String Mixins
  47. The Little JavaScripter demonstrates fundamental commonality with Scheme, a functional language.
  48. Object-Oriented Programming in JavaScript Archived 2019-02-10 at the Wayback Machine gives an overview of object-oriented programming techniques in JavaScript.
  49. "React – A JavaScript library for building user interfaces". 2019-04-08.
  50. "TNG-Hooks". GitHub . 2019-04-08.
  51. "Lodash documentation". 2019-04-08.
  52. "mori". 2019-04-08.
  53. "Light Table". 2019-04-08.
  54. "TNG-Hooks". GitHub . 2019-04-08.
  55. "Prolog embedding". Haskell.org.
  56. "Functional Reactive Programming". HaskellWiki.
  57. Cloud Haskell
  58. "Template Haskell". HaskellWiki.
  59. "Logict: A backtracking logic-programming monad". Haskell.org.
  60. Kollmansberger, Steve; Erwig, Martin (30 May 2006). "Haskell Rules: Embedding Rule Systems in Haskell" (PDF). Oregon State University .
  61. https://jcp.org/en/jsr/detail?id=331 JSR 331: Constraint Programming API
  62. https://github.com/GoogleCloudPlatform/DataflowJavaSDK Google Cloud Platform Dataflow SDK
  63. "JuliaOpt/JuMP.jl". GitHub. JuliaOpt. 11 February 2020. Retrieved 12 February 2020.
  64. "GitHub - MikeInnes/DataFlow.jl". GitHub . 2019-01-15.
  65. "GitHub - JuliaGizmos/Reactive.jl: Reactive programming primitives for Julia". GitHub . 2018-12-28.
  66. https://github.com/davidanthoff/Query.jl Query almost anything in julia
  67. https://github.com/lilinjn/LilKanren.jl A collection of Kanren implementations in Julia
  68. "GitHub - abeschneider/PEGParser.jl: PEG Parser for Julia". GitHub . 2018-12-03.
  69. "GitHub - gitfoxi/Parsimonious.jl: A PEG parser generator for Julia". GitHub . 2017-08-03.
  70. Lazy https://github.com/MikeInnes/Lazy.jl
  71. "Execute loop iterations in parallel". mathworks.com. Retrieved 21 October 2016.
  72. "Write Constraints". mathworks.com. Retrieved 21 October 2016.
  73. "Getting Started with SimEvents". mathworks.com. Retrieved 21 October 2016.
  74. "Execute loop iterations in parallel". mathworks.com. Retrieved 21 October 2016.
  75. "Execute MATLAB expression in text - MATLAB eval". mathworks.com. Retrieved 21 October 2016.
  76. "Determine class of object". mathworks.com. Retrieved 21 October 2016.
  77. "Class Metadata". mathworks.com. Retrieved 21 October 2016.
  78. "Object-Oriented Programming". mathworks.com. Retrieved 21 October 2016.
  79. "Simulink". mathworks.com. Retrieved 21 October 2016.
  80. interpreter based threads
  81. Moose
  82. Higher Order Perl
  83. PHP Manual, Chapter 17. Functions
  84. PHP Manual, Chapter 19. Classes and Objects (PHP 5)
  85. PHP Manual, Anonymous functions
  86. "Parallel Processing and Multiprocessing in Python". Python Wiki. Retrieved 21 October 2016.
  87. "threading — Higher-level threading interface". docs.python.org. Retrieved 21 October 2016.
  88. "python-constraint". pypi.python.org. Retrieved 21 October 2016.
  89. "DistributedProgramming". Python Wiki. Retrieved 21 October 2016.
  90. "Chapter 9. Metaprogramming". chimera.labs.oreilly.com. Archived from the original on 23 October 2016. Retrieved 22 October 2016.
  91. "Metaprogramming". readthedocs.io. Retrieved 22 October 2016.
  92. "PEP 443 – Single-dispatch generic functions". python.org. Retrieved 22 October 2016.
  93. "PEP 484 – Type Hints". python.org. Retrieved 22 October 2016.
  94. "PyDatalog" . Retrieved 22 October 2016.
  95. "Light Table". 2019-04-08.
  96. "Futureverse".
  97. "future batchtools".
  98. "Magrittr: A Forward Pipe Operator for R". cran.r-project.org\access-date=13 July 2017. 17 November 2020.
  99. Racket Guide: Concurrency and Synchronization
  100. The Rosette Guide
  101. FrTime: A Language for Reactive Programs
  102. Racket Guide: Distributed Places
  103. Lazy Racket
  104. Channels and other mechanisms
  105. "Class Signature".
  106. Feed operator
  107. https://github.com/perl6/doc/issues/1744#issuecomment-360565196 Cro module
  108. "Meta-programming: What, why and how". 2011-12-14.
  109. https://perl6advent.wordpress.com/2009/12/18/day-18-roles/ Parametrized Roles
  110. "Meta-object protocol (MOP)".
  111. https://docs.perl6.org/language/classtut Classes and Roles
  112. "The Rust macros guide". Rust. Retrieved 19 January 2015.
  113. "The Rust compiler plugins guide". Rust. Retrieved 19 January 2015.
  114. The Rust Reference §6.1.3.1
  115. An Overview of the Scala Programming Language
  116. Scala Language Specification
  117. "Tcl Programming/Introduction". en.wikibooks.org. Retrieved 22 October 2016.
  118. "TCLLIB - Tcl Standard Library: snitfaq". sourceforge.net. Retrieved 22 October 2016.
  119. Notes for Programming Language Experts, Wolfram Language Documentation.
  120. External Programs, Wolfram Language Documentation.

Related Research Articles

<span class="mw-page-title-main">Lisp (programming language)</span> Programming language family

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.

<span class="mw-page-title-main">Clojure</span> Dialect of the Lisp programming language on the Java platform

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.

<span class="mw-page-title-main">Julia (programming language)</span> Dynamic programming language

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.

<span class="mw-page-title-main">Nim (programming language)</span> Programming language

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.

References