Language Comparison Table: Difference between revisions
Content added Content deleted
m (added a language design goal.) |
(Added Plain English) |
||
(101 intermediate revisions by 41 users not shown) | |||
Line 1: | Line 1: | ||
[[Category:Encyclopedia]] |
[[Category:Encyclopedia]] |
||
See also [[TL;DR]] (Brief descriptions of languages). |
|||
{|class="wikitable sortable" |
{|class="wikitable sortable" |
||
![[:Category:Programming Languages|Language]] |
![[:Category:Programming Languages|Language]] |
||
Line 14: | Line 16: | ||
!Design goals |
!Design goals |
||
|- |
|- |
||
! {{anchor|ACL2|[[ACL2]]}} |
! {{anchor|ACL2|[[ACL2]]}} |
||
|[[functional programming|functional]] |
|[[functional programming|functional]] |
||
Line 19: | Line 23: | ||
|strong |
|strong |
||
|unsafe |
|unsafe |
||
|implicit |
|||
| |
|||
| |
| |
||
|dynamic |
|dynamic |
||
|immutable reference |
|||
| |
|||
|{{yes}} |
|{{yes}} |
||
|Theorem proving |
|Theorem proving |
||
|Be logically sound, mimic Common Lisp |
|Be logically sound, mimic Common Lisp |
||
|- |
|- |
||
! {{anchor|ActionScript|[[ActionScript]]}} |
! {{anchor|ActionScript|[[ActionScript]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]],[[:Category:Programming paradigm/Distributed|distributed]] |
|[[imperative programming|imperative]], [[object-oriented]],[[:Category:Programming paradigm/Distributed|distributed]] |
||
|{{yes|Yes, [[ECMA]]}} |
|{{yes|Yes, [[wp:Ecma_International|ECMA]]}} |
||
|strong |
|strong |
||
|safe |
|safe |
||
Line 40: | Line 46: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|Ada|[[Ada]]}} |
! {{anchor|Ada|[[Ada]]}} |
||
|[[concurrent programming|concurrent]], [[:Category:Programming paradigm/Distributed|distributed]], [[generic programming|generic]], [[imperative programming|imperative]], [[object-oriented]] |
|[[concurrent programming|concurrent]], [[:Category:Programming paradigm/Distributed|distributed]], [[generic programming|generic]], [[imperative programming|imperative]], [[object-oriented]] |
||
Line 53: | Line 61: | ||
|Reliability and maintenance, Programming as a human activity, Efficiency [http://www.adaic.com/standards/05rm/html/RM-0-3.html Language Reference Manual] |
|Reliability and maintenance, Programming as a human activity, Efficiency [http://www.adaic.com/standards/05rm/html/RM-0-3.html Language Reference Manual] |
||
|- |
|- |
||
! {{anchor|ALGOL_68|[[ALGOL 68]]}} |
! {{anchor|ALGOL_68|[[ALGOL 68]]}} |
||
|[[concurrent programming|concurrent]], [[imperative programming|imperative]] |
|[[concurrent programming|concurrent]], [[imperative programming|imperative]] |
||
|{{yes|Yes, [http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf GOST 27974-88]}} |
|{{yes|Yes, [http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf GOST 27974-88]}} |
||
|strong |
|||
|soft, weak, meek, firm and strong - depending on context. |
|||
|safe |
|safe |
||
|explicit |
|explicit |
||
Line 66: | Line 76: | ||
|Completeness and clarity of design, Orthogonal design, Security, Efficiency (Static mode checking, Mode-independent parsing, Independent compilation, Loop optimization, Representations in minimal & larger character sets) |
|Completeness and clarity of design, Orthogonal design, Security, Efficiency (Static mode checking, Mode-independent parsing, Independent compilation, Loop optimization, Representations in minimal & larger character sets) |
||
|- |
|- |
||
! {{anchor|ALGOL_W|[[ALGOL W]]}} |
|||
|[[imperative programming|imperative]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|explicit |
|||
|nominative |
|||
|static or dynamic (programmer chosen) |
|||
|by value, by reference or by name (programmer chosen) |
|||
|{{yes}} |
|||
|Application, Education |
|||
| |
|||
|- |
|||
! {{anchor|AmbientTalk|[[AmbientTalk]]}} |
! {{anchor|AmbientTalk|[[AmbientTalk]]}} |
||
|[[concurrent programming|concurrent]] |
|[[concurrent programming|concurrent]] |
||
Line 79: | Line 106: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|Arturo|[[Arturo]]}} |
|||
|[[generic programming|generic]], [[imperative programming|imperative]], [[functional programming|functional]], [[reflective programming|reflective]], [[stack|stack]]-based |
|||
|{{no|No, see [https://arturo-lang.io/documentation/ official documentation]}} |
|||
|strong |
|||
| |
|||
|implicit |
|||
| |
|||
|dynamic |
|||
|by value, by reference (literals) |
|||
|{{yes}} |
|||
|General, Scripting, DSLs, Templating, Portable apps, GUI applications |
|||
|Simplicity, Expressiveness, Portability |
|||
|- |
|||
! {{anchor|AutoHotkey|[[AutoHotkey]]}} |
! {{anchor|AutoHotkey|[[AutoHotkey]]}} |
||
|[[imperative programming|imperative]] |
|[[imperative programming|imperative]], [[classless-objects|classless]] |
||
|{{no}} |
|{{no}} |
||
|untyped |
|untyped |
||
Line 92: | Line 136: | ||
|simplicity, speed, stability |
|simplicity, speed, stability |
||
|- |
|- |
||
! {{anchor|AutoIt|[[AutoIt]]}} |
|||
|[[imperative programming|imperative]] |
|||
| |
|||
| |
|||
| |
|||
| |
|||
| |
|||
| |
|||
|by value or by reference |
|||
| |
|||
|General, scripting, GUI and tasks automation |
|||
|Simplicity |
|||
|- |
|||
! {{anchor|BASIC|[[BASIC]]}} |
! {{anchor|BASIC|[[BASIC]]}} |
||
|[[procedural programming|procedural]] |
|[[procedural programming|procedural]] |
||
Line 105: | Line 166: | ||
|Simplicity |
|Simplicity |
||
|- |
|- |
||
! {{anchor|Blade|[[Blade]]}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
|nominative |
|||
|dynamic |
|||
|by value, by reference (through pointers) |
|||
|{{yes}} |
|||
|Scripting, Application |
|||
|Simple, Lightweight, CLI, Web, Desktop, Mobile |
|||
|- |
|||
! {{anchor|C|[[C]]}} |
! {{anchor|C|[[C]]}} |
||
|[[imperative programming|imperative]] |
|[[imperative programming|imperative]] |
||
Line 118: | Line 196: | ||
|Low level access, Minimal constraint |
|Low level access, Minimal constraint |
||
|- |
|- |
||
! {{anchor|C_sharp|[[C sharp|C#]]}} |
! {{anchor|C_sharp|[[C sharp|C#]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]], [[functional programming|functional]], [[event-driven programming|event-driven]] |
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]], [[functional programming|functional]], [[event-driven programming|event-driven]] |
||
|{{yes|Yes, [[ECMA]], [[ISO]]}} |
|{{yes|Yes, [[wp:Ecma_International|ECMA]], [[ISO]]}} |
||
|strong |
|strong |
||
|safe (unsafe allowed) |
|safe (unsafe allowed) |
||
Line 126: | Line 206: | ||
|nominative |
|nominative |
||
|static, dynamic (for interop) |
|static, dynamic (for interop) |
||
|by value, by reference (through managed pointers [explicitly in, out, or in-out]) |
|||
| |
|||
|{{yes}} |
|{{yes}} |
||
|Application |
|Application |
||
|Rapid application development |
|Rapid application development |
||
|- |
|- |
||
! {{anchor|C++|[[C++]]}} |
! {{anchor|C++|[[C++]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]] |
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]] |
||
Line 144: | Line 226: | ||
|Abstraction, Efficiency, Compatibility |
|Abstraction, Efficiency, Compatibility |
||
|- |
|- |
||
! {{anchor|Chapel|[[Chapel]]}} |
! {{anchor|Chapel|[[Chapel]]}} |
||
|[[concurrent]], [[generic programming|generic]], [[object-oriented]], [[imperative programming|imperative]], [[:Category:Programming paradigm/Distributed|distributed]], [[reflective programming|reflective]] |
|[[concurrent]], [[generic programming|generic]], [[object-oriented]], [[imperative programming|imperative]], [[:Category:Programming paradigm/Distributed|distributed]], [[reflective programming|reflective]] |
||
Line 157: | Line 241: | ||
|Programmer productivity (compared to C/Fortran), performance |
|Programmer productivity (compared to C/Fortran), performance |
||
|- |
|- |
||
! {{anchor|Clean|[[Clean]]}} |
! {{anchor|Clean|[[Clean]]}} |
||
|[[functional programming|functional]], [[generic programming|generic]] |
|[[functional programming|functional]], [[generic programming|generic]] |
||
Line 170: | Line 256: | ||
|Correctness, Modularity |
|Correctness, Modularity |
||
|- |
|- |
||
! {{anchor|Clojure|[[Clojure]]}} |
! {{anchor|Clojure|[[Clojure]]}} |
||
|[[functional programming|functional]], [[concurrent programming|concurrent]] |
|[[functional programming|functional]], [[concurrent programming|concurrent]] |
||
Line 183: | Line 271: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|COBOL|[[COBOL]]}} |
! {{anchor|COBOL|[[COBOL]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]] |
|[[imperative programming|imperative]], [[object-oriented]] |
||
|{{yes|Yes, [[ANSI]] 68, 74, 85 (and subsequent revisions); [[ISO]] 2002, |
|{{yes|Yes, [[ANSI]] 68, 74, 85 (and subsequent revisions); ECMA; [[ISO]] 1989:2023 (and previous version in 1978, 1985, 2002, 2014)}} |
||
|strong |
|strong |
||
|safe |
|safe |
||
Line 196: | Line 286: | ||
|Readability |
|Readability |
||
|- |
|- |
||
! {{anchor|ColdFusion|[[ColdFusion]]}} |
! {{anchor|ColdFusion|[[ColdFusion]]}} |
||
|[[procedural programming|procedural]], [[object-oriented]] |
|[[procedural programming|procedural]], [[object-oriented]] |
||
Line 209: | Line 301: | ||
|Rapid Application Development, Ease of use |
|Rapid Application Development, Ease of use |
||
|- |
|- |
||
! {{anchor|Common Lisp|[[Common Lisp]]}} |
! {{anchor|Common Lisp|[[Common Lisp]]}} |
||
|[[imperative programming|imperative]], [[functional programming|functional]], [[object-oriented]] |
|[[imperative programming|imperative]], [[functional programming|functional]], [[object-oriented]] |
||
Line 222: | Line 316: | ||
|Standardize [[Lisp]] |
|Standardize [[Lisp]] |
||
|- |
|- |
||
! {{anchor|D|[[D]]}} |
! {{anchor|D|[[D]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]] |
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]] |
||
Line 235: | Line 331: | ||
|Compilability, Correctness, Efficiency |
|Compilability, Correctness, Efficiency |
||
|- |
|- |
||
! {{anchor|Dao|[[Dao]]}} |
! {{anchor|Dao|[[Dao]]}} |
||
|[[object-oriented]] |
|[[object-oriented]] |
||
Line 248: | Line 346: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|Dyalect|[[Dyalect]]}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
|duck |
|||
|dynamic |
|||
|by reference |
|||
|{{yes}} |
|||
|Application |
|||
|Portable dynamic scripting language with consistent design and modern syntax |
|||
|- |
|||
! {{anchor|Dylan|[[Dylan]]}} |
! {{anchor|Dylan|[[Dylan]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]], [[procedural programming|procedural]] |
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]], [[procedural programming|procedural]] |
||
Line 261: | Line 375: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|E|[[E]]}} |
! {{anchor|E|[[E]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[object-capability]], [[communicating event loops]] |
|[[imperative programming|imperative]], [[object-oriented]], [[object-capability]], [[communicating event loops]] |
||
Line 274: | Line 390: | ||
|<!-- Design goals -->Familiarity to [[C]]/[[Java]]/[[JavaScript|JS]] users; less error-prone concurrency & security |
|<!-- Design goals -->Familiarity to [[C]]/[[Java]]/[[JavaScript|JS]] users; less error-prone concurrency & security |
||
|- |
|- |
||
! {{anchor|EC|[[eC]]}} |
! {{anchor|EC|[[eC]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]] |
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]] |
||
Line 287: | Line 405: | ||
|Elegance, Performance, Simplicity, Lightness, 99.9% [[C]] compatibility |
|Elegance, Performance, Simplicity, Lightness, 99.9% [[C]] compatibility |
||
|- |
|- |
||
! {{anchor|Ecstasy|[[Ecstasy]]}} |
|||
|[[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]], [[functional programming|functional]], [[imperative programming|imperative]] |
|||
|{{no|No}} |
|||
|strong |
|||
|safe |
|||
|explicit, optionally inferred |
|||
|nominative; duck for interface types |
|||
|static; dynamic for generic edge conditions |
|||
|by value; by reference |
|||
|{{yes}} |
|||
|Application |
|||
|Predictable, Secure, Composable |
|||
|- |
|||
! {{anchor|Eiffel|[[Eiffel]]}} |
! {{anchor|Eiffel|[[Eiffel]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]] |
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]] |
||
Line 301: | Line 436: | ||
|- |
|- |
||
! {{anchor|Ela|[[Ela]]}} |
! {{anchor|Ela|[[Ela]]}} |
||
|[[functional programming|functional]] |
|[[functional programming|functional]] |
||
Line 309: | Line 446: | ||
|duck |
|duck |
||
|dynamic |
|dynamic |
||
|by |
|by reference |
||
|{{yes}} |
|{{yes}} |
||
|Application |
|Application |
||
Line 316: | Line 453: | ||
|- |
|- |
||
! {{anchor|Elm|[[Elm]]}} |
! {{anchor|Elm|[[Elm]]}} |
||
|[[functional programming|functional]], functional reactive programming, [[declarative programming|declarative]], pattern matching |
|[[functional programming|functional]], functional reactive programming, [[declarative programming|declarative]], pattern matching |
||
Line 331: | Line 470: | ||
|- |
|- |
||
! {{anchor|Elena|[[Elena]]}} |
! {{anchor|Elena|[[Elena]]}} |
||
|[[object-oriented]] |
|[[object-oriented]] |
||
Line 344: | Line 485: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|Erlang|[[Erlang]]}} |
! {{anchor|Erlang|[[Erlang]]}} |
||
|[[functional programming|functional]], [[concurrent programming|concurrent]], [[:Category:Programming paradigm/Distributed|distributed]], [[declarative programming|declarative]] - pattern matching, [[imperative programming|imperative]] |
|[[functional programming|functional]], [[concurrent programming|concurrent]], [[:Category:Programming paradigm/Distributed|distributed]], [[declarative programming|declarative]] - pattern matching, [[imperative programming|imperative]] |
||
Line 357: | Line 500: | ||
|Fault tolerance, Reliability - Nonstop Running, Hot Code Change, Safety, Concurrency, Distribution, Scalability |
|Fault tolerance, Reliability - Nonstop Running, Hot Code Change, Safety, Concurrency, Distribution, Scalability |
||
|- |
|- |
||
! {{anchor|ERRE|[[ERRE]]}} |
|||
|[[imperative programming|imperative]], [[procedural programming|procedural]] |
|||
|{{no}} |
|||
|weak |
|||
|unsafe |
|||
|explicit |
|||
| |
|||
|static and dynamic |
|||
|by value |
|||
|{{yes}} |
|||
|Education |
|||
|Readability, Modularity |
|||
|- |
|||
! {{anchor|Factor|[[Factor]]}} |
! {{anchor|Factor|[[Factor]]}} |
||
|[[stack]]-oriented |
|[[stack]]-oriented |
||
Line 370: | Line 530: | ||
|<!-- Design goals -->x |
|<!-- Design goals -->x |
||
|- |
|- |
||
! {{anchor|Forth|[[Forth]]}} |
! {{anchor|Forth|[[Forth]]}} |
||
|[[imperative programming|imperative]], [[stack]]-oriented |
|[[imperative programming|imperative]], [[stack]]-oriented |
||
|{{yes|Yes, [[ANSI]]}} |
|{{yes|Yes, [[ANSI]], [https://www.iso.org/standard/26479.html ISO/IEC 15145:1997]}} |
||
|none |
|none |
||
|n/a |
|n/a |
||
Line 380: | Line 542: | ||
| |
| |
||
|{{no}} |
|{{no}} |
||
| |
|Applications, High reliability, Embedded systems, Booting new hardware. |
||
|Compact implementations, Low level access, Interactive programming |
|Compact implementations, Low level access, Interactive programming, CPU agnostic Assembler Alternative, ultra-small memory systems. |
||
|- |
|- |
||
! {{anchor|Fortran|[[Fortran]]}} |
! {{anchor|Fortran|[[Fortran]]}} |
||
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[object-oriented]] |
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[object-oriented]], (partially) [[generic programming|generic]], [[concurrent programming|concurrent]] |
||
|{{yes|Yes, [[ISO]], [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=39691 ISO/IEC 1539-1:2004]}} |
|{{yes|Yes, [[ISO]], [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=39691 ISO/IEC 1539-1:2004]}} |
||
|strong |
|strong |
||
|safe |
|safe |
||
|explicit, partially implicit |
|||
| |
|||
|nominative |
|nominative |
||
|static |
|static, dynamic |
||
|by reference, or explicitly by value |
|||
| |
|||
|{{no}} |
|{{no}} |
||
|Scientific and numeric applications |
|Scientific and numeric applications |
||
|Runtime efficiency, Simple syntax |
|Runtime efficiency, Simple syntax |
||
|- |
|- |
||
! {{anchor|FutureBasic|[[FutureBasic]]}} |
|||
|[[procedural programming|procedural]] |
|||
|{{no|No}} |
|||
|strong |
|||
| |
|||
| |
|||
|nominative |
|||
|static |
|||
|by value, by reference (through pointers) |
|||
|{{yes|Yes}} |
|||
|Educational, Scientific, Prototyping, Commercial Level Applications |
|||
|Mac Freeware, Readability, Simplicity, Efficiency, C/Objective-C Compatibility, Objective-C Alternative, Builds Xcode Projects |
|||
|- |
|||
! {{anchor|Gambas|[[Gambas]]}} |
! {{anchor|Gambas|[[Gambas]]}} |
||
|[[object-oriented|object-oriented]] |
|[[object-oriented|object-oriented]] |
||
Line 409: | Line 590: | ||
|<!-- Design goals -->Rapid application development, Visual Basic alternative |
|<!-- Design goals -->Rapid application development, Visual Basic alternative |
||
|- |
|- |
||
! {{anchor|Go|[[Go]]}} |
! {{anchor|Go|[[Go]]}} |
||
|[[concurrent programming|concurrent]] |
|[[concurrent programming|concurrent]], [[classless-objects|classless]] |
||
|<!-- Std -->{{no}}, [http://golang.org/ref/spec language specification] available |
|<!-- Std -->{{no}}, [http://golang.org/ref/spec language specification] available |
||
|<!-- Strength -->strong |
|<!-- Strength -->strong |
||
Line 422: | Line 605: | ||
|<!-- Design goals --> |
|<!-- Design goals --> |
||
|- |
|- |
||
! {{anchor|Gosu|[[Gosu]]}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]], [[functional programming|functional]] |
|||
|{{yes|Yes}} |
|||
|strong |
|||
|safe |
|||
|explicit, optionally inferred |
|||
|nominative and structural |
|||
|static |
|||
|by value |
|||
|{{yes}} |
|||
|Application |
|||
|Open type system, optional dynamic loading |
|||
|- |
|||
! {{anchor|Groovy|[[Groovy]]}} |
! {{anchor|Groovy|[[Groovy]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[ |
|[[imperative programming|imperative]], [[object-oriented]], [[wp:Aspect-oriented_programming|aspect-oriented]] |
||
|{{no}} |
|{{no}} |
||
|strong |
|strong |
||
Line 435: | Line 635: | ||
|[[JVM]] compatibility |
|[[JVM]] compatibility |
||
|- |
|- |
||
! {{anchor|Haskell|[[Haskell]]}} |
! {{anchor|Haskell|[[Haskell]]}} |
||
|[[functional programming|functional]], [[generic programming|generic]], [[lazy evaluation]] |
|[[functional programming|functional]], [[generic programming|generic]], [[lazy evaluation]] |
||
Line 448: | Line 650: | ||
|[[lazy evaluation]], Teaching and research, completely formally described [http://haskell.org/onlinereport/preface-jfp.html Report Preface] |
|[[lazy evaluation]], Teaching and research, completely formally described [http://haskell.org/onlinereport/preface-jfp.html Report Preface] |
||
|- |
|- |
||
! {{anchor|Huginn|[[Huginn]]}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]] |
|||
|{{no|No, [http://huginn.org/referece language reference] included with each version's documentation}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
| |
|||
|dynamic |
|||
|by reference |
|||
|{{optional|Reference counting}} |
|||
|Education, Application, Scripting, Interactive system shell |
|||
|Consistency, Simplicity, Readability, Expressiveness, Modularity |
|||
|- |
|||
! {{anchor|Icon|[[icon]]}} |
! {{anchor|Icon|[[icon]]}} |
||
| [[procedural programming|procedural]], [[structured]], [[Goal_directed_programming|goal directed]], [[string scanning]], [[co-expressions]] |
| [[procedural programming|procedural]], [[structured]], [[Goal_directed_programming|goal directed]], [[string scanning]], [[co-expressions]] |
||
Line 461: | Line 678: | ||
| Facilitates ease of programming, short concise programs, automatic storage allocation and management, provide a rich base of basic data types and structures, and platform independence. Also see [[#Unicon|Unicon]] for the unified extended dialect of Icon. |
| Facilitates ease of programming, short concise programs, automatic storage allocation and management, provide a rich base of basic data types and structures, and platform independence. Also see [[#Unicon|Unicon]] for the unified extended dialect of Icon. |
||
|- |
|- |
||
! {{anchor|Insitux|[[Insitux]]}} |
|||
|[[functional programming|functional]], [[imperative programming|imperative]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
| |
|||
|dynamic |
|||
|by value |
|||
|{{yes}} |
|||
|Host-driven scripting |
|||
|Host-extensibility; provide "safe" modding e.g. timeout infinite loops, memory limits; concise code |
|||
|- |
|||
! {{anchor|Io|[[Io]]}} |
! {{anchor|Io|[[Io]]}} |
||
|[[object-oriented]], prototype |
|[[object-oriented]], [[classless-objects|classless]], prototype |
||
|{{no}} |
|{{no}} |
||
|strong |
|strong |
||
Line 474: | Line 706: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|J|[[J]]}} |
! {{anchor|J|[[J]]}} |
||
|[[array]] programming, function-level programming, [[tacit programming|tacit]] |
|[[array]] programming, function-level programming, [[tacit programming|tacit]] |
||
Line 487: | Line 721: | ||
|Describe computers mathematically and concisely |
|Describe computers mathematically and concisely |
||
|- |
|- |
||
! {{anchor|Java|[[Java]]}} |
! {{anchor|Java|[[Java]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]] |
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]] |
||
Line 500: | Line 736: | ||
|Write once run anywhere |
|Write once run anywhere |
||
|- |
|- |
||
! {{anchor|JavaScript|[[JavaScript]]}} |
! {{anchor|JavaScript|[[JavaScript]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]], [[reflective programming|reflective]] |
|[[imperative programming|imperative]], [[object-oriented]], [[classless-objects|classless]], [[functional programming|functional]], [[reflective programming|reflective]] |
||
|{{yes|Yes, [[ECMAScript standard]]}} |
|{{yes|Yes, [[ECMAScript standard]]}} |
||
|weak |
|weak |
||
Line 513: | Line 751: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|Joy|[[Joy]]}} |
! {{anchor|Joy|[[Joy]]}} |
||
|[[functional programming|functional]], [[stack]]-oriented |
|[[functional programming|functional]], [[stack]]-oriented |
||
Line 526: | Line 766: | ||
|[[concatenative programming|concatenative]] |
|[[concatenative programming|concatenative]] |
||
|- |
|- |
||
! {{anchor|jq|[[jq]]}} |
|||
|[[functional programming|functional]], [[tacit programming|tacit (point-free)]], [[dataflow programming|dataflow]] |
|||
|<!-- Std -->{{no|No, but a de facto standard exists in the agreement between the C and Go-based versions}} |
|||
|<!-- Strength -->weak |
|||
|<!-- Safety -->safe |
|||
|<!-- Expr -->implicit |
|||
|<!-- Compat -->n.a. |
|||
|<!-- Check -->dynamic |
|||
|<!-- Passing -->by value, with limited support for closures |
|||
|<!-- GC -->{{yes}} |
|||
|<!-- Uses -->Processing streams of JSON documents or strings; gojq also supports YAML |
|||
|<!-- Design goals -->Turing-completeness; ease of use and economy of expression within functional/dataflow programming frameworks |
|||
|- |
|||
! {{anchor|Kabap|[[Kabap]]}} |
|||
|[[imperative programming|imperative]], [[Dynamic programming|dynamic]], extensible |
|||
|{{yes}} |
|||
|weak |
|||
|unsafe |
|||
|implicit |
|||
|duck |
|||
|dynamic |
|||
|by value |
|||
| |
|||
|User scripting, general |
|||
|Safe sandboxed, easy to learn, easier to implement. Use to avoid eval() & reflection |
|||
|- |
|||
! {{anchor|Keg|[[Keg]]}} |
|||
|[[imperative programming|imperative]], [[Concatenative programming|concatenative]] |
|||
|{{no}} |
|||
|untyped |
|||
|unsafe |
|||
|implicit |
|||
|nominative |
|||
|dynamic |
|||
|by reference |
|||
|{{no}} |
|||
|Code Golf, general |
|||
|Be simple, readable, and concise |
|||
|- |
|||
! {{anchor|Kotlin|[[Kotlin]]}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], |
|||
[[procedural programming|procedural]], [[functional programming|functional]], |
|||
[[generic programming|generic]], [[reflective programming|reflective]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|explicit, optionally inferred |
|||
|nominative |
|||
|static, dynamic (JS only) |
|||
|by value (read-only) |
|||
|{{yes}} |
|||
|Application |
|||
|Pragmatic language for modern multi-platform applications with compilers for JVM, JS and Native code |
|||
|- |
|||
! {{anchor|LDPL|[[LDPL]]}} |
|||
|[[imperative programming|imperative]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|explicit |
|||
| |
|||
|static |
|||
| |
|||
|{{no}} |
|||
|Portable applications, readable source codes, teaching |
|||
|Readability |
|||
|- |
|||
! {{anchor|LFE|[[LFE]]}} |
! {{anchor|LFE|[[LFE]]}} |
||
|[[functional programming|functional]], [[concurrent programming|concurrent]], [[:Category:Programming paradigm/Distributed|distributed]], [[declarative programming|declarative]] - pattern matching, [[imperative programming|imperative]] |
|[[functional programming|functional]], [[concurrent programming|concurrent]], [[:Category:Programming paradigm/Distributed|distributed]], [[declarative programming|declarative]] - pattern matching, [[imperative programming|imperative]] |
||
Line 539: | Line 857: | ||
|Fault tolerance, Reliability - Nonstop Running, Hot Code Change, Safety, Concurrency, Distribution, Scalability |
|Fault tolerance, Reliability - Nonstop Running, Hot Code Change, Safety, Concurrency, Distribution, Scalability |
||
|- |
|- |
||
! {{anchor|Lisp|[[Lisp]]}} |
! {{anchor|Lisp|[[Lisp]]}} |
||
|[[functional programming|functional]], [[reflective programming|reflective]]; others vary by dialect |
|[[functional programming|functional]], [[reflective programming|reflective]]; others vary by dialect |
||
Line 552: | Line 872: | ||
|Simple notation for Lambda calculus, Homoiconicity |
|Simple notation for Lambda calculus, Homoiconicity |
||
|- |
|- |
||
! {{anchor|Logo|[[Logo]]}} |
! {{anchor|Logo|[[Logo]]}} |
||
|[[procedural programming|procedural]], [[functional programming|functional]] |
|[[procedural programming|procedural]], [[functional programming|functional]] |
||
Line 565: | Line 887: | ||
|Simple syntax, Turtle graphics, Interactive programming |
|Simple syntax, Turtle graphics, Interactive programming |
||
|- |
|- |
||
! {{anchor|Lua|[[Lua]]}} |
! {{anchor|Lua|[[Lua]]}} |
||
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[reflective programming|reflective]] |
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[classless-objects|classless]], [[reflective programming|reflective]] |
||
|{{no}} |
|{{no}} |
||
|strong |
|strong |
||
Line 578: | Line 902: | ||
|Small, embedded, configuration. |
|Small, embedded, configuration. |
||
|- |
|- |
||
! {{anchor|Lucid|[[Lucid]]}} |
! {{anchor|Lucid|[[Lucid]]}} |
||
|[[dataflow programming|dataflow]], [[functional programming|functional]] |
|[[dataflow programming|dataflow]], [[functional programming|functional]] |
||
Line 591: | Line 917: | ||
|dataflow |
|dataflow |
||
|- |
|- |
||
! {{anchor|Luck|[[Luck]]}} |
|||
|[[imperative programming|imperative]], [[functional programming|functional]] |
|||
|{{no}} |
|||
|weak |
|||
|unsafe |
|||
|explicit, partially inferred |
|||
|nominative |
|||
|static |
|||
|by value or by reference |
|||
|{{yes}} |
|||
|systems programming |
|||
|fast, C compatible, high-level language |
|||
|- |
|||
! {{anchor|Mathematica|[[Mathematica]]}} |
! {{anchor|Mathematica|[[Mathematica]]}} |
||
|[[functional programming|functional]], [[procedural programming|procedural]] |
|[[functional programming|functional]], [[procedural programming|procedural]] |
||
Line 604: | Line 947: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|MATLAB|[[MATLAB]]}} |
! {{anchor|MATLAB|[[MATLAB]]}} |
||
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[array]] programming |
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[array]] programming |
||
Line 617: | Line 962: | ||
|At the beginning designed as interpreter for easy use of fortran libraries, nowadays high performance numerical analysis and visualization |
|At the beginning designed as interpreter for easy use of fortran libraries, nowadays high performance numerical analysis and visualization |
||
|- |
|- |
||
! {{anchor|MAXScript|[[MAXScript]]}} |
! {{anchor|MAXScript|[[MAXScript]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[procedural programming|procedural]] |
|[[imperative programming|imperative]], [[object-oriented]], [[procedural programming|procedural]] |
||
Line 630: | Line 977: | ||
|Simplicity, Accessibilty |
|Simplicity, Accessibilty |
||
|- |
|- |
||
! {{anchor|Modula-3|[[Modula-3]]}} |
! {{anchor|Modula-3|[[Modula-3]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[procedural programming|procedural]], [[generic programming|generic]] |
|[[imperative programming|imperative]], [[object-oriented]], [[procedural programming|procedural]], [[generic programming|generic]] |
||
Line 643: | Line 992: | ||
|Simple, Object oriented |
|Simple, Object oriented |
||
|- |
|- |
||
! {{anchor|MUMPS|[[MUMPS]]}} |
! {{anchor|MUMPS|[[MUMPS]]}} |
||
|[[procedural programming|procedural]] |
|[[procedural programming|procedural]] |
||
|{{yes|Yes, [ |
|{{yes|Yes, [https://www.iso.org/standard/29268.html ISO/IEC 11756:1999]}} |
||
|untyped |
|untyped |
||
|not applicable |
|not applicable |
||
Line 656: | Line 1,007: | ||
|Built-in Persistent Storage |
|Built-in Persistent Storage |
||
|- |
|- |
||
! {{anchor|Nial|[[Nial]]}} |
! {{anchor|Nial|[[Nial]]}} |
||
|[[functional programming|functional]], [[array]] programming |
|[[functional programming|functional]], [[array]] programming |
||
Line 669: | Line 1,022: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|Nimrod|[[Nimrod]]}} |
|||
! {{anchor|Nim|[[Nim]]}} |
|||
|[[procedural programming|procedural]], [[functional programming|functional]], [[generic programming|generic]] |
|[[procedural programming|procedural]], [[functional programming|functional]], [[generic programming|generic]] |
||
|{{no}} |
|{{no}} |
||
|strong |
|strong |
||
|safe |
|safe |
||
|explicit |
|||
| |
|||
|nominative, structural |
|||
| |
|||
|static |
|static |
||
|by value, by reference (through reference types) |
|||
| |
|||
|{{Yes}} |
|{{Yes}} |
||
|General, Application, Systems |
|General, Application, Systems, Games, Scripting, Web |
||
|Efficient, Expressive, Elegant in that order. |
|Efficient, Expressive, Elegant in that order. |
||
|- |
|- |
||
! {{anchor|Oberon-2|[[Oberon-2]]}} |
! {{anchor|Oberon-2|[[Oberon-2]]}} |
||
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[object-oriented]] |
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[object-oriented]], [[classless-objects|classless]] |
||
|{{no}} |
|{{no}} |
||
|strong |
|strong |
||
Line 695: | Line 1,052: | ||
|Simplicity |
|Simplicity |
||
|- |
|- |
||
! {{anchor|Objeck|[[Objeck]]}} |
! {{anchor|Objeck|[[Objeck]]}} |
||
|[[object-oriented]],[[functional programming|functional]] |
|[[object-oriented]],[[functional programming|functional]] |
||
Line 708: | Line 1,067: | ||
|Minimalist, Cross-Platform, Modular |
|Minimalist, Cross-Platform, Modular |
||
|- |
|- |
||
! {{anchor|Object Pascal|[[Object Pascal]]}} ({{anchor|Delphi|[[Delphi]]}}) |
! {{anchor|Object Pascal|[[Object Pascal]]}} ({{anchor|Delphi|[[Delphi]]}}) |
||
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]] |
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]] |
||
Line 721: | Line 1,082: | ||
|Readability, Rapid application development, Modularity |
|Readability, Rapid application development, Modularity |
||
|- |
|- |
||
! {{anchor|Objective-C|[[Objective-C]]}} |
! {{anchor|Objective-C|[[Objective-C]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[reflective programming|reflective]] |
|[[imperative programming|imperative]], [[object-oriented]], [[reflective programming|reflective]], [[generic programming|generic]] (as of Xcode 7) |
||
|{{no}} |
|{{no}} |
||
|weak |
|weak |
||
Line 732: | Line 1,095: | ||
|{{yes|Yes (as of 2.0)}} |
|{{yes|Yes (as of 2.0)}} |
||
|Application |
|Application |
||
|[[Smalltalk]] like, Component based code reuse, [[C]] compatibility |
|[[Smalltalk]] like, Component based code reuse, [[C]]/[[C++]] compatibility |
||
|- |
|- |
||
! {{anchor|OCaml|[[OCaml]]}} |
! {{anchor|OCaml|[[OCaml]]}} |
||
|[[object-oriented]], [[functional programming|functional]], [[imperative programming|imperative]], [[generic programming|generic]] |
|[[object-oriented]], [[functional programming|functional]], [[imperative programming|imperative]], [[generic programming|generic]] |
||
Line 747: | Line 1,112: | ||
|Efficiency, Robustness, Correctness |
|Efficiency, Robustness, Correctness |
||
|- |
|- |
||
! {{anchor|Oz|[[Oz]]}} |
! {{anchor|Oz|[[Oz]]}} |
||
|logic programming, [[functional programming|functional]], [[imperative programming|imperative]], [[object-oriented]], [[concurrent programming|concurrent]] |
|logic programming, [[functional programming|functional]], [[imperative programming|imperative]], [[object-oriented]], [[concurrent programming|concurrent]] |
||
Line 760: | Line 1,127: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|PARI/GP|[[PARI/GP]]}} |
! {{anchor|PARI/GP|[[PARI/GP]]}} |
||
|[[imperative programming|imperative]], [[procedural programming|procedural]] |
|[[imperative programming|imperative]], [[procedural programming|procedural]] |
||
Line 773: | Line 1,142: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|Pascal|[[Pascal]]}} |
! {{anchor|Pascal|[[Pascal]]}} |
||
|[[imperative programming|imperative]], [[procedural programming|procedural]] |
|[[imperative programming|imperative]], [[procedural programming|procedural]] |
||
|{{yes| [https://www.iso.org/standard/13802.html ISO 7185:1990] and [https://www.iso.org/standard/18237.html ISO 10206:1991]}} |
|||
|{{yes|Yes, Extended Pascal standardized under [[ISO]]}} |
|||
|strong |
|strong |
||
|safe |
|safe |
||
Line 786: | Line 1,157: | ||
|Readability, Discipline, Modularity |
|Readability, Discipline, Modularity |
||
|- |
|- |
||
! {{anchor|Perl|[[Perl]]}} |
! {{anchor|Perl|[[Perl]]}} |
||
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[reflective programming|reflective]], [[functional programming|functional]], [[object-oriented]], [[generic programming|generic]] |
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[reflective programming|reflective]], [[functional programming|functional]], [[object-oriented]], [[generic programming|generic]] |
||
Line 799: | Line 1,172: | ||
|Terseness, Expressiveness |
|Terseness, Expressiveness |
||
|- |
|- |
||
! {{anchor|Perl 6|[[Perl 6]]}} |
|||
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[reflective programming|reflective]], [[functional programming|functional]], [[object-oriented]], [[generic programming|generic]], [[lazy evaluation]], multiple dispatch, metaprogramming |
|||
! {{anchor|Phix|[[Phix]]}} |
|||
|{{yes|Yes, [http://perlcabal.org/syn/#doctable Perl 6 Synopses]}} |
|||
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[object-oriented]] |
|||
|strong |
|||
|<!-- Std -->{{no}} |
|||
|safe, unsafe |
|||
|<!-- Strength -->strong |
|||
|optional explicit |
|||
|<!-- Safety -->safe |
|||
|nominal (duck and structural available via constraints, patterns, generics, and gradual typing) |
|||
|<!-- Expr -->explicit, partially implicit |
|||
|dynamic, static |
|||
|<!-- Compat -->duck |
|||
|<!-- Check -->dynamic, static |
|||
|<!-- Passing -->copy on write, immutable reference, multiple returns |
|||
|<!-- GC -->{{optional|Reference counting or JavaScript compatible}} |
|||
|<!-- Uses -->Application, Educational, General, High-level scripting, Text processing |
|||
|<!-- Design goals -->Simplicity, Readability, Ease of use |
|||
|- |
|||
! {{anchor|PHP|[[PHP]]}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[reflective programming|reflective]] |
|||
|{{no}} |
|||
|weak |
|||
| |
|||
| |
|||
| |
|||
|dynamic |
|||
|by value, by reference |
|by value, by reference |
||
|{{yes}} |
|{{yes}} |
||
|Application, |
|Web Application, CLI |
||
|Robustness and Simplicity |
|||
|Expressiveness, generality |
|||
|- |
|- |
||
! {{anchor|Pike|[[Pike]]}} |
! {{anchor|Pike|[[Pike]]}} |
||
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[functional programming|functional]], [[object-oriented]], [[reflective programming|reflective]], [[event-driven programming|event-driven]] |
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[functional programming|functional]], [[object-oriented]], [[reflective programming|reflective]], [[event-driven programming|event-driven]] |
||
Line 825: | Line 1,217: | ||
|optimized execution, efficient networking |
|optimized execution, efficient networking |
||
|- |
|- |
||
! {{anchor|PHP|[[PHP]]}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[reflective programming|reflective]] |
|||
! {{anchor|Plain English|[[Plain English]]}} |
|||
|[[imperative programming|imperative]], [[procedural programming|procedural]] |
|||
|{{no}} |
|{{no}} |
||
|strong |
|||
|weak |
|||
|safe |
|||
| |
|||
|explicit |
|||
| |
|||
|nominative |
|||
| |
|||
|static |
|||
|dynamic |
|||
| |
|by reference |
||
|{{ |
|{{no}} |
||
| |
|Application, Education, General |
||
| |
|Ease of use, Expressiveness, Readability, Simplicity |
||
|- |
|- |
||
! {{anchor|Pop11|[[Pop11]]}} |
! {{anchor|Pop11|[[Pop11]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]] |
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]] |
||
Line 851: | Line 1,247: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|Prolog|[[Prolog]]}} |
! {{anchor|Prolog|[[Prolog]]}} |
||
|logic programming |
|logic programming |
||
Line 864: | Line 1,262: | ||
|[[declarative programming|declarative]] |
|[[declarative programming|declarative]] |
||
|- |
|- |
||
!{{anchor|Pure|[[Pure]]}} |
!{{anchor|Pure|[[Pure]]}} |
||
|[[dynamic programming|dynamic]], [[functional programming|functional]] |
|[[dynamic programming|dynamic]], [[functional programming|functional]] |
||
Line 877: | Line 1,277: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|Python|[[Python]]}} |
! {{anchor|Python|[[Python]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]], [[ |
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]], [[wp:Aspect-oriented_programming|aspect-oriented]], [[reflective programming|reflective]] |
||
|{{no|No, [http://docs.python.org/reference/index.html language reference] included with each version's documentation}} |
|{{no|No, [http://docs.python.org/reference/index.html language reference] included with each version's documentation}} |
||
|strong |
|strong |
||
Line 890: | Line 1,292: | ||
|Simplicity, Readability, Expressiveness, Modularity |
|Simplicity, Readability, Expressiveness, Modularity |
||
|- |
|- |
||
! {{anchor|R|[[R]]}} |
|||
|[[functional programming|functional]], [[imperative programming|imperative]], [[reflective programming|reflective]], [[array]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
|Duck, structural |
|||
|dynamic |
|||
|value by need, by name (programmer chosen) |
|||
|{{yes}} |
|||
|Statistics, Numerical computation, Visualization, Education |
|||
|Expressiveness, interactive manipulation and analysis of datasets |
|||
|- |
|||
! {{anchor|Ra|[[Ra]]}} |
|||
|[[object-oriented]] |
|||
|{{no}} |
|||
|dynamic or static |
|||
|safe |
|||
|implicit or explicit |
|||
| |
|||
|dynamic or static |
|||
| |
|||
|{{yes}} |
|||
|General |
|||
|Program in native language, clean and clear syntax, extensive standard library, convenience |
|||
|- |
|||
! {{anchor|Racket|[[Racket]]}} |
! {{anchor|Racket|[[Racket]]}} |
||
|[[functional programming|functional]], [[imperative programming|imperative]], [[object-oriented]], [[reflective programming|reflective]] |
|[[functional programming|functional]], [[imperative programming|imperative]], [[object-oriented]], [[reflective programming|reflective]] |
||
Line 903: | Line 1,337: | ||
|Extensibility, Simplicity, Modularity |
|Extensibility, Simplicity, Modularity |
||
|- |
|- |
||
! {{anchor|RapidQ|[[RapidQ]]}} |
! {{anchor|RapidQ|[[RapidQ]]}} |
||
|[[imperative programming|imperative]], component-oriented programming, [[event-driven programming|event-driven]] |
|[[imperative programming|imperative]], component-oriented programming, [[event-driven programming|event-driven]] |
||
Line 917: | Line 1,353: | ||
|- |
|- |
||
! {{anchor| |
! {{anchor|Raku|[[Raku]]}} ({{anchor|Raku|[[formerly Perl 6]]}}) |
||
|[[ |
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[reflective programming|reflective]], [[functional programming|functional]], [[object-oriented]], [[generic programming|generic]], [[lazy evaluation]], multiple dispatch, metaprogramming |
||
|{{no|No. The [https://github.com/perl6/roast Repository Of All Spec Tests (aka 'roast') defines the language]}} |
|||
|{{no}} |
|||
|strong |
|strong |
||
|safe |
|safe, unsafe |
||
|optional explicit |
|||
|implicit |
|||
|nominal (duck and structural available via constraints, patterns, generics, and gradual typing) |
|||
|Duck, structural |
|||
|dynamic |
|dynamic, static |
||
| |
|by value, by reference |
||
|{{yes}} |
|{{yes}} |
||
|Application, text processing, scripting |
|||
|Statistics, Numerical computation, Visualization, Education |
|||
|Expressiveness, |
|Expressiveness, generality |
||
|- |
|- |
||
! {{anchor|REXX|[[REXX]]}} |
|||
! {{anchor|REXX|[[REXX]]}} ({{anchor|REXX|[[Classic REXX]]}}) |
|||
| [[dynamic programming|dynamic]], [[procedural programming|procedural]], [[functional programming|functional]] |
|||
<br><br> <small><tt> REXX (<u>Re</u>structured E<u>x</u>tended E<u>x</u>xecutor) is an interpreted computer programming language developed at IBM by Mike Cowlishaw circa 1979</tt></small> <br><br> |
|||
| {{yes|Yes, there is a standard, but some implementations don't adhere to it}} |
|||
| [[dynamic programming|dynamic]], [[procedural programming|procedural]], [[functional programming|functional]] |
|||
| strong |
|||
|<!-- Standardized --> {{yes|Yes. <br><br>There is a ANSI standard (X3.274-1996), but some REXX implementations don't adhere to it.}} |
|||
| safe |
|||
|<!-- Type strength --> strong |
|||
| inferred |
|||
|<!-- Type safety --> safe |
|||
| nominal |
|||
|<!-- Expression of types --> inferred |
|||
| dynamic |
|||
|<!-- Type compatibility --> nominal |
|||
| by value |
|||
|<!-- Type checking -->dynamic (but only when both comparands are numeric ''and'' non─strict comparisons are used) |
|||
| {{optional| garbage collection is allowed, but not mandated}} |
|||
|<!-- Parameter Passing --> by value |
|||
| general, application, algorithms, scripting, host/sub-system scripting/interfacing, data/text processing, programming as a human activity |
|||
|<!-- Garbage collection -->{{optional| garbage collection is allowed (and in most cases, automatic), but not mandated}} |
|||
| designed to make programming easier, to foster high quality programs by making writing them as simple and enjoyable as possible, designing each part of the language for people to use is more important than providing easy implementation; principle of least astonishment |
|||
|<!-- Intended use -->general, application, algorithms, calculations with extended precision (big numbers support), scripting, host/sub─system scripting/interfacing, data/text processing, programming as a human activity |
|||
|<!-- Design goals -->designed to make programming easier; to foster high quality programs by making writing them as simple and enjoyable as possible; designing each part of the language for people to use is more important than providing easy implementation; follows the principle of least astonishment [https://en.wikipedia.org/wiki/Principle_of_least_astonishment (POLA)]. |
|||
|- |
|- |
||
! {{anchor|Ruby|[[Ruby]]}} |
! {{anchor|Ruby|[[Ruby]]}} |
||
Line 958: | Line 1,397: | ||
|Expressiveness, Readability |
|Expressiveness, Readability |
||
|- |
|- |
||
! {{anchor|Rust|[[Rust]]}} |
|||
|[[concurrent programming|concurrent]], [[functional programming|functional]], [[imperative programming|imperative]], [[structured]], [[classless-objects|classless]], [[generic programming|generic]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|explicit, optionally inferred |
|||
|nominal |
|||
|static |
|||
|by value, by reference |
|||
|{{optional|resource acquisition is initialization (RAII), optional reference counting}} |
|||
|Application, System |
|||
|Highly concurrent and highly safe systems |
|||
|- |
|||
! {{anchor|Scala|[[Scala]]}} |
! {{anchor|Scala|[[Scala]]}} |
||
|[[object-oriented]], [[functional programming|functional]], [[generic programming|generic]] |
|[[object-oriented]], [[functional programming|functional]], [[generic programming|generic]] |
||
Line 971: | Line 1,427: | ||
|Concise, Type-safe, Integrate OO and functional paradigms, Scalable and Elegance. Platform independent |
|Concise, Type-safe, Integrate OO and functional paradigms, Scalable and Elegance. Platform independent |
||
|- |
|- |
||
! {{anchor|Scheme|[[Scheme]]}} |
! {{anchor|Scheme|[[Scheme]]}} |
||
|[[functional programming|functional]] |
|[[functional programming|functional]] |
||
Line 984: | Line 1,442: | ||
|Minimalistic, Lexical Scoping |
|Minimalistic, Lexical Scoping |
||
|- |
|- |
||
! {{anchor|Seed7|[[Seed7]]}} |
! {{anchor|Seed7|[[Seed7]]}} |
||
|extensible, [[object-oriented]], [[imperative programming|imperative]], structured, [[generic programming|generic]], [[reflective programming|reflective]] |
|extensible, [[object-oriented]], [[imperative programming|imperative]], structured, [[generic programming|generic]], [[reflective programming|reflective]] |
||
Line 997: | Line 1,457: | ||
|Extensibility, Portability, Reliability, Efficiency, Elegance |
|Extensibility, Portability, Reliability, Efficiency, Elegance |
||
|- |
|- |
||
! {{anchor|Sidef|[[Sidef]]}} |
! {{anchor|Sidef|[[Sidef]]}} |
||
|[[object-oriented]], [[imperative programming|imperative]], [[reflective programming|reflective]], [[dynamic programming|dynamic]], [[functional programming|functional]] |
|||
| |
|||
|{{no}} |
|||
| |
|||
|weak |
|weak |
||
|unsafe |
|||
| |
|||
|optional explicit |
|||
|implicit |
|||
|duck |
|||
| |
|||
|dynamic |
|dynamic |
||
|by value, by reference |
|by value (Call by object reference), by reference |
||
|{{optional|Reference counting}} |
|||
|{{no}} |
|||
|Application, Scripting, PL Research, Education |
|||
| |
|||
|Expressiveness, Elegance, Readability |
|||
| |
|||
|- |
|- |
||
! {{anchor|SkookumScript|[[SkookumScript]]}} |
|||
|[[concurrent programming|concurrent]], [[object-oriented]], [[functional programming|functional]], [[imperative programming|imperative]], [[generic programming|generic]] |
|||
|{{no|No, [http://skookumscript.com/docs/v3.0/lang/syntax/ online syntax] includes EBNF language specification}} |
|||
|strong |
|||
|safe |
|||
|inferred, optional explicit annotations |
|||
|nominal |
|||
|static |
|||
|by reference |
|||
|{{optional|Reference counting}} |
|||
|Embedded gameplay, AI, automation, scripting |
|||
|Game concepts, Interactivity, Live workflow, Efficiency, Embedded |
|||
|- |
|||
! {{anchor|Slate|[[Slate]]}} |
! {{anchor|Slate|[[Slate]]}} |
||
|[[object-oriented]], [[imperative programming|imperative]], [[functional programming|functional]], [[reflective programming|reflective]], prototype, multi-dispatch |
|[[object-oriented]], [[imperative programming|imperative]], [[functional programming|functional]], [[reflective programming|reflective]], prototype, multi-dispatch |
||
Line 1,023: | Line 1,502: | ||
|Uniformity, Pure object-oriented, expressiveness, readability |
|Uniformity, Pure object-oriented, expressiveness, readability |
||
|- |
|- |
||
! {{anchor|Smalltalk|[[Smalltalk]]}} |
! {{anchor|Smalltalk|[[Smalltalk]]}} |
||
|[[object-oriented]], [[concurrent programming|concurrent]], [[event-driven programming|event-driven]], [[imperative programming|imperative]], [[declarative programming|declarative]] |
|[[object-oriented]], [[concurrent programming|concurrent]], [[event-driven programming|event-driven]], [[imperative programming|imperative]], [[declarative programming|declarative]] |
||
Line 1,036: | Line 1,517: | ||
|Uniformity, Pure object oriented |
|Uniformity, Pure object oriented |
||
|- |
|- |
||
! {{anchor|SPARK|[[SPARK]]}} |
! {{anchor|SPARK|[[SPARK]]}} |
||
|[[concurrent programming|concurrent]], [[imperative programming|imperative]], [[object-oriented]] |
|[[concurrent programming|concurrent]], [[imperative programming|imperative]], [[object-oriented]] |
||
|{{no|No, but [http://docs.adacore.com/spark2014-docs/html/lrm/ Language Reference Manual] available.}} |
|||
|{{no|No, Language definition is proprietary - main copyright is held by [[http://www.sparkada.com/ Altran-Praxis]].}} |
|||
|strong |
|strong |
||
|safe |
|safe |
||
Line 1,049: | Line 1,532: | ||
|Logically sound, simple formal definition, expressive power, security, applications verifiable and have bounded space and time. |
|Logically sound, simple formal definition, expressive power, security, applications verifiable and have bounded space and time. |
||
|- |
|- |
||
! {{anchor|Standard ML|[[Standard ML]]}} |
! {{anchor|Standard ML|[[Standard ML]]}} |
||
|[[functional programming|functional]], [[imperative programming|imperative]], [[generic programming|generic]] |
|[[functional programming|functional]], [[imperative programming|imperative]], [[generic programming|generic]] |
||
Line 1,062: | Line 1,547: | ||
| |
| |
||
|- |
|- |
||
! {{anchor|Swift|[[Swift]]}} |
! {{anchor|Swift|[[Swift]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]] |
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]] |
||
Line 1,071: | Line 1,558: | ||
|static |
|static |
||
|by value |
|by value |
||
|{{ |
|{{optional|Reference counting}} |
||
|Application |
|Application |
||
|Compatibility with [[Objective-C]] runtime |
|Compatibility with [[Objective-C]] runtime |
||
|- |
|- |
||
! {{anchor|Tcl|[[Tcl]]}} |
! {{anchor|Tcl|[[Tcl]]}} |
||
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[event-driven programming|event-driven]], [[object-oriented]] <small>(native from Tcl 8.6 or via [http://wiki.tcl.tk/970 extensions] before that)</small> |
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[event-driven programming|event-driven]], [[object-oriented]] <small>(native from Tcl 8.6 or via [http://wiki.tcl.tk/970 extensions] before that)</small> |
||
Line 1,088: | Line 1,577: | ||
|[http://www.tcl.tk/about/history.html Extend, Embed and Integrate] |
|[http://www.tcl.tk/about/history.html Extend, Embed and Integrate] |
||
|- |
|- |
||
! {{anchor|TMG|[[TMG]]}} |
|||
| [[declarative programming|declarative]], data-driven, [[functional programming|functional]], unstructured |
|||
|{{no}} |
|||
|weak |
|||
|safe |
|||
|implicit |
|||
| |
|||
| |
|||
|by reference |
|||
| |
|||
|Compiler-compiler |
|||
|Creating compilers or translators (particularly, from a programming language to assembly) |
|||
|- |
|||
! {{anchor|Transd|[[Transd]]}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|explicit |
|||
|nominative |
|||
|static |
|||
|by reference |
|||
|{{yes}} |
|||
|Embedded, Application, Scripting, Education |
|||
|Simplicity; compact implementation. |
|||
|- |
|||
! {{anchor|Trith|[[Trith]]}} |
! {{anchor|Trith|[[Trith]]}} |
||
|[[functional programming|functional]], [[stack]]-oriented, [[concatenative programming|concatenative]] |
|[[functional programming|functional]], [[stack]]-oriented, [[concatenative programming|concatenative]] |
||
Line 1,101: | Line 1,620: | ||
|Simplicity, Expressiveness, Terseness, [http://linkeddata.org/ Linked Data] |
|Simplicity, Expressiveness, Terseness, [http://linkeddata.org/ Linked Data] |
||
|- |
|- |
||
! {{anchor|Unicon|[[Unicon]]}} |
! {{anchor|Unicon|[[Unicon]]}} |
||
| [[procedural programming|procedural]], [[structured]], [[Goal_directed_programming|goal directed]], [[string scanning]], [[co-expressions]], [[object-oriented]] |
| [[procedural programming|procedural]], [[structured]], [[Goal_directed_programming|goal directed]], [[string scanning]], [[co-expressions]], [[object-oriented]] |
||
Line 1,114: | Line 1,635: | ||
| Facilitates ease of programming, short concise programs, automatic storage allocation and management, provide a rich base of basic data types and structures, and platform independence . Unicon provides additional capabilities over [[#Icon|Icon]] integrating object oriented capabilities, messaging and external communications, event monitoring, and more in a consistent framework. |
| Facilitates ease of programming, short concise programs, automatic storage allocation and management, provide a rich base of basic data types and structures, and platform independence . Unicon provides additional capabilities over [[#Icon|Icon]] integrating object oriented capabilities, messaging and external communications, event monitoring, and more in a consistent framework. |
||
|- |
|- |
||
! {{anchor|V|[[V]]}} |
! {{anchor|V|[[V]]}} |
||
|[[functional programming|functional]], [[stack]]-oriented, [[concatenative programming|concatenative]] |
|[[functional programming|functional]], [[stack]]-oriented, [[concatenative programming|concatenative]] |
||
Line 1,127: | Line 1,650: | ||
|[[concatenative programming|concatenative]] |
|[[concatenative programming|concatenative]] |
||
|- |
|- |
||
! {{anchor|V_(Vlang)|[[V (Vlang)]]}} |
|||
|[[concurrent programming|concurrent]], [[imperative programming|imperative]], [[procedural programming|procedural]], [[structured]], [[classless-objects|classless]], [[functional programming|functional]], [[generic programming| generic]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|explicit, optionally inferred |
|||
|duck, structural |
|||
|<!-- Check -->static |
|||
|by value or by reference |
|||
|<!-- GC -->{{optional}} |
|||
|General, Application, Systems, GUI, Web, CLI, IT |
|||
|Simplicity, Readability, Usability, Portability, Modularity |
|||
|- |
|||
! {{anchor|Visual Basic|[[Visual Basic]]}} |
! {{anchor|Visual Basic|[[Visual Basic]]}} |
||
|component-oriented programming, [[event-driven programming|event-driven]] |
|component-oriented programming, [[event-driven programming|event-driven]] |
||
Line 1,140: | Line 1,678: | ||
|Rapid application development, Simplicity |
|Rapid application development, Simplicity |
||
|- |
|- |
||
! {{anchor|Visual Basic .NET|[[Visual Basic .NET]]}} |
! {{anchor|Visual Basic .NET|[[Visual Basic .NET]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]], [[functional programming|functional]], [[event-driven programming|event-driven]] |
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]], [[functional programming|functional]], [[event-driven programming|event-driven]] |
||
Line 1,148: | Line 1,688: | ||
|nominative |
|nominative |
||
|static, dynamic (for interop) |
|static, dynamic (for interop) |
||
|by value, by reference (through managed pointers [always in-out]) |
|||
|by reference, by value (both explicit) |
|||
|{{yes}} |
|{{yes}} |
||
|Application |
|Application |
||
|Rapid application development |
|Rapid application development |
||
|- |
|- |
||
! {{anchor|PowerShell|[[Windows PowerShell]]}} |
! {{anchor|PowerShell|[[Windows PowerShell]]}} |
||
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]], |
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]], pipeline, [[reflective programming|reflective]] |
||
|{{no}} |
|{{no}} |
||
|strong |
|strong |
||
Line 1,165: | Line 1,707: | ||
|Scripting |
|Scripting |
||
| |
| |
||
|- |
|||
! {{anchor|Wren|[[Wren]]}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]], [[concurrent programming|concurrent]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
|nominative |
|||
|dynamic |
|||
|by value |
|||
|{{yes}} |
|||
|Host-driven Scripting |
|||
|Lightweight, class-based, concurrent, easily embeddable |
|||
|- |
|||
|-class="sortbottom" |
|-class="sortbottom" |
||
![[Programming Language|Language]] |
![[Programming Language|Language]] |
||
Line 1,178: | Line 1,738: | ||
!Intended use |
!Intended use |
||
!Design goals |
!Design goals |
||
|- |
|||
|} |
|} |
||
==External resources== |
==External resources== |
||
* [[wp:Comparison_of_programming_languages|Wikipedia: Comparison of programming languages]] |
* [[wp:Comparison_of_programming_languages|Wikipedia: Comparison of programming languages]] |
Latest revision as of 00:04, 9 March 2024
See also TL;DR (Brief descriptions of languages).
Language | Paradigm(s) | Standardized | Type strength | Type safety | Expression of types | Type compatibility | Type checking | Parameter Passing Methods Available | Garbage collection | Intended use | Design goals |
---|---|---|---|---|---|---|---|---|---|---|---|
ACL2 | functional | Yes | strong | unsafe | implicit | dynamic | immutable reference | Yes | Theorem proving | Be logically sound, mimic Common Lisp | |
ActionScript | imperative, object-oriented,distributed | Yes, ECMA | strong | safe | static | Yes | Web design | ||||
Ada | concurrent, distributed, generic, imperative, object-oriented | Yes | strong | safe | explicit | nominative | static | by value, by reference (compiler chosen if not determined by the data type) | GC is allowed, but not mandated | Embedded, real-time, mission-critical, long-lived, and large scale systems | Reliability and maintenance, Programming as a human activity, Efficiency Language Reference Manual |
ALGOL 68 | concurrent, imperative | Yes, GOST 27974-88 | strong | safe | explicit | structural | static or dynamic (programmer chosen) | by value or by reference (programmer chosen) | Yes | Application | Completeness and clarity of design, Orthogonal design, Security, Efficiency (Static mode checking, Mode-independent parsing, Independent compilation, Loop optimization, Representations in minimal & larger character sets) |
ALGOL W | imperative | No | strong | safe | explicit | nominative | static or dynamic (programmer chosen) | by value, by reference or by name (programmer chosen) | Yes | Application, Education | |
AmbientTalk | concurrent | strong | safe | explicit | duck | dynamic | by value | Mobile ad hoc networks | |||
Arturo | generic, imperative, functional, reflective, stack-based | No, see official documentation | strong | implicit | dynamic | by value, by reference (literals) | Yes | General, Scripting, DSLs, Templating, Portable apps, GUI applications | Simplicity, Expressiveness, Portability | ||
AutoHotkey | imperative, classless | No | untyped | by value or by reference | No | End User Programming | simplicity, speed, stability | ||||
AutoIt | imperative | by value or by reference | General, scripting, GUI and tasks automation | Simplicity | |||||||
BASIC | procedural | Yes, ANSI, ISO | varies by dialect | varies by dialect | Education | Simplicity | |||||
Blade | imperative, object-oriented, functional | No | strong | safe | implicit | nominative | dynamic | by value, by reference (through pointers) | Yes | Scripting, Application | Simple, Lightweight, CLI, Web, Desktop, Mobile |
C | imperative | Yes, ANSI C89, ISO C90/C99 | weak | unsafe | explicit | nominative | static | by value, by reference (through pointers) | Optional through external tools | System, Embedded | Low level access, Minimal constraint |
C# | imperative, object-oriented, generic, reflective, functional, event-driven | Yes, ECMA, ISO | strong | safe (unsafe allowed) | implicit | nominative | static, dynamic (for interop) | by value, by reference (through managed pointers [explicitly in, out, or in-out]) | Yes | Application | Rapid application development |
C++ | imperative, object-oriented, generic | Yes, ISO C++98/C++11 | strong | safe (unsafe allowed) | explicit, partially implicit | nominative, structural | static, dynamic | by value, by reference (through reference types) | Optional through external tools | Application, System | Abstraction, Efficiency, Compatibility |
Chapel | concurrent, generic, object-oriented, imperative, distributed, reflective | No, still under development, a preliminary language specification exists | strong | safe | explicit, partially inferred | nominative | static | by value, by reference | No | High Performance Computing | Programmer productivity (compared to C/Fortran), performance |
Clean | functional, generic | No | strong | implicit | static | Yes | General | Correctness, Modularity | |||
Clojure | functional, concurrent | strong | safe | dynamic, static | Yes | ||||||
COBOL | imperative, object-oriented | Yes, ANSI 68, 74, 85 (and subsequent revisions); ECMA; ISO 1989:2023 (and previous version in 1978, 1985, 2002, 2014) | strong | safe | explicit | static | by value, by reference | No | Business and Financial Applications | Readability | |
ColdFusion | procedural, object-oriented | No | weak | implicit | dynamic | Web Development | Rapid Application Development, Ease of use | ||||
Common Lisp | imperative, functional, object-oriented | Yes | strong | safe | dynamic, static | Yes | General | Standardize Lisp | |||
D | imperative, object-oriented, generic | No | strong | safe | explicit, optional inferred | nominative, structural | static, dynamic | by value, by reference (through reference types) | Yes | Application, System | Compilability, Correctness, Efficiency |
Dao | object-oriented | strong | safe, unsafe allowed | implicit, explicit | static, dynamic | Yes | |||||
Dyalect | imperative, object-oriented, functional | No | strong | safe | implicit | duck | dynamic | by reference | Yes | Application | Portable dynamic scripting language with consistent design and modern syntax |
Dylan | imperative, object-oriented, functional, procedural | strong | safe | static, dynamic | Yes | ||||||
E | imperative, object-oriented, object-capability, communicating event loops | No
, still in development |
strong (runtime) | safe | optional explicit | duck | dynamic | by value | Yes | Secure collaboration, distributed systems, running untrusted applications, high-level "scripting" | Familiarity to C/Java/JS users; less error-prone concurrency & security |
eC | imperative, object-oriented, generic, reflective | No | weak | unsafe | explicit, partially implicit | nominative, complex conversions system | static, dynamic | according to data type, or explicitly by value, by reference | Reference counting | Applications, GUIs, System, Games | Elegance, Performance, Simplicity, Lightness, 99.9% C compatibility |
Ecstasy | object-oriented, generic, reflective, functional, imperative | No | strong | safe | explicit, optionally inferred | nominative; duck for interface types | static; dynamic for generic edge conditions | by value; by reference | Yes | Application | Predictable, Secure, Composable |
Eiffel | imperative, object-oriented, generic | Yes | strong | safe | nominative | static | Yes | Application | Correctness, Efficiency, Design by contract | ||
Ela | functional | No | strong | safe | implicit | duck | dynamic | by reference | Yes | Application | |
Elm | functional, functional reactive programming, declarative, pattern matching | No | strong | safe | inferred, optional explicit annotations | static | immutable data structures, syntactically by value, time-varying with Signals | Yes | Web Development, GUIs, Applications, Games | Simple, Modular, Safe, Reactive | |
Elena | object-oriented | strong | safe | implicit | dynamic | Yes | |||||
Erlang | functional, concurrent, distributed, declarative - pattern matching, imperative | No | strong | safe | implicit | dynamic | immutable data structures, syntactically by value but safe sharing of compound data types | Yes | Telecom and mission critical distributed applications | Fault tolerance, Reliability - Nonstop Running, Hot Code Change, Safety, Concurrency, Distribution, Scalability | |
ERRE | imperative, procedural | No | weak | unsafe | explicit | static and dynamic | by value | Yes | Education | Readability, Modularity | |
Factor | stack-oriented | No | safe | implicit | duck | dynamic | by reference | Yes | x | ||
Forth | imperative, stack-oriented | Yes, ANSI, ISO/IEC 15145:1997 | none | n/a | n/a | n/a | n/a | No | Applications, High reliability, Embedded systems, Booting new hardware. | Compact implementations, Low level access, Interactive programming, CPU agnostic Assembler Alternative, ultra-small memory systems. | |
Fortran | imperative, procedural, object-oriented, (partially) generic, concurrent | Yes | strong | safe | explicit, partially implicit | nominative | static, dynamic | by reference, or explicitly by value | No | Scientific and numeric applications | Runtime efficiency, Simple syntax |
FutureBasic | procedural | No | strong | nominative | static | by value, by reference (through pointers) | Yes | Educational, Scientific, Prototyping, Commercial Level Applications | Mac Freeware, Readability, Simplicity, Efficiency, C/Objective-C Compatibility, Objective-C Alternative, Builds Xcode Projects | ||
Gambas | object-oriented | No | strong | safe | explicit | dynamic | by value, by reference | Application, Scripting | Rapid application development, Visual Basic alternative | ||
Go | concurrent, classless | No
, language specification available |
strong | safe | explicit, optionally inferred | nominative; structural for interface types | static | by value | Yes | ||
Gosu | imperative, object-oriented, generic, functional | Yes | strong | safe | explicit, optionally inferred | nominative and structural | static | by value | Yes | Application | Open type system, optional dynamic loading |
Groovy | imperative, object-oriented, aspect-oriented | No | strong | safe | implicit | nominative | dynamic | Yes | Application | JVM compatibility | |
Haskell | functional, generic, lazy evaluation | Yes, Haskell 2010 Report, Haskell 98 Report | strong | safe | inferred, optional explicit annotations | polymorphic structural | static | Yes | Application, Research | lazy evaluation, Teaching and research, completely formally described Report Preface | |
Huginn | imperative, object-oriented, functional | No, language reference included with each version's documentation | strong | safe | implicit | dynamic | by reference | Reference counting | Education, Application, Scripting, Interactive system shell | Consistency, Simplicity, Readability, Expressiveness, Modularity | |
icon | procedural, structured, goal directed, string scanning, co-expressions | No | strong | Safe | implicit | nominative | dynamic | by value and safe reference depending if the type is mutable or immutable | Yes | Text analysis, text editing, document formatting, artificial intelligence, expert systems, rapid prototyping, symbolic mathematics, text generation, and data laundry | Facilitates ease of programming, short concise programs, automatic storage allocation and management, provide a rich base of basic data types and structures, and platform independence. Also see Unicon for the unified extended dialect of Icon. |
Insitux | functional, imperative | No | strong | safe | implicit | dynamic | by value | Yes | Host-driven scripting | Host-extensibility; provide "safe" modding e.g. timeout infinite loops, memory limits; concise code | |
Io | object-oriented, classless, prototype | No | strong | dynamic | Yes | ||||||
J | array programming, function-level programming, tacit | No | strong | safe | inferred | structural | dynamic | by value, by name, by address for memory mapped files (and, indirectly, for foreign languages) | Yes | Data processing, expressing concepts algorithms and architectures | Describe computers mathematically and concisely |
Java | imperative, object-oriented, generic, reflective | Yes, Java SE Specifications | strong | safe | explicit | nominative | static | by value | Yes | Application | Write once run anywhere |
JavaScript | imperative, object-oriented, classless, functional, reflective | Yes, ECMAScript standard | weak | implicit | dynamic | by value | Yes | Client side web scripting | |||
Joy | functional, stack-oriented | No | strong | safe | dynamic | functional research | concatenative | ||||
jq | functional, tacit (point-free), dataflow | No, but a de facto standard exists in the agreement between the C and Go-based versions | weak | safe | implicit | n.a. | dynamic | by value, with limited support for closures | Yes | Processing streams of JSON documents or strings; gojq also supports YAML | Turing-completeness; ease of use and economy of expression within functional/dataflow programming frameworks |
Kabap | imperative, dynamic, extensible | Yes | weak | unsafe | implicit | duck | dynamic | by value | User scripting, general | Safe sandboxed, easy to learn, easier to implement. Use to avoid eval() & reflection | |
Keg | imperative, concatenative | No | untyped | unsafe | implicit | nominative | dynamic | by reference | No | Code Golf, general | Be simple, readable, and concise |
Kotlin | imperative, object-oriented, | No | strong | safe | explicit, optionally inferred | nominative | static, dynamic (JS only) | by value (read-only) | Yes | Application | Pragmatic language for modern multi-platform applications with compilers for JVM, JS and Native code |
LDPL | imperative | No | strong | safe | explicit | static | No | Portable applications, readable source codes, teaching | Readability | ||
LFE | functional, concurrent, distributed, declarative - pattern matching, imperative | No | strong | safe | implicit | dynamic | immutable data structures, syntactically by value but safe sharing of compound data types | Yes | Telecom and distributed applications | Fault tolerance, Reliability - Nonstop Running, Hot Code Change, Safety, Concurrency, Distribution, Scalability | |
Lisp | functional, reflective; others vary by dialect | No | strong | dynamic | Yes | General | Simple notation for Lambda calculus, Homoiconicity | ||||
Logo | procedural, functional | No | strong | safe | implicit | structural | dynamic | Yes | Education | Simple syntax, Turtle graphics, Interactive programming | |
Lua | procedural, imperative, classless, reflective | No | strong | safe | implicit | dynamic | Yes | Host-driven Scripting | Small, embedded, configuration. | ||
Lucid | dataflow, functional | No | strong | safe | dynamic | stream processing | dataflow | ||||
Luck | imperative, functional | No | weak | unsafe | explicit, partially inferred | nominative | static | by value or by reference | Yes | systems programming | fast, C compatible, high-level language |
Mathematica | functional, procedural | No | strong | dynamic | Yes | Numeric and symbolic computation, visualization | |||||
MATLAB | procedural, imperative, array programming | No, however the language is also implemented in Octave and FreeMat | strong | unsafe | dynamic | by value | Yes | Numeric computation and visualization | At the beginning designed as interpreter for easy use of fortran libraries, nowadays high performance numerical analysis and visualization | ||
MAXScript | imperative, object-oriented, procedural | No | strong | safe | implicit | dynamic | by value, by reference | 3D Art Tools, Scripting | Simplicity, Accessibilty | ||
Modula-3 | imperative, object-oriented, procedural, generic | No | strong | safe (unsafe allowed) | explicit | structural | static | by value, by reference | Yes | Application, Systems | Simple, Object oriented |
MUMPS | procedural | Yes, ISO/IEC 11756:1999 | untyped | not applicable | by value, by reference | Yes | Built-in Persistent Storage | ||||
Nial | functional, array programming | No | strong | dynamic | Data processing | ||||||
Nim | procedural, functional, generic | No | strong | safe | explicit | nominative, structural | static | by value, by reference (through reference types) | Yes | General, Application, Systems, Games, Scripting, Web | Efficient, Expressive, Elegant in that order. |
Oberon-2 | procedural, imperative, object-oriented, classless | No | strong | safe | explicit | structural | static | by value, by reference | Yes | Teaching, System | Simplicity |
Objeck | object-oriented,functional | No | strong | safe | explicit | nominative | static | by value | Yes | General, Education | Minimalist, Cross-Platform, Modular |
Object Pascal (Delphi) | imperative, object-oriented, generic | No | strong | safe (unsafe allowed) | explicit | nominative | static, dynamic | by reference, by value | some types | Application, System | Readability, Rapid application development, Modularity |
Objective-C | imperative, object-oriented, reflective, generic (as of Xcode 7) | No | weak | explicit | static | by value | Yes (as of 2.0) | Application | Smalltalk like, Component based code reuse, C/C++ compatibility | ||
OCaml | object-oriented, functional, imperative, generic | No, the manual includes language specification | strong | safe | inferred, optional explicit annotations | polymorphic structural | static | by value | Yes | Application | Efficiency, Robustness, Correctness |
Oz | logic programming, functional, imperative, object-oriented, concurrent | No | strong | safe | implicit | structural | dynamic | by reference (though often immutable) | Yes | Application, Education, Distribution | |
PARI/GP | imperative, procedural | No | weak | unsafe | implicit | nominal | dynamic | by value, by reference | Yes | Mathematics, especially number theory | |
Pascal | imperative, procedural | ISO 7185:1990 and ISO 10206:1991 | strong | safe | explicit | static (some dialects also dynamic) | by reference, by value | No | General, Application, Education, System | Readability, Discipline, Modularity | |
Perl | imperative, procedural, reflective, functional, object-oriented, generic | No | weak | implicit | dynamic, static | by reference | Reference counting | Text processing, Scripting | Terseness, Expressiveness | ||
Phix | imperative, procedural, object-oriented | No | strong | safe | explicit, partially implicit | duck | dynamic, static | copy on write, immutable reference, multiple returns | Reference counting or JavaScript compatible | Application, Educational, General, High-level scripting, Text processing | Simplicity, Readability, Ease of use |
PHP | imperative, object-oriented, reflective | No | weak | dynamic | by value, by reference | Yes | Web Application, CLI | Robustness and Simplicity | |||
Pike | imperative, procedural, functional, object-oriented, reflective, event-driven | No | strong | safe | explicit | structural | dynamic, static | by value, by reference | Yes | Application, scripting | optimized execution, efficient networking |
Plain English | imperative, procedural | No | strong | safe | explicit | nominative | static | by reference | No | Application, Education, General | Ease of use, Expressiveness, Readability, Simplicity |
Pop11 | imperative, object-oriented, functional | No | strong | safe | implicit | dynamic | Yes | Application, Education | |||
Prolog | logic programming | Yes, ISO | strong | dynamic | Yes | Problem solving, Artificial intelligence | declarative | ||||
Pure | dynamic, functional | strong | structural | dynamic | Yes | ||||||
Python | imperative, object-oriented, functional, aspect-oriented, reflective | No, language reference included with each version's documentation | strong | safe | implicit | dynamic | by value (Call by object reference) | Yes | Application, Education, Scripting | Simplicity, Readability, Expressiveness, Modularity | |
R | functional, imperative, reflective, array | No | strong | safe | implicit | Duck, structural | dynamic | value by need, by name (programmer chosen) | Yes | Statistics, Numerical computation, Visualization, Education | Expressiveness, interactive manipulation and analysis of datasets |
Ra | object-oriented | No | dynamic or static | safe | implicit or explicit | dynamic or static | Yes | General | Program in native language, clean and clear syntax, extensive standard library, convenience | ||
Racket | functional, imperative, object-oriented, reflective | No | strong | safe | implicit or explicit (see Typed Racket) | dynamic or static | by value | Yes | General | Extensibility, Simplicity, Modularity | |
RapidQ | imperative, component-oriented programming, event-driven | No | strong (none for Variant type) | safe | static | by reference, by value | Application | Rapid application development, Simplicity, BASIC compatibility | |||
Raku (formerly Perl 6) | imperative, procedural, reflective, functional, object-oriented, generic, lazy evaluation, multiple dispatch, metaprogramming | No. The Repository Of All Spec Tests (aka 'roast') defines the language | strong | safe, unsafe | optional explicit | nominal (duck and structural available via constraints, patterns, generics, and gradual typing) | dynamic, static | by value, by reference | Yes | Application, text processing, scripting | Expressiveness, generality |
REXX (Classic REXX)
|
dynamic, procedural, functional | Yes. There is a ANSI standard (X3.274-1996), but some REXX implementations don't adhere to it. |
strong | safe | inferred | nominal | dynamic (but only when both comparands are numeric and non─strict comparisons are used) | by value | garbage collection is allowed (and in most cases, automatic), but not mandated | general, application, algorithms, calculations with extended precision (big numbers support), scripting, host/sub─system scripting/interfacing, data/text processing, programming as a human activity | designed to make programming easier; to foster high quality programs by making writing them as simple and enjoyable as possible; designing each part of the language for people to use is more important than providing easy implementation; follows the principle of least astonishment (POLA). |
Ruby | imperative, object-oriented, functional, reflective | Yes, JIS X 3017 (2011), ISO/IEC 30170 (2012) | strong | implicit | dynamic | by value (Call by object reference) | Yes | Application, Scripting | Expressiveness, Readability | ||
Rust | concurrent, functional, imperative, structured, classless, generic | No | strong | safe | explicit, optionally inferred | nominal | static | by value, by reference | resource acquisition is initialization (RAII), optional reference counting | Application, System | Highly concurrent and highly safe systems |
Scala | object-oriented, functional, generic | Yes, The Scala Language Specification Version 2.9 | strong | safe | partially implicit | nominative, structural | static | by value, by name | Yes | General, Education, Parallel computing, DSL and scripting. | Concise, Type-safe, Integrate OO and functional paradigms, Scalable and Elegance. Platform independent |
Scheme | functional | Yes, R5RS, R6RS | strong | safe | implicit | dynamic (latent) | by value | Yes | General, Education | Minimalistic, Lexical Scoping | |
Seed7 | extensible, object-oriented, imperative, structured, generic, reflective | No | strong | safe | explicit | nominative | static | by value, by reference, by name | Yes (no garbage collection process that stops the world) | General, Application, System | Extensibility, Portability, Reliability, Efficiency, Elegance |
Sidef | object-oriented, imperative, reflective, dynamic, functional | No | weak | unsafe | optional explicit | duck | dynamic | by value (Call by object reference), by reference | Reference counting | Application, Scripting, PL Research, Education | Expressiveness, Elegance, Readability |
SkookumScript | concurrent, object-oriented, functional, imperative, generic | No, online syntax includes EBNF language specification | strong | safe | inferred, optional explicit annotations | nominal | static | by reference | Reference counting | Embedded gameplay, AI, automation, scripting | Game concepts, Interactivity, Live workflow, Efficiency, Embedded |
Slate | object-oriented, imperative, functional, reflective, prototype, multi-dispatch | No | strong | safe | implicit, optional | structural (aka duck) | dynamic | by reference | Yes | Application, Embedded, Scripting | Uniformity, Pure object-oriented, expressiveness, readability |
Smalltalk | object-oriented, concurrent, event-driven, imperative, declarative | Yes, ANSI | strong | safe | implicit | protocol (aka duck) | dynamic | by value (Call by object reference) | Yes | Application, Education | Uniformity, Pure object oriented |
SPARK | concurrent, imperative, object-oriented | No, but Language Reference Manual available. | strong | safe | explicit | nominative | static | by value, by reference | Allowed | High integrity applications | Logically sound, simple formal definition, expressive power, security, applications verifiable and have bounded space and time. |
Standard ML | functional, imperative, generic | Yes, SML '97 | strong | safe | inferred, optional explicit annotations | polymorphic structural | static | by value | Yes | ||
Swift | imperative, object-oriented, generic | No | strong | inferred, optional explicit annotations | nominative | static | by value | Reference counting | Application | Compatibility with Objective-C runtime | |
Tcl | imperative, procedural, event-driven, object-oriented (native from Tcl 8.6 or via extensions before that) | No | weak | safe | implicit | duck | dynamic | by value (also by name and by reference through passing of variable names and upvar command)
|
Only of unnamed entities, e.g., values | Embedded, Application, Scripting | Extend, Embed and Integrate |
TMG | declarative, data-driven, functional, unstructured | No | weak | safe | implicit | by reference | Compiler-compiler | Creating compilers or translators (particularly, from a programming language to assembly) | |||
Transd | imperative, object-oriented, functional | No | strong | safe | explicit | nominative | static | by reference | Yes | Embedded, Application, Scripting, Education | Simplicity; compact implementation. |
Trith | functional, stack-oriented, concatenative | No | strong | safe | implicit | duck | dynamic | by value | Yes | Embedded, Application, Scripting, Education | Simplicity, Expressiveness, Terseness, Linked Data |
Unicon | procedural, structured, goal directed, string scanning, co-expressions, object-oriented | No | strong | Safe | implicit | nominative | dynamic | by value and safe reference depending if the type is mutable or immutable | Yes | Text analysis, text editing, document formatting, artificial intelligence, expert systems, rapid prototyping, symbolic mathematics, text generation, and data laundry. | Facilitates ease of programming, short concise programs, automatic storage allocation and management, provide a rich base of basic data types and structures, and platform independence . Unicon provides additional capabilities over Icon integrating object oriented capabilities, messaging and external communications, event monitoring, and more in a consistent framework. |
V | functional, stack-oriented, concatenative | No | strong | safe | dynamic | functional research | concatenative | ||||
V (Vlang) | concurrent, imperative, procedural, structured, classless, functional, generic | No | strong | safe | explicit, optionally inferred | duck, structural | static | by value or by reference | Optional | General, Application, Systems, GUI, Web, CLI, IT | Simplicity, Readability, Usability, Portability, Modularity |
Visual Basic | component-oriented programming, event-driven | No | strong | safe | nominative | static | by reference, by value (explicit) | Yes | Application | Rapid application development, Simplicity | |
Visual Basic .NET | imperative, object-oriented, generic, reflective, functional, event-driven | No | strong | safe | implicit | nominative | static, dynamic (for interop) | by value, by reference (through managed pointers [always in-out]) | Yes | Application | Rapid application development |
Windows PowerShell | imperative, object-oriented, functional, pipeline, reflective | No | strong | safe | implicit | dynamic | Scripting | ||||
Wren | imperative, object-oriented, functional, concurrent | No | strong | safe | implicit | nominative | dynamic | by value | Yes | Host-driven Scripting | Lightweight, class-based, concurrent, easily embeddable |
Language | Paradigm(s) | Standardized | Type strength | Type safety | Expression of types | Type compatibility | Type checking | Parameter Passing Methods Available | Garbage collection | Intended use | Design goals |