Comparison of multi-paradigm programming languages

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 behavior)
  • 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 a computation should perform, without specifying detailed state changes c.f. imperative programming (functional and logic programming are major subgroups of declarative programing)
  • 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 templates are used by a compiler 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 Num­ber of Para­digms Con­cur­rent Con­straints Data­flow De­clar­at­ive Dis­trib­uted Func­tion­al Meta­pro­gram­ming Gen­er­ic Im­per­at­ive Lo­gic Re­flec­tion Ob­ject-ori­ented Pipe­lines Visu­al Rule-based Oth­er para­digms
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)
BETA 3 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]
ChucK 3 YesNoNoNoNoNoNoNoYesNoNoYes[a 2]NoNoNoNo
Claire2 NoNoNoNoNoYesNoNoNoNoNoYes[a 2]NoNoNoNo
Common Lisp5 Library[23]Library[24]Library[25]Yes[26]Library[27]YesYesYes[28]YesLibrary[29]YesYes (multiple dispatch, method combinations)[30][a 2]Library[31]NoLibrary[32]Multiple dispatch, meta-OOP system[33], Language is extensible via metaprogramming.
Curl5 NoNoNoNoNoYesNoYes[a 3]YesNoYesYes[a 2]NoNoNoNo
Curry4 YesYesNoNoNoYesNoNoNoYesNoNoNoNoNoNo
D (version 2.0)[34][35]6 Yes[a 7]NoNoNoNoYesYes[36][a 3]Yes[a 3]YesNoNoYes[a 2]NoNoNoNo
Dylan3 NoNoNoNoNoYesNoNoNoNoYesYes[a 2]NoNoNoNo
E3 YesNoNoNoYesNoNoNoNoNoNoYes[a 2]NoNoNoNo
ECMAScript[37][38] (ActionScript, E4X, JavaScript, JScript)4 (5) partial (promises, native extensions)[a 8]NoNoNoNoYesNoNoYesNoYesYes[a 9]NoNoNoreactive[a 10]
Embarcadero Delphi3 NoNoNoNoNoNoNoYes[a 3]YesNoNoYes[a 2]NoNoNoNo
Erlang3 YesNoNoNoYesYesNoNoNoNoNoNoYesNoNoNo
Elixir4 YesNoNoNoYesYesYesNoNoNoNoNoYesNoNoNo
Elm6 YesNoYesYesNoYesNoYesNoNoNoNoYesNoNoreactive
F#7 (8) Yes[a 7]NoLibrary[a 4]YesNoYesNoYesYesNoYesYes[a 2]NoNoNoreactive[a 6]
Falcon4 NoNoNoNoNoYesYesNoNoNoYesYes[a 2]NoNoNoNo
Fortran4 (5) YesNoNoNoNoYes[a 11]NoYes[a 12]NoNoNoYes[a 2]NoNoNoArray (multi-dimensional)
Go4 YesNoNoNoNoNoNoNoYesNoYesNoYesNoNoNo
Haskell2? YesLibrary[39]NoYesLibrary[40]Yes (lazy)NoYesYesNoNoNoNoYesNoTemplate:Reactive, dependent types (partial)
Io4 Yes[a 7]NoNoNoNoYesNoNoYesNoNoYes[a 9]NoNoNoNo
J 3 NoNoNoNoNoYesNoNoYesNoNoYes[a 2]NoNoNoNo
Java6 YesLibrary[41]Library[42]NoNoYesNoYesYesNoYesYes[a 2]NoNoNoNo
Julia9 (17) YesLibrary[43]Library[44][45]Library[46]YesYes (eager)YesYesYesLibrary[47]YesYes (multiple dispatch, not traditional single)YesNoLibrary[48][49]Multiple dispatch,
Array (multi-dimensional); optionally lazy[50] and reactive (with libraries)
Kotlin8 YesNoNoNoNoYesYesYesYesNoYesYesYesNoNoNo
LabVIEW4 YesNoYesNoNoNoNoNoNoNoNoYesNoYesNoNo
Lava2 NoNoNoNoNoNoNoNoNoNoNoYes[a 2]NoYesNoNo
Leda4 NoNoNoNoNoYesNoNoYesYesNoYes[a 2]NoNoNoNo
LispWorks (version 6.0 with support for symmetric multi-processing, rules, logic (Prolog), CORBA)9 YesNoNoNoYesYesYesNoYesYesYesYes[a 2]NoNoYesNo
Lua 3 NoNoNoNoNoYesNoNoYesNoNoYes[a 9]NoNoNoNo
MATLAB6 (10) Toolbox[51]Toolbox[52]Yes[53]NoToolbox[54]NoYes[55]Yes[56]NoNoYes[57]Yes[58]NoYes[59]NoArray (multi-dimensional)
Nemerle7 YesNoNoNoNoYesYesYesYesNoYesYes[a 2]NoNoNoNo
Object Pascal4 YesNoNoNoNoYesNoNoYesNoNoYes[a 2]NoNoNoNo
OCaml4 NoNoNoNoNoYesNoYesYesNoNoYes[a 2]NoNoNoNo
Oz11 YesYesYesYesYesYesNoNoYesYesNoYes[a 2]YesNoYesNo
Perl 8 (9) Yes[60]Library[61]Yes[62]NoNoYesYesNoYesNoYes[a 2]Yes[a 2]YesNoNoNo
Perl610 Yes[63]Yes[64]Yes[65]NoLibrary[66]YesYes[67]Yes[68]YesNoYes[69]Yes[70]YesNoNoMultiple dispatch, lazy lists, reactive.
PHP[71][72][73]4 NoNoNoNoNoYesNoNoYesNoYesYes[a 2]NoNoNoNo
Poplog3 NoNoNoNoNoYesNoNoYesYesNoNoNoNoNoNo
Prograph3 NoNoYesNoNoNoNoNoNoNoNoYes[a 2]NoYesNoNo
Python5 (10) Library[74][75] Library[76] No No Library[77] Partial Yes[78][79] Yes[80][81]YesLibrary[82]YesYes[a 2] NoNoNostructured
R4 NoNoNoNoNoYesNoNoYesNoYesYesYes[83]NoNoArray (multi-dimensional)
Racket6 NoNoNoNoNoYesYesNoYesYesYesYesNoNoNoNo
ROOP3 NoNoNoNoNoNoNoNoYesYesNoNoNoNoYesNo
Ruby4 NoNoNoNoNoYesNoNoYesNoYesYes[a 2]NoNoNoNo
Rust (version 1.0.0-alpha)6 Yes[a 7]NoNoNoNoYesYes[84][85]Yes[86]YesNoNoYesNoNoNolinear, affline, and ownership types
Sather2 NoNoNoNoNoYesNoNoNoNoNoYes[a 2]NoNoNoNo
Scala[87][88]9 Yes[a 7]NoYes[a 13]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[89]NoNoYesNoNoYes[a 9][90]NoNoNoNo
Visual Basic .NET6 (7) YesNoLibrary[a 4]NoNoYesNoYesYesNoYesYes[a 2]NoNoNoreactive[a 6]
Windows PowerShell6 NoNoNoNoNoYesNoYesYesNoYesYes[a 2]YesNoNoNo
Wolfram Language & Mathematica13[91] (14) YesYesYesYesYesYesYesYesYesYesYesYesYes[92]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 36 37 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. purely functional
  12. parameterized classes
  13. 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". IEEEXplore. IEEE.
  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
  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. many concurrency paradigms implemented as language extensions
  24. constraint programming inside CL through extensions
  25. dataflow extension
  26. by creating DSLs using the built-in metaprogramming; also see note on functional, constraint and logic paradigms, which are part of declarative
  27. MPI, etc via language extensions
  28. template metaprogramming using macros (see C++)
  29. Prolog implemented as a language extension
  30. Common Lisp Object System see Wikipedia article on CLOS, the Common Lisp Object System.
  31. implemented by the user via a short macro, example of implementation:
  32. rule-based programming extension
  33. through the Meta Object Protocol
  34. D Language Feature Table
  35. Phobos std.algorithm
  36. D language String Mixins
  37. The Little JavaScripter demonstrates fundamental commonality with Scheme, a functional language.
  38. Object Oriented Programming in JavaScript gives an overview of object-oriented programming techniques in JavaScript.
  39. Prolog embedding
  40. Cloud Haskell
  41. https://jcp.org/en/jsr/detail?id=331 JSR 331: Constraint Programming API
  42. https://github.com/GoogleCloudPlatform/DataflowJavaSDK Google Cloud Platform Dataflow SDK
  43. https://jump.readthedocs.io/en/latest/
  44. https://github.com/MikeInnes/DataFlow.jl
  45. https://github.com/JuliaGizmos/Reactive.jl
  46. https://github.com/davidanthoff/Query.jl Query almost anything in julia
  47. https://github.com/lilinjn/LilKanren.jl A collection of Kanren implementations in Julia
  48. https://github.com/abeschneider/PEGParser.jl
  49. https://github.com/gitfoxi/Parsimonious.jl
  50. Lazy https://github.com/MikeInnes/Lazy.jl
  51. "Execute loop iterations in parallel". mathworks.com. Retrieved 21 October 2016.
  52. "Write Constraints". mathworks.com. Retrieved 21 October 2016.
  53. "Getting Started with SimEvents". mathworks.com. Retrieved 21 October 2016.
  54. "Execute loop iterations in parallel". mathworks.com. Retrieved 21 October 2016.
  55. "Execute MATLAB expression in text - MATLAB eval". mathworks.com. Retrieved 21 October 2016.
  56. "Determine class of object". mathworks.com. Retrieved 21 October 2016.
  57. "Class Metadata". mathworks.com. Retrieved 21 October 2016.
  58. "Object-Oriented Programming". mathworks.com. Retrieved 21 October 2016.
  59. "Simulink". mathworks.com. Retrieved 21 October 2016.
  60. interpreter based threads
  61. Moose
  62. Higher Order Perl
  63. Channels and other mechanisms
  64. Feed operator
  65. https://github.com/perl6/doc/issues/1744#issuecomment-360565196 Cro module
  66. https://perl6advent.wordpress.com/2011/12/14/meta-programming-what-why-and-how/
  67. https://perl6advent.wordpress.com/2009/12/18/day-18-roles/ Parametrized Roles
  68. https://docs.perl6.org/language/mop
  69. https://docs.perl6.org/language/classtut Classes and Roles
  70. PHP Manual, Chapter 17. Functions
  71. PHP Manual, Chapter 19. Classes and Objects (PHP 5)
  72. PHP Manual, Anonymous functions
  73. "Parallel Processing and Multiprocessing in Python". wiki.python.org. Retrieved 21 October 2016.
  74. "threading — Higher-level threading interface". docs.python.org. Retrieved 21 October 2016.
  75. "python-constraint". pypi.python.org. Retrieved 21 October 2016.
  76. "DistributedProgramming". wiki.python.org. Retrieved 21 October 2016.
  77. "Chapter 9. Metaprogramming". chimera.labs.oreilly.com. Retrieved 22 October 2016.
  78. "Metaprogramming". readthedocs.io. Retrieved 22 October 2016.
  79. "PEP 443 -- Single-dispatch generic functions". python.org. Retrieved 22 October 2016.
  80. "PEP 484 -- Type Hints". python.org. Retrieved 22 October 2016.
  81. "PyDatalog". Retrieved 22 October 2016.
  82. "Magrittr: A Forward Pipe Operator for R". cran.r-project.org\accessdate=13 July 2017.
  83. "The Rust macros guide". Rust. Retrieved 19 January 2015.
  84. "The Rust compiler plugins guide". Rust. Retrieved 19 January 2015.
  85. The Rust Reference §6.1.3.1
  86. An Overview of the Scala Programming Language
  87. Scala Language Specification
  88. "Tcl Programming/Introduction". en.wikibooks.org. Retrieved 22 October 2016.
  89. "TCLLIB - Tcl Standard Library: snitfaq:". sourceforge.net. Retrieved 22 October 2016.
  90. Notes for Programming Language Experts, Wolfram Language Documentation.
  91. 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.