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

Paradigm summaries

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

  • Concurrent programming – have language constructs for concurrency, these may involve multi-threading, support for distributed computing, message passing, shared resources (including shared memory), or futures
    • Actor programming – concurrent computation with actors that make local decisions in response to the environment (capable of selfish or competitive behaviour)
  • Constraint programming – relations between variables are expressed as constraints (or constraint networks), directing allowable solutions (uses constraint satisfaction or simplex algorithm)
  • Dataflow programming – forced recalculation of formulas when data values change (e.g. spreadsheets)
  • Declarative programming – describes what computation should perform, without specifying detailed state changes c.f. imperative programming (functional and logic programming are major subgroups of declarative programming)
  • Distributed programming – have support for multiple autonomous computers that communicate via computer networks
  • Functional programming – uses evaluation of mathematical functions and avoids state and mutable data
  • Generic programming – uses algorithms written in terms of to-be-specified-later types that are then instantiated as needed for specific types provided as parameters
  • Imperative programming – explicit statements that change a program state
  • Logic programming – uses explicit mathematical logic for programming
  • Metaprogramming – writing programs that write or manipulate other programs (or themselves) as their data, or that do part of the work at compile time that would otherwise be done at runtime
    • Template metaprogramming – metaprogramming methods in which a compiler uses templates to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled
    • Reflective programming – metaprogramming methods in which a program modifies or extends itself
  • Object-oriented programming – uses data structures consisting of data fields and methods together with their interactions (objects) to design programs
    • Class-based – object-oriented programming in which inheritance is achieved by defining classes of objects, versus the objects themselves
    • Prototype-based – object-oriented programming that avoids classes and implements inheritance via cloning of instances
  • Pipeline programming – a simple syntax change to add syntax to nest function calls to language originally designed with none
  • Rule-based programming – a network of rules of thumb that comprise a knowledge base and can be used for expert systems and problem deduction & resolution
  • Visual programming – manipulating program elements graphically rather than by specifying them textually (e.g. Simulink); also termed diagrammatic programming[1]

Language overview

