Language Comparison Table: Difference between revisions
Content deleted Content added
No edit summary |
Added Plain English |
||
(256 intermediate revisions by more than 100 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 paradigm|Paradigm(s)]] |
||
! |
!Standardized |
||
! |
![[Type strength]] |
||
! |
![[Type safety]] |
||
! |
!Expression of types |
||
! |
![[Type compatibility]] |
||
! |
![[Type checking]] |
||
! |
![[Parameter Passing]] Methods Available |
||
![[Garbage collection]] |
|||
! Intended use |
|||
!Intended use |
|||
! Design goals |
|||
!Design goals |
|||
|- |
|- |
||
! [[ActionScript]] |
|||
| [[imperative programming]], [[object-oriented]], [[event-driven programming]] |
|||
! {{anchor|ACL2|[[ACL2]]}} |
|||
|[[functional programming|functional]] |
|||
| strong |
|||
|{{yes}} |
|||
| safe |
|||
|strong |
|||
| |
|||
|unsafe |
|||
| |
|||
|implicit |
|||
| static |
|||
| |
| |
||
|dynamic |
|||
| Web design |
|||
|immutable reference |
|||
| |
|||
|{{yes}} |
|||
|Theorem proving |
|||
|Be logically sound, mimic Common Lisp |
|||
|- |
|- |
||
! [[Ada]] |
|||
| [[concurrent programming|concurrent]], [[distributed programming]], [[generic programming]], [[imperative programming]], [[object-oriented]] |
|||
! {{anchor|ActionScript|[[ActionScript]]}} |
|||
| {{yes}}, [[ANSI]], [[ISO]], ANSI/MIL-STD-1815A-1983, [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=22983 ISO/IEC 8652], [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=38828 ISO/IEC TR 24718], [http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27831-88.pdf GOST 27831-88] |
|||
|[[imperative programming|imperative]], [[object-oriented]],[[:Category:Programming paradigm/Distributed|distributed]] |
|||
| strong |
|||
|{{yes|Yes, [[wp:Ecma_International|ECMA]]}} |
|||
| safe |
|||
|strong |
|||
| explicit |
|||
|safe |
|||
| nominative |
|||
| |
|||
| static |
|||
| |
|||
| by value, by reference (compiler chosen if not determined by the data type) |
|||
|static |
|||
| Embedded, real-time, mission-critical, long-lived, and large scale systems |
|||
| |
|||
| Program reliability and maintenance, Programming as a human activity, Efficiency [http://www.adaic.com/standards/05rm/html/RM-0-3.html Language Reference Manual] |
|||
|{{yes}} |
|||
|Web design |
|||
| |
|||
|- |
|||
! {{anchor|Ada|[[Ada]]}} |
|||
|[[concurrent programming|concurrent]], [[:Category:Programming paradigm/Distributed|distributed]], [[generic programming|generic]], [[imperative programming|imperative]], [[object-oriented]] |
|||
|{{yes|Yes, [[ANSI]], [[ISO]], ANSI/MIL-STD-1815A-1983, [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=22983 ISO/IEC 8652], [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=38828 ISO/IEC TR 24718], [http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27831-88.pdf GOST 27831-88]}} |
|||
|strong |
|||
|safe |
|||
|explicit |
|||
|nominative |
|||
|static |
|||
|by value, by reference (compiler chosen if not determined by the data type) |
|||
|{{optional|GC is allowed, but not mandated}} |
|||
|Embedded, [[real-time computing|real-time]], mission-critical, long-lived, and large scale systems |
|||
|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|Yes, [http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf 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 68]] |
|||
| [[concurrent programming|concurrent]], [[imperative programming]] |
|||
! {{anchor|ALGOL_W|[[ALGOL W]]}} |
|||
| {{yes}}, [http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf GOST 27974-88] |
|||
|[[imperative programming|imperative]] |
|||
| strong |
|||
|{{no}} |
|||
| safe |
|||
|strong |
|||
| explicit |
|||
|safe |
|||
| structural |
|||
|explicit |
|||
| static or dynamic |
|||
|nominative |
|||
|static or dynamic (programmer chosen) |
|||
|by value, by reference or by name (programmer chosen) |
|||
|{{yes}} |
|||
|Application, Education |
|||
| |
| |
||
| 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) |
|||
|- |
|- |
||
! [[BASIC]] |
|||
| [[procedural programming]] |
|||
! {{anchor|AmbientTalk|[[AmbientTalk]]}} |
|||
| {{yes}}, [[ANSI]], [[ISO]] |
|||
|[[concurrent programming|concurrent]] |
|||
| varies by dialect |
|||
| |
| |
||
|strong |
|||
| |
|||
|safe |
|||
| |
|||
|explicit |
|||
| |
|||
|duck |
|||
|dynamic |
|||
|by value |
|||
| |
|||
|Mobile ad hoc networks |
|||
| |
| |
||
| Education |
|||
| Simplicity |
|||
|- |
|- |
||
! [[C]] |
|||
| [[imperative programming]] |
|||
! {{anchor|Arturo|[[Arturo]]}} |
|||
| {{yes}}, [[ANSI]] [[C89]], [[ISO]] [[C90]]/[[C99]] |
|||
|[[generic programming|generic]], [[imperative programming|imperative]], [[functional programming|functional]], [[reflective programming|reflective]], [[stack|stack]]-based |
|||
| weak |
|||
|{{no|No, see [https://arturo-lang.io/documentation/ official documentation]}} |
|||
| unsafe |
|||
|strong |
|||
| explicit |
|||
| |
|||
| nominative |
|||
|implicit |
|||
| static |
|||
| |
|||
| by value, by reference (through reference types) |
|||
|dynamic |
|||
| System, Embedded |
|||
|by value, by reference (literals) |
|||
| Low level access, Minimal constraint |
|||
|{{yes}} |
|||
|General, Scripting, DSLs, Templating, Portable apps, GUI applications |
|||
|Simplicity, Expressiveness, Portability |
|||
|- |
|- |
||
! [[C sharp|C#]] |
|||
| [[imperative programming]], [[object-oriented]], [[generic programming]], [[reflective programming]] |
|||
! {{anchor|AutoHotkey|[[AutoHotkey]]}} |
|||
| {{yes}}, [[ECMA]], [[ISO]] |
|||
|[[imperative programming|imperative]], [[classless-objects|classless]] |
|||
| strong |
|||
|{{no}} |
|||
| safe (but unsafe allowed) |
|||
|untyped |
|||
| implicit |
|||
| nominative |
|||
| static |
|||
| |
| |
||
| |
|||
| Application |
|||
| |
|||
| Rapid application development |
|||
| |
|||
|by value or by reference |
|||
|{{no}} |
|||
|End User Programming |
|||
|simplicity, speed, stability |
|||
|- |
|- |
||
! [[C++]] |
|||
| [[imperative programming]], [[object-oriented]], [[generic programming]] |
|||
! {{anchor|AutoIt|[[AutoIt]]}} |
|||
|[[imperative programming|imperative]] |
|||
| strong |
|||
| |
|||
| safe (but unsafe allowed) |
|||
| |
|||
| explicit, partially implicit |
|||
| |
|||
| nominative, structural |
|||
| |
|||
| static, dynamic |
|||
| |
|||
| by value, by reference (through reference types) |
|||
| |
|||
| Application, System |
|||
|by value or by reference |
|||
| Abstraction, Efficiency, Compatibility |
|||
| |
|||
|General, scripting, GUI and tasks automation |
|||
|Simplicity |
|||
|- |
|- |
||
! [[Clean]] |
|||
| [[functional programming]], [[generic programming]] |
|||
! {{anchor|BASIC|[[BASIC]]}} |
|||
| {{no}} |
|||
|[[procedural programming|procedural]] |
|||
| strong |
|||
|{{yes|Yes, [[ANSI]], [[ISO]]}} |
|||
| |
|||
|varies by dialect |
|||
| implicit |
|||
| |
|||
| static |
|||
| |
| |
||
| |
|||
| General |
|||
| |
|||
| Correctness, Modularity |
|||
| |
|||
| |
|||
|{{optional|varies by dialect}} |
|||
|Education |
|||
|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|Yes, [[ANSI]] [[C89]], [[ISO]] [[C90]]/[[C99]]}} |
|||
|weak |
|||
|unsafe |
|||
|explicit |
|||
|nominative |
|||
|static |
|||
|by value, by reference (through pointers) |
|||
|{{optional}} through [[wp:Boehm-GC|external tools]] |
|||
|System, Embedded |
|||
|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|Yes, [[wp:Ecma_International|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 |
|||
|- |
|||
! {{anchor|C++|[[C++]]}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]] |
|||
|{{yes|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 [[wp:Boehm-GC|external tools]] |
|||
|Application, System |
|||
|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 |
|||
|- |
|- |
||
! [[COBOL]] |
|||
| [[imperative programming]], [[object-oriented]] |
|||
! {{anchor|Clean|[[Clean]]}} |
|||
| {{yes}} |
|||
|[[functional programming|functional]], [[generic programming|generic]] |
|||
| strong |
|||
| |
|{{no}} |
||
|strong |
|||
| |
|||
| |
|||
| static |
|||
| |
| |
||
|implicit |
|||
| Business and Financial Applications |
|||
| |
|||
| Readability |
|||
|static |
|||
| |
|||
|{{yes}} |
|||
|General |
|||
|Correctness, Modularity |
|||
|- |
|- |
||
! [[ColdFusion]] |
|||
| [[procedural programming]], [[object-oriented]] |
|||
! {{anchor|Clojure|[[Clojure]]}} |
|||
| {{no}} |
|||
|[[functional programming|functional]], [[concurrent programming|concurrent]] |
|||
| weak |
|||
| |
| |
||
|strong |
|||
| implicit |
|||
|safe |
|||
| |
|||
| |
|||
| dynamic |
|||
| |
|||
|dynamic, static |
|||
| |
|||
|{{yes}} |
|||
| |
|||
| |
| |
||
| Web Development |
|||
| Rapid Application Development, Ease of use |
|||
|- |
|- |
||
! [[Common Lisp]] |
|||
| [[imperative programming]], [[functional programming]], [[object-oriented]] |
|||
! {{anchor|COBOL|[[COBOL]]}} |
|||
| {{yes}} |
|||
|[[imperative programming|imperative]], [[object-oriented]] |
|||
| strong |
|||
|{{yes|Yes, [[ANSI]] 68, 74, 85 (and subsequent revisions); ECMA; [[ISO]] 1989:2023 (and previous version in 1978, 1985, 2002, 2014)}} |
|||
| safe |
|||
|strong |
|||
| |
|||
|safe |
|||
| |
|||
|explicit |
|||
| dynamic |
|||
| |
| |
||
|static |
|||
| General |
|||
|by value, by reference |
|||
| Standardize [[Lisp]] |
|||
|{{no}} |
|||
|Business and Financial Applications |
|||
|Readability |
|||
|- |
|- |
||
! [[D]] |
|||
| [[imperative programming]], [[object-oriented]], [[generic programming]] |
|||
! {{anchor|ColdFusion|[[ColdFusion]]}} |
|||
| {{no}} |
|||
|[[procedural programming|procedural]], [[object-oriented]] |
|||
| strong |
|||
|{{no}} |
|||
| safe |
|||
|weak |
|||
| explicit |
|||
| |
|||
| static |
|||
| |
| |
||
|implicit |
|||
| Application, System |
|||
| |
|||
| Compilability, Correctness, Efficiency |
|||
|dynamic |
|||
| |
|||
| |
|||
|Web Development |
|||
|Rapid Application Development, Ease of use |
|||
|- |
|- |
||
! [[eC]] |
|||
| [[imperative programming]], [[object-oriented]], [[generic programming]], [[reflective programming]] |
|||
! {{anchor|Common Lisp|[[Common Lisp]]}} |
|||
| {{no}} |
|||
|[[imperative programming|imperative]], [[functional programming|functional]], [[object-oriented]] |
|||
| weak |
|||
|{{yes}} |
|||
| unsafe |
|||
|strong |
|||
| explicit, partially implicit |
|||
|safe |
|||
| nominative, complex conversions system |
|||
| |
|||
| static, dynamic |
|||
| |
|||
| according to data type, or explicitly by value, by reference |
|||
|dynamic, static |
|||
| Applications, GUI Interfaces, System, Games |
|||
| |
|||
| Elegance, Performance, Simplicity, Lightness, 99.9% C compatibility |
|||
|{{yes}} |
|||
|General |
|||
|Standardize [[Lisp]] |
|||
|- |
|- |
||
! [[Eiffel]] |
|||
| [[imperative programming]], [[object-oriented]], [[generic programming]] |
|||
! {{anchor|D|[[D]]}} |
|||
| {{yes}}, [http://www.ecma-international.org/publications/standards/Ecma-367.htm ECMA-367], [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=42924 ISO/IEC 25436:2006] |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]] |
|||
| strong |
|||
|{{no}} |
|||
| safe |
|||
|strong |
|||
| |
|||
|safe |
|||
| nominative |
|||
|explicit, optional inferred |
|||
| static |
|||
|nominative, structural |
|||
|static, dynamic |
|||
|by value, by reference (through reference types) |
|||
|{{yes}} |
|||
|Application, System |
|||
|Compilability, Correctness, Efficiency |
|||
|- |
|||
! {{anchor|Dao|[[Dao]]}} |
|||
|[[object-oriented]] |
|||
| |
|||
|strong |
|||
|safe, unsafe allowed |
|||
|implicit, explicit |
|||
| |
|||
|static, dynamic |
|||
| |
|||
|{{yes}} |
|||
| |
|||
| |
| |
||
| Application |
|||
| Correctness, Efficiency, Design by contract |
|||
|- |
|- |
||
! [[Erlang]] |
|||
! {{anchor|Dyalect|[[Dyalect]]}} |
|||
| [[functional programming]], [[concurrent programming|concurrent]], [[distributed programming]] |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]] |
|||
| {{no}} |
|||
|{{no}} |
|||
| strong |
|||
|strong |
|||
| |
|||
|safe |
|||
| |
|||
|implicit |
|||
| |
|||
|duck |
|||
| dynamic |
|||
|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]] |
|||
| |
|||
|strong |
|||
|safe |
|||
| |
|||
| |
|||
|static, dynamic |
|||
| |
|||
|{{yes}} |
|||
| |
|||
| |
| |
||
| Telecom and distributed applications |
|||
| Fault tolerance, Scalability |
|||
|- |
|- |
||
! [[Forth]] |
|||
| [[imperative programming]], [[stack]]-oriented |
|||
! {{anchor|E|[[E]]}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[object-capability]], [[communicating event loops]] |
|||
| none |
|||
|<!-- Std -->{{no}}, still in development |
|||
| n/a |
|||
|<!-- Strength -->strong (runtime) |
|||
| n/a |
|||
|<!-- Safety -->safe |
|||
| n/a |
|||
|<!-- Expr -->optional explicit |
|||
| n/a |
|||
|<!-- Compat -->duck |
|||
|<!-- Check -->dynamic |
|||
|<!-- Passing -->by value |
|||
|<!-- GC -->{{yes}} |
|||
|<!-- Uses -->Secure collaboration, distributed systems, running untrusted applications, high-level "scripting" |
|||
|<!-- 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]] |
|||
|{{no}} |
|||
|weak |
|||
|unsafe |
|||
|explicit, partially implicit |
|||
|nominative, complex conversions system |
|||
|static, dynamic |
|||
|according to data type, or explicitly by value, by reference |
|||
|{{optional|Reference counting}} |
|||
|Applications, GUIs, System, Games |
|||
|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|Yes, [http://www.ecma-international.org/publications/standards/Ecma-367.htm ECMA-367], [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=42924 ISO/IEC 25436:2006]}} |
|||
|strong |
|||
|safe |
|||
| |
| |
||
|nominative |
|||
| Application, Embedded systems |
|||
|static |
|||
| Compact implementations, Low level access, Interactive programming |
|||
| |
|||
|{{yes}} |
|||
|Application |
|||
|Correctness, Efficiency, Design by contract |
|||
|- |
|- |
||
! [[Fortran]] |
|||
| [[imperative programming]], [[procedural programming]], [[object-oriented]] |
|||
! {{anchor|Ela|[[Ela]]}} |
|||
| {{yes}} |
|||
|[[functional programming|functional]] |
|||
| strong |
|||
|{{no}} |
|||
| safe |
|||
|strong |
|||
| |
|||
|safe |
|||
| nominative |
|||
|implicit |
|||
| static |
|||
|duck |
|||
|dynamic |
|||
|by reference |
|||
|{{yes}} |
|||
|Application |
|||
| |
| |
||
| Scientific and numeric applications |
|||
| Runtime efficiency, Simple syntax |
|||
|- |
|- |
||
! [[Groovy]] |
|||
|- |
|||
| [[imperative programming]], [[object-oriented]], [[aspect-oriented programming]] |
|||
| {{no}} |
|||
| strong |
|||
! {{anchor|Elm|[[Elm]]}} |
|||
| safe |
|||
|[[functional programming|functional]], functional reactive programming, [[declarative programming|declarative]], pattern matching |
|||
| implicit |
|||
|{{no}} |
|||
| |
|||
|strong |
|||
| dynamic |
|||
|safe |
|||
|inferred, optional explicit annotations |
|||
| |
| |
||
|static |
|||
| Application |
|||
|immutable data structures, syntactically by value, time-varying with Signals |
|||
| [[JVM]] compatibility |
|||
|{{yes}} |
|||
|Web Development, GUIs, Applications, Games |
|||
|Simple, Modular, Safe, Reactive |
|||
|- |
|- |
||
! [[Haskell]] |
|||
| [[functional programming]], [[generic programming]], [[lazy evaluation]] |
|||
| {{yes}}, [http://www.haskell.org/haskellwiki/Language_and_library_specification Haskell 98 Report] |
|||
| strong |
|||
| safe |
|||
| inferred, optional explicit annotations |
|||
| polymorphic structural |
|||
| static |
|||
| |
|||
| Application, Research |
|||
| [[lazy evaluation]], Teaching and research, completely formally described [http://haskell.org/onlinereport/preface-jfp.html Report Preface] |
|||
|- |
|- |
||
! [[Io]] |
|||
| [[object-oriented]], prototype |
|||
! {{anchor|Elena|[[Elena]]}} |
|||
| {{no}} |
|||
|[[object-oriented]] |
|||
| strong |
|||
| |
| |
||
|strong |
|||
| |
|||
|safe |
|||
| |
|||
|implicit |
|||
| dynamic |
|||
| |
| |
||
|dynamic |
|||
| |
|||
| |
| |
||
|{{yes}} |
|||
| |
|||
| |
|||
|- |
|- |
||
! [[J]] |
|||
| [[array]] programming, function-level programming, [[tacit programming]] |
|||
! {{anchor|Erlang|[[Erlang]]}} |
|||
| {{no}} |
|||
|[[functional programming|functional]], [[concurrent programming|concurrent]], [[:Category:Programming paradigm/Distributed|distributed]], [[declarative programming|declarative]] - pattern matching, [[imperative programming|imperative]] |
|||
| strong |
|||
|{{no}} |
|||
| safe |
|||
|strong |
|||
| |
|||
|safe |
|||
| |
|||
|implicit |
|||
| dynamic |
|||
| |
| |
||
|dynamic |
|||
| Data processing |
|||
|immutable data structures, syntactically by value but safe sharing of compound data types |
|||
| Terseness, Expressiveness, Powerful Data Manipulation |
|||
|{{yes}} |
|||
|Telecom and mission critical distributed applications |
|||
|Fault tolerance, Reliability - Nonstop Running, Hot Code Change, Safety, Concurrency, Distribution, Scalability |
|||
|- |
|- |
||
! [[Java]] |
|||
| [[imperative programming]], [[object-oriented]], [[generic programming]], [[reflective programming]] |
|||
! {{anchor|ERRE|[[ERRE]]}} |
|||
| {{no}} |
|||
|[[imperative programming|imperative]], [[procedural programming|procedural]] |
|||
| strong |
|||
|{{no}} |
|||
| safe |
|||
|weak |
|||
| explicit |
|||
|unsafe |
|||
| nominative |
|||
|explicit |
|||
| static |
|||
| |
|||
| by value |
|||
|static and dynamic |
|||
| Application |
|||
|by value |
|||
| Write once run anywhere |
|||
|{{yes}} |
|||
|Education |
|||
|Readability, Modularity |
|||
|- |
|- |
||
! [[JavaScript]] |
|||
| [[imperative programming]], [[object-oriented]], [[functional programming]], [[reflective programming]] |
|||
! {{anchor|Factor|[[Factor]]}} |
|||
| {{yes}} |
|||
|[[stack]]-oriented |
|||
| weak |
|||
|<!-- Std -->{{no}} |
|||
| |
|||
|<!-- Strength --> |
|||
| implicit |
|||
|<!-- Safety -->safe |
|||
| |
|||
|<!-- Expr -->implicit |
|||
| dynamic |
|||
|<!-- 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 |
|||
|n/a |
|||
|n/a |
|||
|n/a |
|||
| |
| |
||
|{{no}} |
|||
| Client side web scripting |
|||
|Applications, High reliability, Embedded systems, Booting new hardware. |
|||
| |
|||
|Compact implementations, Low level access, Interactive programming, CPU agnostic Assembler Alternative, ultra-small memory systems. |
|||
|- |
|- |
||
! [[Joy]] |
|||
| [[functional programming]], [[stack]]-oriented |
|||
! {{anchor|Fortran|[[Fortran]]}} |
|||
| {{no}} |
|||
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[object-oriented]], (partially) [[generic programming|generic]], [[concurrent programming|concurrent]] |
|||
| strong |
|||
|{{yes|Yes, [[ISO]], [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=39691 ISO/IEC 1539-1:2004]}} |
|||
| safe |
|||
|strong |
|||
| |
|||
|safe |
|||
| |
|||
|explicit, partially implicit |
|||
| dynamic |
|||
|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 |
|||
| |
| |
||
| |
|||
| [[functional programming]] research |
|||
|nominative |
|||
| [[concatenative]] |
|||
|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]] |
|||
|<!-- Std -->{{no}} |
|||
|<!-- Strength -->strong |
|||
|<!-- Safety -->safe |
|||
|<!-- Expr -->explicit |
|||
|<!-- Compat --> |
|||
|<!-- Check -->dynamic |
|||
|<!-- Passing -->by value, by reference |
|||
|<!-- GC --> |
|||
|<!-- Uses -->Application, Scripting |
|||
|<!-- Design goals -->Rapid application development, Visual Basic alternative |
|||
|- |
|||
! {{anchor|Go|[[Go]]}} |
|||
|[[concurrent programming|concurrent]], [[classless-objects|classless]] |
|||
|<!-- Std -->{{no}}, [http://golang.org/ref/spec language specification] available |
|||
|<!-- Strength -->strong |
|||
|<!-- Safety -->safe |
|||
|<!-- Expr -->explicit, optionally inferred |
|||
|<!-- Compat -->nominative; structural for interface types |
|||
|<!-- Check -->static |
|||
|<!-- Passing -->by value |
|||
|<!-- GC -->{{yes}} |
|||
|<!-- Uses --> |
|||
|<!-- 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 |
|||
|- |
|- |
||
! [[Lisp]] |
|||
| [[functional programming]], [[reflective programming]]; others vary by dialect |
|||
! {{anchor|Groovy|[[Groovy]]}} |
|||
| {{no}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[wp:Aspect-oriented_programming|aspect-oriented]] |
|||
| strong |
|||
|{{no}} |
|||
| |
|||
|strong |
|||
| |
|||
|safe |
|||
| |
|||
|implicit |
|||
| dynamic |
|||
|nominative |
|||
|dynamic |
|||
| |
| |
||
|{{yes}} |
|||
| General |
|||
|Application |
|||
| Simple notation for Lambda calculus, Homoiconicity |
|||
|[[JVM]] compatibility |
|||
|- |
|- |
||
! [[Logo]] |
|||
| [[procedural programming]], [[functional programming]] |
|||
! {{anchor|Haskell|[[Haskell]]}} |
|||
|[[functional programming|functional]], [[generic programming|generic]], [[lazy evaluation]] |
|||
|{{yes|Yes, [http://www.haskell.org/onlinereport/haskell2010/ Haskell 2010 Report], [http://www.haskell.org/onlinereport/ Haskell 98 Report]}} |
|||
|strong |
|||
|safe |
|||
|inferred, optional explicit annotations |
|||
|polymorphic structural |
|||
|static |
|||
| |
|||
|{{yes}} |
|||
|Application, Research |
|||
|[[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]] |
|||
| {{no}} |
| {{no}} |
||
| strong |
| strong |
||
| |
| Safe |
||
| implicit |
| implicit |
||
| nominative |
|||
| structural |
|||
| dynamic |
| 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|Unicon]] for the unified extended dialect of Icon. |
|||
|- |
|||
! {{anchor|Insitux|[[Insitux]]}} |
|||
|[[functional programming|functional]], [[imperative programming|imperative]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
| |
| |
||
|dynamic |
|||
| Education |
|||
|by value |
|||
| Simple syntax, Turtle graphics, Interactive programming |
|||
|{{yes}} |
|||
|Host-driven scripting |
|||
|Host-extensibility; provide "safe" modding e.g. timeout infinite loops, memory limits; concise code |
|||
|- |
|- |
||
! [[Lua]] |
|||
! {{anchor|Io|[[Io]]}} |
|||
| [[procedural programming]], [[imperative programming]], [[reflective programming|reflective]] |
|||
|[[object-oriented]], [[classless-objects|classless]], prototype |
|||
| {{no}} |
|||
|{{no}} |
|||
| strong |
|||
| |
|strong |
||
| implicit |
|||
| |
|||
| dynamic |
|||
| |
| |
||
| |
|||
| Host-driven Scripting |
|||
| |
|||
| Small, embedded, configuration. |
|||
|dynamic |
|||
| |
|||
|{{yes}} |
|||
| |
|||
| |
|||
|- |
|||
! {{anchor|J|[[J]]}} |
|||
|[[array]] programming, function-level programming, [[tacit 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 |
|||
|- |
|||
! {{anchor|Java|[[Java]]}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]] |
|||
|{{yes|Yes, [http://docs.oracle.com/javase/specs/index.html Java SE Specifications]}} |
|||
|strong |
|||
|safe |
|||
|explicit |
|||
|nominative |
|||
|static |
|||
|by value |
|||
|{{yes}} |
|||
|Application |
|||
|Write once run anywhere |
|||
|- |
|- |
||
! [[Mathematica]] |
|||
| [[functional programming]], [[procedural programming]] |
|||
! {{anchor|JavaScript|[[JavaScript]]}} |
|||
| {{no}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[classless-objects|classless]], [[functional programming|functional]], [[reflective programming|reflective]] |
|||
| strong |
|||
|{{yes|Yes, [[ECMAScript standard]]}} |
|||
| |
|||
| |
|weak |
||
| |
| |
||
|implicit |
|||
| dynamic |
|||
| |
|||
|dynamic |
|||
|by value |
|||
|{{yes}} |
|||
|Client side web scripting |
|||
| |
| |
||
| Numeric computation and visualization |
|||
| |
|||
|- |
|- |
||
! [[Nial]] |
|||
| [[functional programming]], [[array]] programming |
|||
! {{anchor|Joy|[[Joy]]}} |
|||
| {{no}} |
|||
|[[functional programming|functional]], [[stack]]-oriented |
|||
| strong |
|||
|{{no}} |
|||
| |
|||
|strong |
|||
| |
|||
|safe |
|||
| |
|||
| dynamic |
|||
| |
| |
||
| |
|||
| Data processing |
|||
|dynamic |
|||
| |
|||
| |
|||
| |
|||
|[[functional programming|functional]] research |
|||
|[[concatenative programming|concatenative]] |
|||
|- |
|- |
||
! [[Oberon-2]] |
|||
! {{anchor|jq|[[jq]]}} |
|||
| [[procedural programming]] |
|||
|[[functional programming|functional]], [[tacit programming|tacit (point-free)]], [[dataflow programming|dataflow]] |
|||
| {{no}} |
|||
|<!-- Std -->{{no|No, but a de facto standard exists in the agreement between the C and Go-based versions}} |
|||
| strong |
|||
|<!-- Strength -->weak |
|||
| safe |
|||
|<!-- Safety -->safe |
|||
| explicit |
|||
|<!-- Expr -->implicit |
|||
| structural |
|||
|<!-- Compat -->n.a. |
|||
| static or dynamic |
|||
|<!-- Check -->dynamic |
|||
| by value, by reference |
|||
|<!-- Passing -->by value, with limited support for closures |
|||
| Teaching, System |
|||
|<!-- GC -->{{yes}} |
|||
| Simplicity |
|||
|<!-- 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 |
|||
|- |
|- |
||
! [[Object Pascal]] ([[Delphi]]) |
|||
| [[imperative programming]], [[object-oriented]], [[generic programming]] |
|||
! {{anchor|Kabap|[[Kabap]]}} |
|||
| {{no}} |
|||
|[[imperative programming|imperative]], [[Dynamic programming|dynamic]], extensible |
|||
| strong |
|||
|{{yes}} |
|||
| safe (but unsafe allowed) |
|||
|weak |
|||
| explicit |
|||
|unsafe |
|||
| nominative |
|||
|implicit |
|||
| static |
|||
|duck |
|||
|dynamic |
|||
|by value |
|||
| |
| |
||
|User scripting, general |
|||
| Application, System |
|||
|Safe sandboxed, easy to learn, easier to implement. Use to avoid eval() & reflection |
|||
| Readability, Rapid application development, Modularity |
|||
|- |
|- |
||
! [[Objective-C]] |
|||
| [[imperative programming]], [[object-oriented]], [[reflective programming]] |
|||
! {{anchor|Keg|[[Keg]]}} |
|||
| {{yes}} |
|||
|[[imperative programming|imperative]], [[Concatenative programming|concatenative]] |
|||
| weak |
|||
|{{no}} |
|||
| |
|||
|untyped |
|||
| explicit |
|||
|unsafe |
|||
| |
|||
|implicit |
|||
| static |
|||
|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 |
|||
| Application |
|||
| |
|||
| Smalltalk like, Component based code reuse, C compatibility |
|||
|{{no}} |
|||
|Portable applications, readable source codes, teaching |
|||
|Readability |
|||
|- |
|- |
||
! [[Ocaml]] |
|||
| [[object-oriented]], [[functional programming]], [[imperative programming]], [[generic programming]] |
|||
! {{anchor|LFE|[[LFE]]}} |
|||
| {{no}} |
|||
|[[functional programming|functional]], [[concurrent programming|concurrent]], [[:Category:Programming paradigm/Distributed|distributed]], [[declarative programming|declarative]] - pattern matching, [[imperative programming|imperative]] |
|||
| strong |
|||
|{{no}} |
|||
| safe |
|||
|strong |
|||
| implicit |
|||
|safe |
|||
| structural |
|||
|implicit |
|||
| static |
|||
| |
|||
| by value |
|||
|dynamic |
|||
| Application |
|||
|immutable data structures, syntactically by value but safe sharing of compound data types |
|||
| Efficiency, Robustness, Correctness |
|||
|{{yes}} |
|||
|Telecom and distributed applications |
|||
|Fault tolerance, Reliability - Nonstop Running, Hot Code Change, Safety, Concurrency, Distribution, Scalability |
|||
|- |
|- |
||
! [[Oz]] |
|||
| logic programming, [[functional programming]], [[imperative programming]], [[object-oriented]], [[concurrent programming]] |
|||
! {{anchor|Lisp|[[Lisp]]}} |
|||
| {{no}} |
|||
|[[functional programming|functional]], [[reflective programming|reflective]]; others vary by dialect |
|||
| |
|||
|{{no}} |
|||
| |
|||
|strong |
|||
| |
|||
| |
| |
||
| |
|||
| dynamic |
|||
| |
|||
|dynamic |
|||
| |
| |
||
|{{yes}} |
|||
| Education |
|||
|General |
|||
| |
|||
|Simple notation for Lambda calculus, Homoiconicity |
|||
|- |
|- |
||
! [[Pascal]] |
|||
| [[imperative programming]], [[procedural programming]] |
|||
! {{anchor|Logo|[[Logo]]}} |
|||
| {{yes}} (Extended Pascal standardized under [[ISO]]) |
|||
|[[procedural programming|procedural]], [[functional programming|functional]] |
|||
| strong |
|||
|{{no}} |
|||
| safe |
|||
|strong |
|||
| explicit |
|||
|safe |
|||
| |
|||
|implicit |
|||
| static |
|||
|structural |
|||
|dynamic |
|||
| |
| |
||
|{{yes}} |
|||
| Education |
|||
|Education |
|||
| Readability, Discipline, Modularity |
|||
|Simple syntax, Turtle graphics, Interactive programming |
|||
|- |
|- |
||
! [[Perl]] |
|||
| [[imperative programming]], [[procedural programming]], [[reflective programming]], [[functional programming]], [[object-oriented]], [[generic programming]] |
|||
! {{anchor|Lua|[[Lua]]}} |
|||
| {{no}} |
|||
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[classless-objects|classless]], [[reflective programming|reflective]] |
|||
| weak |
|||
|{{no}} |
|||
| |
|||
|strong |
|||
| implicit |
|||
|safe |
|||
| |
|||
|implicit |
|||
| dynamic |
|||
| |
|||
| by reference |
|||
|dynamic |
|||
| Text processing, Scripting |
|||
| |
|||
| Terseness, Expressiveness |
|||
|{{yes}} |
|||
|Host-driven Scripting |
|||
|Small, embedded, configuration. |
|||
|- |
|- |
||
! [[PHP]] |
|||
| [[imperative programming]], [[object-oriented]], [[reflective programming]] |
|||
! {{anchor|Lucid|[[Lucid]]}} |
|||
| {{no}} |
|||
|[[dataflow programming|dataflow]], [[functional programming|functional]] |
|||
| weak |
|||
|{{no}} |
|||
| |
|||
|strong |
|||
| |
|||
| |
|safe |
||
| dynamic |
|||
| |
| |
||
| |
|||
| Web Application, CLI |
|||
|dynamic |
|||
| Robustness and Simplicity |
|||
| |
|||
| |
|||
|stream processing |
|||
|dataflow |
|||
|- |
|- |
||
! [[Prolog]] |
|||
| logic programming |
|||
! {{anchor|Luck|[[Luck]]}} |
|||
|[[imperative programming|imperative]], [[functional programming|functional]] |
|||
| strong |
|||
|{{no}} |
|||
| |
|||
|weak |
|||
| |
|||
| |
|unsafe |
||
|explicit, partially inferred |
|||
| dynamic |
|||
|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]] |
|||
|{{no}} |
|||
|strong |
|||
| |
|||
| |
|||
| |
|||
|dynamic |
|||
| |
|||
|{{yes}} |
|||
|Numeric and symbolic computation, visualization |
|||
| |
| |
||
| Problem solving, Artificial intelligence |
|||
| [[declarative programming]] |
|||
|- |
|- |
||
! [[Python]] |
|||
| [[imperative programming]], [[object-oriented]], [[functional programming]], [[aspect-oriented programming]], [[reflective programming]] |
|||
! {{anchor|MATLAB|[[MATLAB]]}} |
|||
| {{no}} |
|||
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[array]] programming |
|||
| strong |
|||
|{{no|No, however the language is also implemented in [[Octave]] and [[FreeMat]]}} |
|||
| safe |
|||
|strong |
|||
| implicit |
|||
|unsafe |
|||
| |
|||
| dynamic |
|||
| |
| |
||
| |
|||
| Application, Education, Scripting |
|||
|dynamic |
|||
| Simplicity, Readability, Expressiveness, Modularity |
|||
|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 |
|||
|- |
|- |
||
! [[Ruby]] |
|||
| [[imperative programming]], [[object-oriented]], [[aspect-oriented programming]], [[reflective programming]] |
|||
! {{anchor|MAXScript|[[MAXScript]]}} |
|||
| {{no}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[procedural programming|procedural]] |
|||
| strong |
|||
|{{no}} |
|||
| |
|||
|strong |
|||
| implicit |
|||
|safe |
|||
| |
|||
|implicit |
|||
| dynamic |
|||
| |
|||
| by reference |
|||
|dynamic |
|||
| Application, Scripting |
|||
|by value, by reference |
|||
| Expressiveness, Readability |
|||
| |
|||
|3D Art Tools, Scripting |
|||
|Simplicity, Accessibilty |
|||
|- |
|- |
||
! [[Scala]] |
|||
| [[object-oriented]], [[functional programming]], [[generic programming]] |
|||
! {{anchor|Modula-3|[[Modula-3]]}} |
|||
| {{no}} |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[procedural programming|procedural]], [[generic programming|generic]] |
|||
| strong |
|||
|{{no}} |
|||
| |
|||
|strong |
|||
| partially implicit |
|||
|safe (unsafe allowed) |
|||
| |
|||
|explicit |
|||
| static |
|||
|structural |
|||
|static |
|||
|by value, by reference |
|||
|{{yes}} |
|||
|Application, Systems |
|||
|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 |
|||
| |
|||
| |
|||
| |
|||
|by value, by reference |
|||
|{{yes}} |
|||
| |
| |
||
|Built-in Persistent Storage |
|||
| Education |
|||
| |
|||
|- |
|- |
||
! [[Scheme]] |
|||
| [[functional programming]] |
|||
! {{anchor|Nial|[[Nial]]}} |
|||
| {{yes}} |
|||
|[[functional programming|functional]], [[array]] programming |
|||
| strong |
|||
|{{no}} |
|||
| |
|||
|strong |
|||
| |
|||
| |
| |
||
| |
|||
| dynamic (latent) |
|||
| |
|||
| by value |
|||
|dynamic |
|||
| General, Education |
|||
| |
|||
| Minimalistic, Lexical Scoping |
|||
| |
|||
|Data processing |
|||
| |
|||
|- |
|||
! {{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, Expressive, Elegant in that order. |
|||
|- |
|||
! {{anchor|Oberon-2|[[Oberon-2]]}} |
|||
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[object-oriented]], [[classless-objects|classless]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|explicit |
|||
|structural |
|||
|static |
|||
|by value, by reference |
|||
|{{yes}} |
|||
|Teaching, System |
|||
|Simplicity |
|||
|- |
|||
! {{anchor|Objeck|[[Objeck]]}} |
|||
|[[object-oriented]],[[functional programming|functional]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|explicit |
|||
|nominative |
|||
|static |
|||
|by value |
|||
|{{yes}} |
|||
|General, Education |
|||
|Minimalist, Cross-Platform, Modular |
|||
|- |
|||
! {{anchor|Object Pascal|[[Object Pascal]]}} ({{anchor|Delphi|[[Delphi]]}}) |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]] |
|||
|{{no}} |
|||
|strong |
|||
|safe (unsafe allowed) |
|||
|explicit |
|||
|nominative |
|||
|static, dynamic |
|||
|by reference, by value |
|||
|{{optional|some types}} |
|||
|Application, System |
|||
|Readability, Rapid application development, Modularity |
|||
|- |
|- |
||
! [[Smalltalk]] |
|||
| [[object-oriented]], [[concurrent programming]], [[event-driven programming]], [[imperative programming]], [[declarative programming]] |
|||
! {{anchor|Objective-C|[[Objective-C]]}} |
|||
| {{yes}}, [[ANSI]] |
|||
|[[imperative programming|imperative]], [[object-oriented]], [[reflective programming|reflective]], [[generic programming|generic]] (as of Xcode 7) |
|||
| strong |
|||
|{{no}} |
|||
| safe |
|||
|weak |
|||
| implicit |
|||
| |
|||
| dynamic |
|||
| |
| |
||
|explicit |
|||
| Application, Education |
|||
| |
|||
| Uniformity, Pure object oriented |
|||
|static |
|||
|by value |
|||
|{{yes|Yes (as of 2.0)}} |
|||
|Application |
|||
|[[Smalltalk]] like, Component based code reuse, [[C]]/[[C++]] compatibility |
|||
|- |
|- |
||
! [[Tcl]] |
|||
| [[imperative programming]], [[procedural programming]], [[event-driven programming]] |
|||
! {{anchor|OCaml|[[OCaml]]}} |
|||
| {{no}} |
|||
|[[object-oriented]], [[functional programming|functional]], [[imperative programming|imperative]], [[generic programming|generic]] |
|||
| |
|||
|{{no|No, [http://caml.inria.fr/pub/docs/manual-ocaml/index.html the manual] includes language specification}} |
|||
| |
|||
|strong |
|||
| |
|||
|safe |
|||
| |
|||
|inferred, optional explicit annotations |
|||
| dynamic |
|||
|polymorphic structural |
|||
|static |
|||
|by value |
|||
|{{yes}} |
|||
|Application |
|||
|Efficiency, Robustness, Correctness |
|||
|- |
|||
! {{anchor|Oz|[[Oz]]}} |
|||
|logic programming, [[functional programming|functional]], [[imperative programming|imperative]], [[object-oriented]], [[concurrent programming|concurrent]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
|structural |
|||
|dynamic |
|||
|by reference (though often immutable) |
|||
|{{yes}} |
|||
|Application, Education, Distribution |
|||
| |
| |
||
| Application, Scripting |
|||
| |
|||
|- |
|- |
||
! [[V]] |
|||
| [[functional programming]], [[stack]]-oriented,[[concatenative]] |
|||
! {{anchor|PARI/GP|[[PARI/GP]]}} |
|||
| {{no}} |
|||
|[[imperative programming|imperative]], [[procedural programming|procedural]] |
|||
| strong |
|||
|{{no}} |
|||
| safe |
|||
|weak |
|||
| |
|||
|unsafe |
|||
| |
|||
|implicit |
|||
| dynamic |
|||
|nominal |
|||
|dynamic |
|||
|by value, by reference |
|||
|{{yes}} |
|||
|Mathematics, especially number theory |
|||
| |
| |
||
| [[functional programming]] research |
|||
| [[concatenative]] |
|||
|- |
|- |
||
! [[Visual Basic]] |
|||
| component-oriented programming, [[event-driven programming]] |
|||
! {{anchor|Pascal|[[Pascal]]}} |
|||
| {{no}} |
|||
|[[imperative programming|imperative]], [[procedural programming|procedural]] |
|||
| strong |
|||
|{{yes| [https://www.iso.org/standard/13802.html ISO 7185:1990] and [https://www.iso.org/standard/18237.html ISO 10206:1991]}} |
|||
| safe |
|||
|strong |
|||
| |
|||
|safe |
|||
| nominative |
|||
|explicit |
|||
| static |
|||
| |
|||
| by reference, by value (explicit) |
|||
|static (some dialects also dynamic) |
|||
| Application |
|||
|by reference, by value |
|||
| Rapid application development, Simplicity |
|||
|{{no}} |
|||
|General, Application, Education, System |
|||
|Readability, Discipline, Modularity |
|||
|- |
|- |
||
! [[Visual Basic .NET]] |
|||
| [[object-oriented]], [[event-driven programming]] |
|||
! {{anchor|Perl|[[Perl]]}} |
|||
| {{no}} |
|||
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[reflective programming|reflective]], [[functional programming|functional]], [[object-oriented]], [[generic programming|generic]] |
|||
| strong |
|||
|{{no}} |
|||
| |
|||
|weak |
|||
| |
|||
| |
| |
||
|implicit |
|||
| static |
|||
| |
|||
| by reference, by value (both explicit) |
|||
|dynamic, static |
|||
| Application |
|||
|by reference |
|||
| Rapid application development, Simplicity |
|||
|{{optional|Reference counting}} |
|||
|Text processing, Scripting |
|||
|Terseness, Expressiveness |
|||
|- |
|- |
||
! [[Windows PowerShell]] |
|||
| [[imperative programming]], [[object-oriented]], [[functional programming]], [[pipeline programming]], [[reflective programming]] |
|||
! {{anchor|Phix|[[Phix]]}} |
|||
| {{no}} |
|||
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[object-oriented]] |
|||
| strong |
|||
|<!-- Std -->{{no}} |
|||
| safe |
|||
|<!-- Strength -->strong |
|||
| implicit |
|||
|<!-- Safety -->safe |
|||
| |
|||
|<!-- Expr -->explicit, partially implicit |
|||
| dynamic |
|||
|<!-- 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 |
|||
| |
| |
||
| |
|||
| Scripting |
|||
| |
| |
||
|dynamic |
|||
|by value, by reference |
|||
|{{yes}} |
|||
|Web Application, CLI |
|||
|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]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
| |
|||
|dynamic |
|||
| |
|||
|{{yes}} |
|||
|Application, Education |
|||
| |
|||
|- |
|||
! {{anchor|Prolog|[[Prolog]]}} |
|||
|logic programming |
|||
|{{yes|Yes, [[ISO]]}} |
|||
|strong |
|||
| |
|||
| |
|||
| |
|||
|dynamic |
|||
| |
|||
|{{yes}} |
|||
|Problem solving, Artificial intelligence |
|||
|[[declarative programming|declarative]] |
|||
|- |
|||
!{{anchor|Pure|[[Pure]]}} |
|||
|[[dynamic programming|dynamic]], [[functional programming|functional]] |
|||
| |
|||
|strong |
|||
| |
|||
| |
|||
|structural |
|||
|dynamic |
|||
| |
|||
|{{yes}} |
|||
| |
|||
| |
|||
|- |
|||
! {{anchor|Python|[[Python]]}} |
|||
|[[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}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
| |
|||
|dynamic |
|||
|by value ([[wp:Python_syntax_and_semantics#Data_structures|Call by object reference]]) |
|||
|{{yes}} |
|||
|Application, Education, Scripting |
|||
|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]] |
|||
|{{no}} |
|||
|strong (none for Variant type) |
|||
|safe |
|||
| |
|||
| |
|||
|static |
|||
|by reference, by value |
|||
| |
|||
|Application |
|||
|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 |
|||
| |
|||
|implicit |
|||
| |
|||
|dynamic |
|||
|by value (Call by object reference) |
|||
|{{yes}} |
|||
|Application, Scripting |
|||
|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 |
|||
|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 |
|||
|- |
|||
! {{anchor|Scheme|[[Scheme]]}} |
|||
|[[functional programming|functional]] |
|||
|{{yes|Yes, [http://www.schemers.org/Documents/Standards/R5RS/ R<sup>5</sup>RS], [http://www.r6rs.org/ R<sup>6</sup>RS]}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
| |
|||
|dynamic (latent) |
|||
|by value |
|||
|{{yes}} |
|||
|General, Education |
|||
|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 |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|implicit, optional |
|||
|structural (aka duck) |
|||
|dynamic |
|||
|by reference |
|||
|{{yes}} |
|||
|Application, Embedded, Scripting |
|||
|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|Yes, [http://wiki.squeak.org/squeak/172 ANSI]}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
|protocol (aka duck) |
|||
|dynamic |
|||
|by value (Call by object reference) |
|||
|{{yes}} |
|||
|Application, Education |
|||
|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 |
|||
|explicit |
|||
|nominative |
|||
|static |
|||
|by value, by reference |
|||
|{{optional|Allowed}} |
|||
|High integrity applications |
|||
|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|Yes, [http://www.smlnj.org/sml97.html SML '97]}} |
|||
|strong |
|||
|safe |
|||
|inferred, optional explicit annotations |
|||
|polymorphic structural |
|||
|static |
|||
|by value |
|||
|{{yes}} |
|||
| |
|||
| |
|||
|- |
|||
! {{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> |
|||
|{{no}} |
|||
|weak |
|||
|safe |
|||
|implicit |
|||
|duck |
|||
|dynamic |
|||
|by value (also by name and by reference through passing of variable names and <code>upvar</code> command) |
|||
|{{optional|Only of unnamed entities, e.g., values}} |
|||
|Embedded, Application, Scripting |
|||
|[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]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
|duck |
|||
|dynamic |
|||
|by value |
|||
|{{yes}} |
|||
|Embedded, Application, Scripting, Education |
|||
|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]] |
|||
| {{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|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]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
| |
|||
| |
|||
|dynamic |
|||
| |
|||
| |
|||
|[[functional programming|functional]] research |
|||
|[[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]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
| |
|||
|nominative |
|||
|static |
|||
|by reference, by value (explicit) |
|||
|{{yes}} |
|||
|Application |
|||
|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]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
|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]], pipeline, [[reflective programming|reflective]] |
|||
|{{no}} |
|||
|strong |
|||
|safe |
|||
|implicit |
|||
| |
|||
|dynamic |
|||
| |
|||
| |
|||
|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]] |
||
! |
![[:Category:Programming Paradigms|Paradigm(s)]] |
||
! |
!Standardized |
||
! |
![[Type strength]] |
||
! |
![[Type safety]] |
||
! |
!Expression of types |
||
! |
![[Type compatibility]] |
||
! |
![[Type checking]] |
||
! |
![[Parameter Passing]] Methods Available |
||
![[Garbage collection]] |
|||
! Intended use |
|||
!Intended use |
|||
! Design goals |
|||
!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 |