Language Comparison Table: Difference between revisions
Content deleted Content added
No edit summary |
Added Plain English |
||
(137 intermediate revisions by 60 users not shown) | |||
Line 1:
[[Category:Encyclopedia]]
See also [[TL;DR]] (Brief descriptions of languages).
{|class="wikitable sortable"
![[:Category:Programming Languages|Language]]
Line 14 ⟶ 16:
!Design goals
|-
! {{anchor|ACL2|[[ACL2]]}}
|[[functional programming|functional]]
|{{yes}}
|strong
|unsafe
|implicit
|
|dynamic
|immutable reference
|{{yes}}
|Theorem proving
|Be logically sound, mimic Common Lisp
|-
! {{anchor|ActionScript|[[ActionScript]]}}
|[[imperative programming|imperative]], [[object-oriented]],[[:Category:Programming paradigm/Distributed|distributed]]
|{{yes
|strong
|safe
Line 27 ⟶ 46:
|
|-
! {{anchor|Ada|[[Ada]]}}
|[[concurrent programming|concurrent]], [[:Category:Programming paradigm/Distributed|distributed]], [[generic programming|generic]], [[imperative programming|imperative]], [[object-oriented]]
|{{yes
|strong
|safe
Line 40 ⟶ 61:
|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]]}}
|[[concurrent programming|concurrent]], [[imperative programming|imperative]]
|{{yes
|strong
|safe
|explicit
Line 53 ⟶ 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)
|-
! {{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]]}}
|[[concurrent programming|concurrent]]
Line 66 ⟶ 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]]}}
|[[imperative programming|imperative]], [[classless-objects|classless]]
|{{no}}
|untyped
Line 79 ⟶ 136:
|simplicity, speed, stability
|-
! {{anchor|AutoIt|[[AutoIt]]}}
|[[imperative programming|imperative]]
|
|
|
|
|
|
|by value or by reference
|
|General, scripting, GUI and tasks automation
|Simplicity
|-
! {{anchor|BASIC|[[BASIC]]}}
|[[procedural programming|procedural]]
|{{yes
|varies by dialect
|
Line 92 ⟶ 166:
|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]]}}
|[[imperative programming|imperative]]
|{{yes
|weak
|unsafe
Line 105 ⟶ 196:
|Low level access, Minimal constraint
|-
! {{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]]
|{{yes
|strong
|safe (unsafe allowed)
Line 113 ⟶ 206:
|nominative
|static, dynamic (for interop)
|by value, by reference (through managed pointers [explicitly in, out, or in-out])
|{{yes}}
|Application
|Rapid application development
|-
! {{anchor|C++|[[C++]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]]
|{{yes
|strong
|safe (unsafe allowed)
Line 131 ⟶ 226:
|Abstraction, Efficiency, Compatibility
|-
! {{anchor|Chapel|[[Chapel]]}}
|[[concurrent]], [[generic programming|generic]], [[object-oriented]], [[imperative programming|imperative]], [[:Category:Programming paradigm/Distributed|distributed]], [[reflective programming|reflective]]
|{{no|No, still under development, a [http://chapel.cray.com/spec/spec-0.93.pdf 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
|-
! {{anchor|Clean|[[Clean]]}}
|[[functional programming|functional]], [[generic programming|generic]]
Line 144 ⟶ 256:
|Correctness, Modularity
|-
! {{anchor|Clojure|[[Clojure]]}}
|[[functional programming|functional]], [[concurrent programming|concurrent]]
Line 157 ⟶ 271:
|
|-
! {{anchor|COBOL|[[COBOL]]}}
|[[imperative programming|imperative]], [[object-oriented]]
|{{yes|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
|-
! {{anchor|ColdFusion|[[ColdFusion]]}}
|[[procedural programming|procedural]], [[object-oriented]]
Line 183 ⟶ 301:
|Rapid Application Development, Ease of use
|-
! {{anchor|Common Lisp|[[Common Lisp]]}}
|[[imperative programming|imperative]], [[functional programming|functional]], [[object-oriented]]
Line 196 ⟶ 316:
|Standardize [[Lisp]]
|-
! {{anchor|D|[[D]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]]
Line 209 ⟶ 331:
|Compilability, Correctness, Efficiency
|-
! {{anchor|Dao|[[Dao]]}}
|[[object-oriented]]
Line 222 ⟶ 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]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]], [[procedural programming|procedural]]
Line 235 ⟶ 375:
|
|-
! {{anchor|E|[[E]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[object-capability]], [[communicating event loops]]
Line 248 ⟶ 390:
|<!-- Design goals -->Familiarity to [[C]]/[[Java]]/[[JavaScript|JS]] users; less error-prone concurrency & security
|-
! {{anchor|EC|[[eC]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]]
Line 261 ⟶ 405:
|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]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]]
|{{yes
|strong
|safe
Line 275 ⟶ 436:
|-
! {{anchor|Ela|[[Ela]]}}
|[[functional programming|functional]]
Line 283 ⟶ 446:
|duck
|dynamic
|by
|{{yes}}
|Application
Line 289 ⟶ 452:
|-
|-
! {{anchor|Elm|[[Elm]]}}
|[[functional programming|functional]], functional reactive programming, [[declarative 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
|-
|-
! {{anchor|Elena|[[Elena]]}}
|[[object-oriented]]
Line 305 ⟶ 485:
|
|-
! {{anchor|Erlang|[[Erlang]]}}
|[[functional programming|functional]], [[concurrent programming|concurrent]], [[:Category:Programming paradigm/Distributed|distributed]], [[declarative programming|declarative]] - pattern matching, [[imperative programming|imperative]]
Line 315 ⟶ 497:
|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
|-
! {{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]]}}
|[[stack]]-oriented
|<!-- Std -->{{no}}
|<!-- Strength -->
|<!-- Safety -->safe
|<!-- Expr -->implicit
|<!-- Compat -->duck
|<!-- Check -->dynamic
|<!-- Passing -->by reference
|<!-- GC -->{{yes}}
|<!-- Uses -->
|<!-- Design goals -->x
|-
! {{anchor|Forth|[[Forth]]}}
|[[imperative programming|imperative]], [[stack]]-oriented
|{{yes|Yes, [[ANSI]], [https://www.iso.org/standard/26479.html ISO/IEC 15145:1997]}}
|none
|n/a
Line 341 ⟶ 542:
|
|{{no}}
|
|Compact implementations, Low level access, Interactive programming, CPU agnostic Assembler Alternative, ultra-small memory systems.
|-
! {{anchor|Fortran|[[Fortran]]}}
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[object-oriented]], (partially) [[generic programming|generic]], [[concurrent programming|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
|-
! {{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]]}}
|[[object-oriented|object-oriented]]
Line 370 ⟶ 590:
|<!-- Design goals -->Rapid application development, Visual Basic alternative
|-
! {{anchor|Go|[[Go]]}}
|[[concurrent programming|concurrent]], [[classless-objects|classless]]
|<!-- Std -->{{no}}, [http://golang.org/
|<!-- Strength -->strong
|<!-- Safety -->safe
|<!-- Expr -->explicit, optionally inferred
|<!-- Compat -->nominative; structural for interface types
|<!-- Check -->static
|<!-- Passing -->by value
Line 383 ⟶ 605:
|<!-- 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]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[
|{{no}}
|strong
Line 396 ⟶ 635:
|[[JVM]] compatibility
|-
! {{anchor|Haskell|[[Haskell]]}}
|[[functional programming|functional]], [[generic programming|generic]], [[lazy evaluation]]
|{{yes
|strong
|safe
Line 409 ⟶ 650:
|[[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]]}}
| [[procedural programming|procedural]], [[structured]], [[Goal_directed_programming|goal directed]], [[string scanning]], [[co-expressions]]
Line 422 ⟶ 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.
|-
! {{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]]}}
|[[object-oriented]], [[classless-objects|classless]], prototype
|{{no}}
|strong
Line 435 ⟶ 706:
|
|-
! {{anchor|J|[[J]]}}
|[[array]] programming, function-level programming, [[tacit programming|tacit]]
Line 448 ⟶ 721:
|Describe computers mathematically and concisely
|-
! {{anchor|Java|[[Java]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]]
|{{
|strong
|safe
Line 461 ⟶ 736:
|Write once run anywhere
|-
! {{anchor|JavaScript|[[JavaScript]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[classless-objects|classless]], [[functional programming|functional]], [[reflective programming|reflective]]
|{{yes|Yes, [[ECMAScript standard]]}}
|weak
|
Line 469 ⟶ 746:
|
|dynamic
|by value
|{{yes}}
|Client side web scripting
|
|-
! {{anchor|Joy|[[Joy]]}}
|[[functional programming|functional]], [[stack]]-oriented
Line 487 ⟶ 766:
|[[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]]}}
|[[functional programming|functional]], [[concurrent programming|concurrent]], [[:Category:Programming paradigm/Distributed|distributed]], [[declarative programming|declarative]] - pattern matching, [[imperative programming|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
|-
! {{anchor|Lisp|[[Lisp]]}}
|[[functional programming|functional]], [[reflective programming|reflective]]; others vary by dialect
Line 500 ⟶ 872:
|Simple notation for Lambda calculus, Homoiconicity
|-
! {{anchor|Logo|[[Logo]]}}
|[[procedural programming|procedural]], [[functional programming|functional]]
Line 513 ⟶ 887:
|Simple syntax, Turtle graphics, Interactive programming
|-
! {{anchor|Lua|[[Lua]]}}
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[classless-objects|classless]], [[reflective programming|reflective]]
|{{no}}
|strong
Line 526 ⟶ 902:
|Small, embedded, configuration.
|-
! {{anchor|Lucid|[[Lucid]]}}
|[[dataflow programming|dataflow]], [[functional programming|functional]]
Line 539 ⟶ 917:
|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]]}}
|[[functional programming|functional]], [[procedural programming|procedural]]
Line 549 ⟶ 944:
|
|{{yes}}
|Numeric
|
|-
! {{anchor|MATLAB|[[MATLAB]]}}
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[array]] programming
|{{no|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
|-
! {{anchor|MAXScript|[[MAXScript]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[procedural programming|procedural]]
Line 565 ⟶ 977:
|Simplicity, Accessibilty
|-
! {{anchor|Modula-3|[[Modula-3]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[procedural programming|procedural]], [[generic programming|generic]]
Line 578 ⟶ 992:
|Simple, Object oriented
|-
! {{anchor|MUMPS|[[MUMPS]]}}
|[[procedural programming|procedural]]
|{{yes|Yes, [https://www.iso.org/standard/29268.html ISO/IEC 11756:1999]}}
|untyped
|not applicable
Line 591 ⟶ 1,007:
|Built-in Persistent Storage
|-
! {{anchor|Nial|[[Nial]]}}
|[[functional programming|functional]], [[array]] programming
Line 604 ⟶ 1,022:
|
|-
! {{anchor|Nim|[[Nim]]}}
|[[procedural programming|procedural]], [[functional programming|functional]], [[generic programming|generic]]
|{{no}}
|strong
|safe
|explicit
|nominative, structural
|static
|by value, by reference (through reference types)
|{{Yes}}
|General, Application, Systems, Games, Scripting, Web
|Efficient,
|-
! {{anchor|Oberon-2|[[Oberon-2]]}}
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[object-oriented]], [[classless-objects|classless]]
|{{no}}
|strong
Line 630 ⟶ 1,052:
|Simplicity
|-
! {{anchor|Objeck|[[Objeck]]}}
|[[object-oriented]],[[functional programming|functional]]
Line 643 ⟶ 1,067:
|Minimalist, Cross-Platform, Modular
|-
! {{anchor|Object Pascal|[[Object Pascal]]}} ({{anchor|Delphi|[[Delphi]]}})
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]]
Line 650 ⟶ 1,076:
|explicit
|nominative
|static, dynamic
|by reference, by value
|{{optional|some types}}
|Application, System
|Readability, Rapid application development, Modularity
|-
! {{anchor|Objective-C|[[Objective-C]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[reflective programming|reflective]], [[generic programming|generic]] (as of Xcode 7)
|{{no}}
|weak
Line 664 ⟶ 1,092:
|
|static
|by value
|{{yes
|Application
|[[Smalltalk]] like, Component based code reuse, [[C]]/[[C++]] compatibility
|-
! {{anchor|OCaml|[[OCaml]]}}
|[[object-oriented]], [[functional programming|functional]], [[imperative programming|imperative]], [[generic programming|generic]]
|{{no
|strong
|safe
Line 682 ⟶ 1,112:
|Efficiency, Robustness, Correctness
|-
! {{anchor|Oz|[[Oz]]}}
|logic programming, [[functional programming|functional]], [[imperative programming|imperative]], [[object-oriented]], [[concurrent programming|concurrent]]
Line 695 ⟶ 1,127:
|
|-
! {{anchor|PARI/GP|[[PARI/GP]]}}
|[[imperative programming|imperative]], [[procedural programming|procedural]]
Line 708 ⟶ 1,142:
|
|-
! {{anchor|Pascal|[[Pascal]]}}
|[[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]}}
|strong
|safe
|explicit
|
|static (some dialects also dynamic)
|by
|{{no}}
|General, Application, Education, System
|Readability, Discipline, Modularity
|-
! {{anchor|Perl|[[Perl]]}}
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[reflective programming|reflective]], [[functional programming|functional]], [[object-oriented]], [[generic programming|generic]]
Line 734 ⟶ 1,172:
|Terseness, Expressiveness
|-
! {{anchor|Phix|[[Phix]]}}
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[object-oriented]]
|<!-- Std -->{{no}}
|<!-- Strength -->strong
|<!-- Safety -->safe
|<!-- Expr -->explicit, partially implicit
|<!-- 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]]
Line 760 ⟶ 1,202:
|Robustness and Simplicity
|-
! {{anchor|Pike|[[Pike]]}}
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[functional programming|functional]], [[object-oriented]], [[reflective programming|reflective]], [[event-driven programming|event-driven]]
|{{no}}
|strong
|safe
|explicit
|structural
|dynamic, static
|by value, by reference
|{{yes}}
|Application, scripting
|optimized execution, efficient networking
|-
! {{anchor|Plain English|[[Plain English]]}}
|[[imperative programming|imperative]], [[procedural programming|procedural]]
|{{no}}
|strong
|safe
|explicit
|nominative
|static
|by reference
|{{no}}
|Application, Education, General
|Ease of use, Expressiveness, Readability, Simplicity
|-
! {{anchor|Pop11|[[Pop11]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]]
Line 773 ⟶ 1,247:
|
|-
! {{anchor|Prolog|[[Prolog]]}}
|logic programming
|{{yes
|strong
|
Line 786 ⟶ 1,262:
|[[declarative programming|declarative]]
|-
!{{anchor|Pure|[[Pure]]}}
|[[dynamic programming|dynamic]], [[functional programming|functional]]
Line 799 ⟶ 1,277:
|
|-
! {{anchor|Python|[[Python]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]], [[
|{{no
|strong
|safe
Line 812 ⟶ 1,292:
|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]]}}
|[[functional programming|functional]], [[imperative programming|imperative]], [[object-oriented]], [[reflective programming|reflective]]
|{{no}}
|strong
|safe
|implicit or explicit (see [http://docs.racket-lang.org/ts-guide/index.html Typed Racket])
|
|dynamic or static
|by value
|{{yes}}
|General
|Extensibility, Simplicity, Modularity
|-
! {{anchor|RapidQ|[[RapidQ]]}}
|[[imperative programming|imperative]], component-oriented programming, [[event-driven programming|event-driven]]
Line 825 ⟶ 1,352:
|Rapid application development, Simplicity, [[BASIC]] compatibility
|-
! {{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]}}
|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
|-
! {{anchor|REXX|[[REXX]]}} ({{anchor|REXX|[[Classic REXX]]}})
<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>
| [[dynamic programming|dynamic]], [[procedural programming|procedural]], [[functional programming|functional]]
|<!-- Standardized --> {{yes|Yes. <br><br>There is a ANSI standard (X3.274-1996), but some REXX implementations don't adhere to it.}}
|<!-- Type strength --> strong
|<!-- Type safety --> safe
|<!-- Expression of types --> inferred
|<!-- Type compatibility --> nominal
|<!-- Type checking -->dynamic (but only when both comparands are numeric ''and'' non─strict comparisons are used)
|<!-- Parameter Passing --> by value
|<!-- Garbage collection -->{{optional| garbage collection is allowed (and in most cases, automatic), but not mandated}}
|<!-- 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]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]], [[reflective programming|reflective]]
|{{yes|Yes, JIS X 3017 (2011), ISO/IEC 30170 (2012)}}
|strong
|
Line 838 ⟶ 1,397:
|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]]}}
|[[object-oriented]], [[functional programming|functional]], [[generic programming|generic]]
|{{yes|Yes, [http://www.scala-lang.org/docu/files/ScalaReference.pdf The Scala Language Specification Version 2.9]}}
|strong
|safe
Line 848 ⟶ 1,424:
|by value, by name
|{{yes}}
|General, Education, Parallel computing, DSL and scripting.
|
|-
! {{anchor|Scheme|[[Scheme]]}}
|[[functional programming|functional]]
|{{yes
|strong
|safe
Line 864 ⟶ 1,442:
|Minimalistic, Lexical Scoping
|-
! {{anchor|Seed7|[[Seed7]]}}
|extensible, [[object-oriented]], [[imperative programming|imperative]], structured, [[generic programming|generic]], [[reflective programming|reflective]]
|{{no}}
|strong
|safe
|explicit
|nominative
|static
|by value, by reference, by name
|{{yes|Yes (no garbage collection process that stops the world)}}
|General, Application, System
|Extensibility, Portability, Reliability, Efficiency, Elegance
|-
! {{anchor|Sidef|[[Sidef]]}}
|[[object-oriented]], [[imperative programming|imperative]], [[reflective programming|reflective]], [[dynamic programming|dynamic]], [[functional programming|functional]]
|{{no}}
|weak
|unsafe
|optional explicit
|duck
|dynamic
|by value (Call by object reference), by reference
|{{optional|Reference counting}}
|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]]}}
|[[object-oriented]], [[imperative programming|imperative]], [[functional programming|functional]], [[reflective programming|reflective]], prototype, multi-dispatch
Line 877 ⟶ 1,502:
|Uniformity, Pure object-oriented, expressiveness, readability
|-
! {{anchor|Smalltalk|[[Smalltalk]]}}
|[[object-oriented]], [[concurrent programming|concurrent]], [[event-driven programming|event-driven]], [[imperative programming|imperative]], [[declarative programming|declarative]]
|{{yes
|strong
|safe
|implicit
|protocol (aka duck)
|dynamic
|by value (Call by object reference)
Line 890 ⟶ 1,517:
|Uniformity, Pure object oriented
|-
! {{anchor|SPARK|[[SPARK]]}}
|[[concurrent programming|concurrent]], [[imperative programming|imperative]], [[object-oriented]]
|{{no|No, but [http://docs.adacore.com/spark2014-docs/html/lrm/ Language Reference Manual] available.}}
|strong
|safe
Line 903 ⟶ 1,532:
|Logically sound, simple formal definition, expressive power, security, applications verifiable and have bounded space and time.
|-
! {{anchor|Standard ML|[[Standard ML]]}}
|[[functional programming|functional]], [[imperative programming|imperative]], [[generic programming|generic]]
|{{yes
|strong
|safe
Line 916 ⟶ 1,547:
|
|-
! {{anchor|Swift|[[Swift]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]]
|{{no}}
|strong
|
|inferred, optional explicit annotations
|nominative
|static
|by value
|{{optional|Reference counting}}
|Application
|Compatibility with [[Objective-C]] runtime
|-
! {{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>
Line 929 ⟶ 1,577:
|[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]]}}
|[[functional programming|functional]], [[stack]]-oriented, [[concatenative programming|concatenative]]
Line 942 ⟶ 1,620:
|Simplicity, Expressiveness, Terseness, [http://linkeddata.org/ Linked Data]
|-
! {{anchor|Unicon|[[Unicon]]}}
| [[procedural programming|procedural]], [[structured]], [[Goal_directed_programming|goal directed]], [[string scanning]], [[co-expressions]], [[object-oriented]]
Line 955 ⟶ 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.
|-
! {{anchor|V|[[V]]}}
|[[functional programming|functional]], [[stack]]-oriented, [[concatenative programming|concatenative]]
Line 968 ⟶ 1,650:
|[[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]]}}
|component-oriented programming, [[event-driven programming|event-driven]]
Line 981 ⟶ 1,678:
|Rapid application development, Simplicity
|-
! {{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]]
Line 989 ⟶ 1,688:
|nominative
|static, dynamic (for interop)
|by value, by reference (through managed pointers [always in-out])
|{{yes}}
|Application
|Rapid application development
|-
! {{anchor|PowerShell|[[Windows PowerShell]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]],
|{{no}}
|strong
Line 1,006 ⟶ 1,707:
|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"
![[Programming Language|Language]]
Line 1,019 ⟶ 1,738:
!Intended use
!Design goals
|-
|}
==External resources==
* [[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 |