List of multi-paradigm programming languages
Language Number of paradigms Concurrent Constraints Data­flow Declarative Distributed Functional Meta­programming Generic Imperative Logic Reflection Object­oriented Pipe­lines Visual Rule-­based Other paradigms
Ada[2][3][4][5][6]5 Yes[a 1]NoNoNoYesNoNoYesYesNoNoYes[a 2]NoNoNoNo
ALF2 NoNoNoNoNoYesNoNoNoYesNoNoNoNoNoNo
AmigaE2 NoNoNoNoNoNoNoNoYesNoNoYes[a 2]NoNoNoNo
APL3 NoNoNoNoNoYesNoNoYesNoNoNoNoNoNoArray (multi-dimensional)
BETA3 NoNoNoNoNoYesNoNoYesNoNoYes[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]
ChucK3 YesNoNoNoNoNoNoNoYesNoNoYes[a 2]NoNoNoNo
Claire2 NoNoNoNoNoYesNoNoNoNoNoYes[a 2]NoNoNoNo
Clojure5 Yes[23][24]NoNoYesNoYes[25]Yes[26]NoNoLibrary[27]NoNoYes[28]Editor[29]NoMultiple dispatch,[30] Agents[31]
Common Lisp7 (14) Library[32]Library[33]Library[34]Yes[35]Library[36]YesYesYes[37]YesLibrary[38]YesYes (multiple dispatch, method combinations)[39][a 2]Library[40]Library[41]Library[42]Multiple dispatch, meta-OOP system,[43] Language is extensible via metaprogramming.
Curl5 NoNoNoNoNoYesNoYes[a 3]YesNoYesYes[a 2]NoNoNoNo
Curry4 YesYesNoNoNoYesNoNoNoYesNoNoNoNoNoNo
D (version 2.0)[44][45]7 Yes[a 7]NoNoNoNoYesYes[46][a 3]Yes[a 3]YesNoYesYes[a 2]NoNoNoNo
Delphi3 NoNoNoNoNoNoNoYes[a 3]YesNoNoYes[a 2]NoNoNoNo
Dylan3 NoNoNoNoNoYesNoNoNoNoYesYes[a 2]NoNoNoNo
E3 YesNoNoNoYesNoNoNoNoNoNoYes[a 2]NoNoNoNo
ECMAScript[47][48] (ActionScript, E4X, JavaScript, JScript)4 (5) partial (promises, native extensions)[a 8]NoNoLibrary[49][50]NoYesNoNoYesNoYesYes[a 9]Library[51][52]Editor[53]Noreactive,[a 10][54] event driven[a 11][a 12]
Erlang3 YesNoNoYesYesYesNoNoNoNoNoNoYesNoNoNo
Elixir4 YesNoNoNoYesYesYesNoNoNoNoNoYesNoNoNo
Elm6 YesNoYesYesNoYes (pure)[a 13]NoYesNoNoNoNoYesNoNoreactive
F#7 (8) Yes[a 7]NoLibrary[a 4]YesNoYesNoYesYesNoYesYes[a 2]NoNoNoreactive[a 6]
Fortran4 (5) YesNoNoNoNoYes[a 13]NoYes[a 14]NoNoNoYes[a 2]NoNoNoArray (multi-dimensional)
Go4 YesNoNoNoNoNoNoNoYesNoYesNoYesNoNoNo
Haskell8 (15) YesLibrary[55]Library[56]YesLibrary[57]Yes (lazy) (pure)[a 13]Yes[58]YesYesLibrary[59]NoImmutableYesYesLibrary[60]literate, reactive, dependent types (partial)
Io4 Yes[a 7]NoNoNoNoYesNoNoYesNoNoYes[a 9]NoNoNoNo
J3 NoNoNoNoNoYesNoNoYesNoNoYes[a 2]NoNoNoNo
Java6 YesLibrary[61]Library[62]NoNoYesNoYesYesNoYesYes[a 2]NoNoNoNo
Julia9 (17) YesLibrary[63]Library[64][65]Library[66]YesYes (eager)YesYesYesLibrary[67]YesYes (multiple dispatch, not traditional single)YesNoLibrary[68][69]Multiple dispatch,
Array (multi-dimensional); optionally lazy[70] and reactive (with libraries)
Kotlin8 YesNoNoNoNoYesYesYesYesNoYesYesYesNoNoNo
LabVIEW4 YesNoYesNoNoNoNoNoNoNoNoYesNoYesNoNo
Lava2 NoNoNoNoNoNoNoNoNoNoNoYes[a 2]NoYesNoNo
LispWorks (version 6.0 with support for symmetric multi-processing, rules, logic (Prolog), CORBA)9 YesNoNoNoYesYesYesNoYesYesYesYes[a 2]NoNoYesNo
Lua3 NoNoNoNoNoYesNoNoYesNoNoYes[a 9]NoNoNoNo
MATLAB6 (10) Toolbox[71]Toolbox[72]Yes[73]NoToolbox[74]NoYes[75]Yes[76]NoNoYes[77]Yes[78]NoYes[79]NoArray (multi-dimensional)
Nemerle7 YesNoNoNoNoYesYesYesYesNoYesYes[a 2]NoNoNoNo
Object Pascal4 YesNoNoNoNoYesNoNoYesNoNoYes[a 2]NoNoNoNo
OCaml4 NoNoNoNoNoYesNoYesYesNoNoYes[a 2]NoNoNoNo
Oz11 YesYesYesYesYesYesNoNoYesYesNoYes[a 2]YesNoYesNo
Perl8 (9) Yes[80]Library[81]Yes[82]NoNoYesYesNoYesNoYes[a 2]Yes[a 2]YesNoNoNo
PHP[83][84][85]4 NoNoNoNoNoYesNoNoYesNoYesYes[a 2]NoNoNoNo
Poplog3 NoNoNoNoNoYesNoNoYesYesNoNoNoNoNoNo
Prograph3 NoNoYesNoNoNoNoNoNoNoNoYes[a 2]NoYesNoNo
Python5 (10) Library[86][87] Library[88] No No Library[89] Yes Yes[90][91] Yes[92][93]YesLibrary[94]YesYes[a 2] NoEditor[95]Nostructured
R4 (6) Library[96]NoNoNoLibrary[97]YesNoNoYesNoYesYesYes[98]NoNoArray (multi-dimensional)
Racket10 Yes[99]Yes[100]Yes[101]NoYes[102]YesYesNoYesYesYesYesNoNoNoLazy[103]
Raku10 Yes[104]Yes[105]Yes[106]NoLibrary[107]YesYes[108]Yes[109]YesNoYes[110]Yes[111]YesNoNoMultiple dispatch, lazy lists, reactive.
ROOP3 NoNoNoNoNoNoNoNoYesYesNoNoNoNoYesNo
Ruby5 NoNoNoNoNoYesYesNoYesNoYesYes[a 2]NoNoNoNo
Rust (version 1.0.0-alpha)6 Yes[a 7]NoNoNoNoYesYes[112][113]Yes[114]YesNoNoYesNoNoNolinear, affline, and ownership types
Sather2 NoNoNoNoNoYesNoNoNoNoNoYes[a 2]NoNoNoNo
Scala[115][116]9 Yes[a 7]NoYes[a 15]YesNoYesYesYesYesNoYesYes[a 2]NoNoNoNo
Simula2 NoNoNoNoNoNoNoNoYesNoNoYes[a 2]NoNoNoNo
SISAL3 YesNoYesNoNoYesNoNoNoNoNoNoNoNoNoNo
Spreadsheets2 NoNoNoNoNoYesNoNoNoNoNoNoNoYesNoNo
Swift7 YesNoNoNoNoYesYesYesYesNoYesYes[a 2]NoNoNoblock-structured
Tcl with Snit extension 3 NoNoNoNoNoYes[117]NoNoYesNoNoYes[a 9][118]NoNoNoNo
Visual Basic .NET6 (7) YesNoLibrary[a 4]NoNoYesNoYesYesNoYesYes[a 2]NoNoNoreactive[a 6]
Windows PowerShell6 NoNoNoNoNoYesNoYesYesNoYesYes[a 2]YesNoNoNo
Wolfram Language & Mathematica13[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. 1 2 3 4 5 actor programming
  8. ↑ using Node.js' cluster module or child_process.fork method, web workers in the browser, etc.
  9. 1 2 3 4 Prototype-based
  10. ↑ using Reactive Extensions (RxJS)
  11. ↑ in Node.js via their events module
  12. ↑ in browsers via their native EventTarget API
  13. 1 2 3 purely functional
  14. ↑ parameterized classes
  15. ↑ 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.

References

  • Jim Coplien, Multiparadigm Design for C++, Addison-Wesley Professional, 1998.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.