Language Comparison Table: Difference between revisions

← Older edit

Language Comparison Table (view source)

Revision as of 00:04, 9 March 2024

29,141 bytes added , 3 months ago

Added Plain English

Elenderg

18

edits

Revision as of 00:58, 31 December 2008 (view source) 68.222.54.6 (talk) No edit summary ← Older edit		Latest revision as of 00:04, 9 March 2024 (view source) Elenderg (talk \| contribs) (Added Plain English)
(246 intermediate revisions by 95 users not shown)
Line 1: [[Category:Encyclopedia]] See also [[TL;DR]] (Brief descriptions of languages). {\|class="wikitable sortable" ! [[:Category:Programming ~~Language~~Languages\|Language]] ! [[:Category:Programming ~~Paradigms~~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]]~~ \|! {{~~yes}},~~ anchor\|ACL2\|[[~~ECMA~~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]]~~ \|! {{~~yes}},~~ anchor\|AutoIt\|[[~~ISO~~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 \|- ~~! [[COBOL]]~~ ~~\| [[imperative programming]], [[object-oriented]]~~ ! {{anchor\|Blade\|[[Blade]]}} ~~\| {{yes}}~~ \|[[imperative programming\|imperative]], [[object-oriented]], [[functional programming\|functional]] ~~\| strong~~ \|{{no}} \| \|strong \| \|safe \| \|implicit ~~\| static~~ \|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 \|- ! {{anchor\|Clean\|[[Clean]]}} \|[[functional programming\|functional]], [[generic programming\|generic]] \|{{no}} \|strong \| \|implicit \| \|static \| \|{{yes}} ~~\| Business and Financial Applications~~ \|General ~~\| Readability~~ \|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 \|- ~~! [[E]]~~ ~~\| [[imperative programming\|imperative]], [[object-oriented]], [[object-capability]], [[communicating event loops]]~~ ! {{anchor\|Common Lisp\|[[Common Lisp]]}} ~~\| <!-- Std -->{{no}}, still in development~~ \|[[imperative programming\|imperative]], [[functional programming\|functional]], [[object-oriented]] ~~\| <!-- Strength -->strong (runtime)~~ \|{{yes}} ~~\| <!-- Safety -->safe~~ \|strong ~~\| <!-- Expr -->optional explicit~~ \|safe ~~\| <!-- Compat -->structural~~ \| ~~\| <!-- Check -->dynamic~~ \| ~~\| <!-- Passing -->by value~~ \|dynamic, static ~~\| <!-- Uses -->Secure collaboration, distributed systems, running untrusted applications, high-level “scripting”~~ \| ~~\| <!-- Design goals -->Familiarity to C/Java/JS users; less error-prone concurrency & security~~ \|{{yes}} \|General \|Standardize [[Lisp]] \|- ~~! [[eC]]~~ ~~\| [[imperative programming]], [[object-oriented]], [[generic programming]], [[reflective programming]]~~ \|! {{noanchor\|D\|[[D]]}} \|[[imperative programming\|imperative]], [[object-oriented]], [[generic programming\|generic]] ~~\| weak~~ \|{{no}} ~~\| unsafe~~ \|strong ~~\| explicit, partially implicit~~ \|safe ~~\| nominative, complex conversions system~~ \|explicit, optional inferred ~~\| static, dynamic~~ \|nominative, structural ~~\| according to data type, or explicitly by value, by reference~~ \|static, dynamic ~~\| Applications, GUIs, System, Games~~ \|by value, by reference (through reference types) ~~\| Elegance, Performance, Simplicity, Lightness, 99.9% [[C]] compatibility~~ \|{{yes}} \|Application, System \|Compilability, Correctness, Efficiency \|- ~~! [[Eiffel]]~~ ~~\| [[imperative programming]], [[object-oriented]], [[generic programming]]~~ ! {{anchor\|Dao\|[[Dao]]}} ~~\| {{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]~~ \|[[object-oriented]] ~~\| strong~~ ~~\| safe~~ \| ~~\| nominative~~ ~~\| static~~ \| \|strong ~~\| Application~~ \|safe, unsafe allowed ~~\| Correctness, Efficiency, Design by contract~~ \|implicit, explicit \| \|static, dynamic \| \|{{yes}} \| \| \|- ! {{anchor\|Dyalect\|[[Dyalect]]}} \|[[imperative programming\|imperative]], [[object-oriented]], [[functional programming\|functional]] \|{{no}} \|strong \|safe \|implicit \|duck \|dynamic \|by reference \|{{yes}} \|Application \|Portable dynamic scripting language with consistent design and modern syntax \|- ~~! [[Erlang]]~~ ~~\| [[functional programming]], [[concurrent programming\|concurrent]], [[distributed programming]]~~ ! {{anchor\|Dylan\|[[Dylan]]}} ~~\| {{no}}~~ \|[[imperative programming\|imperative]], [[object-oriented]], [[functional programming\|functional]], [[procedural programming\|procedural]] ~~\| strong~~ \| \| \| ~~\| dynamic~~ \| \|strong ~~\| Telecom and distributed applications~~ \|safe ~~\| Fault tolerance, Scalability~~ \| \| \|static, dynamic \| \|{{yes}} \| \| \|- ! {{anchor\|E\|[[E]]}} \|[[imperative programming\|imperative]], [[object-oriented]], [[object-capability]], [[communicating event loops]] \|<!-- Std -->{{no}}, still in development \|<!-- Strength -->strong (runtime) \|<!-- Safety -->safe \|<!-- Expr -->optional explicit \|<!-- 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 \|- ~~! [[Forth]]~~ ~~\| [[imperative programming]], [[stack]]-oriented~~ \|! {{~~yes}},~~ anchor\|Eiffel\|[[~~ANSI~~Eiffel]] }} \|[[imperative programming\|imperative]], [[object-oriented]], [[generic programming\|generic]] ~~\| none~~ \|{{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]}} ~~\| n/a~~ \|strong ~~\| n/a~~ \|safe ~~\| n/a~~ ~~\| n/a~~ \| \|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}}, [[ISO]], [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=39691 ISO/IEC 1539-1:2004]~~ \|[[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 \|- ~~! [[Lisp]]~~ ~~\| [[functional programming]], [[reflective programming]]; others vary by dialect~~ ! {{anchor\|Gambas\|[[Gambas]]}} ~~\| {{no}}~~ \|[[object-oriented\|object-oriented]] ~~\| strong~~ \|<!-- Std -->{{no}} \| \|<!-- Strength -->strong \| \|<!-- Safety -->safe \| \|<!-- Expr -->explicit ~~\| dynamic~~ \|<!-- 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 \|- ! {{anchor\|Groovy\|[[Groovy]]}} \|[[imperative programming\|imperative]], [[object-oriented]], [[wp:Aspect-oriented_programming\|aspect-oriented]] \|{{no}} \|strong \|safe \|implicit \|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}} \| strong \| ~~safe~~Safe \| implicit \| nominative ~~\| structural~~ \| 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~~ \| ~~safe~~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 \|- ~~! [[Lucid]]~~ ~~\| [[dataflow programming]], [[functional programming]]~~ ! {{anchor\|JavaScript\|[[JavaScript]]}} ~~\| {{no}}~~ \|[[imperative programming\|imperative]], [[object-oriented]], [[classless-objects\|classless]], [[functional programming\|functional]], [[reflective programming\|reflective]] ~~\| strong~~ \|{{yes\|Yes, [[ECMAScript standard]]}} ~~\| safe~~ \| weak \| \|implicit ~~\| dynamic~~ \| \|dynamic \|by value \|{{yes}} \|Client side web scripting \| ~~\| stream processing~~ ~~\| dataflow~~ \|- ~~! [[Mathematica]]~~ ~~\| [[functional programming]], [[procedural programming]]~~ ! {{anchor\|Joy\|[[Joy]]}} ~~\| {{no}}~~ \|[[functional programming\|functional]], [[stack]]-oriented ~~\| strong~~ \|{{no}} \| \|strong \| \|safe \| ~~\| dynamic~~ \| \| ~~\| Numeric computation and visualization~~ \|dynamic \| \| \|[[functional programming\|functional]] research \|[[concatenative programming\|concatenative]] \|- ~~! [[MAXScript]]~~ ! {{anchor\|jq\|[[jq]]}} ~~\| [[imperative programming]], [[object-oriented]], [[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 ~~\| implicit~~ \|<!-- Expr -->implicit \| \|<!-- Compat -->n.a. ~~\| dynamic~~ \|<!-- Check -->dynamic ~~\| by value, by reference~~ \|<!-- Passing -->by value, with limited support for closures ~~\| 3D Art Tools, Scripting~~ \|<!-- GC -->{{yes}} ~~\| Simplicity, Accessibilty~~ \|<!-- 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 \|- ~~! [[Modula-3]]~~ ~~\| [[imperative programming]], [[object-oriented]], [[procedural programming]], [[generic programming]]~~ ! {{anchor\|Kabap\|[[Kabap]]}} ~~\| {{no}}~~ \|[[imperative programming\|imperative]], [[Dynamic programming\|dynamic]], extensible ~~\| strong~~ \|{{yes}} ~~\| safe (unsafe allowed)~~ \|weak ~~\| explicit~~ \|unsafe ~~\| structural~~ \|implicit ~~\| static or dynamic~~ \|duck ~~\| by value, by reference~~ \|dynamic ~~\| Application, Systems~~ \|by value ~~\| Simple, Object oriented~~ \| \|User scripting, general \|Safe sandboxed, easy to learn, easier to implement. Use to avoid eval() & reflection \|- ! {{anchor\|Keg\|[[Keg]]}} \|[[imperative programming\|imperative]], [[Concatenative programming\|concatenative]] \|{{no}} \|untyped \|unsafe \|implicit \|nominative \|dynamic \|by reference \|{{no}} \|Code Golf, general \|Be simple, readable, and concise \|- ! {{anchor\|Kotlin\|[[Kotlin]]}} \|[[imperative programming\|imperative]], [[object-oriented]], [[procedural programming\|procedural]], [[functional programming\|functional]], [[generic programming\|generic]], [[reflective programming\|reflective]] \|{{no}} \|strong \|safe \|explicit, optionally inferred \|nominative \|static, dynamic (JS only) \|by value (read-only) \|{{yes}} \|Application \|Pragmatic language for modern multi-platform applications with compilers for JVM, JS and Native code \|- ~~! [[Nial]]~~ ~~\| [[functional programming]], [[array]] programming~~ ! {{anchor\|LDPL\|[[LDPL]]}} ~~\| {{no}}~~ \|[[imperative programming\|imperative]] ~~\| strong~~ \|{{no}} \| \|strong \| \|safe \| \|explicit ~~\| dynamic~~ \| \|static ~~\| Data processing~~ \| \|{{no}} \|Portable applications, readable source codes, teaching \|Readability \|- ~~! [[Oberon-2]]~~ ~~\| [[procedural programming]], [[imperative programming]], [[object-oriented]]~~ \|! {{noanchor\|LFE\|[[LFE]]}} \|[[functional programming\|functional]], [[concurrent programming\|concurrent]], [[:Category:Programming paradigm/Distributed\|distributed]], [[declarative programming\|declarative]] - pattern matching, [[imperative programming\|imperative]] ~~\| strong~~ \|{{no}} ~~\| safe~~ \|strong ~~\| explicit~~ \|safe ~~\| structural~~ \|implicit ~~\| static or dynamic~~ \| ~~\| by value, by reference~~ \|dynamic ~~\| Teaching, System~~ \|immutable data structures, syntactically by value but safe sharing of compound data types ~~\| Simplicity~~ \|{{yes}} \|Telecom and distributed applications \|Fault tolerance, Reliability - Nonstop Running, Hot Code Change, Safety, Concurrency, Distribution, Scalability \|- ~~! [[Object Pascal]] ([[Delphi]])~~ ~~\| [[imperative programming]], [[object-oriented]], [[generic programming]]~~ ! {{anchor\|Lisp\|[[Lisp]]}} ~~\| {{no}}~~ \|[[functional programming\|functional]], [[reflective programming\|reflective]]; others vary by dialect ~~\| strong~~ \|{{no}} ~~\| safe (but unsafe allowed)~~ \|strong ~~\| explicit~~ ~~\| nominative~~ ~~\| static~~ \| \| ~~\| Application, System~~ \| ~~\| Readability, Rapid application development, Modularity~~ \|dynamic \| \|{{yes}} \|General \|Simple notation for Lambda calculus, Homoiconicity \|- ~~! [[Objective-C]]~~ ~~\| [[imperative programming]], [[object-oriented]], [[reflective programming]]~~ ! {{anchor\|Logo\|[[Logo]]}} ~~\| {{yes}}~~ \|[[procedural programming\|procedural]], [[functional programming\|functional]] ~~\| weak~~ \|{{no}} \| \|strong ~~\| explicit~~ \|safe \| \|implicit ~~\| static~~ \|structural \|dynamic \| \|{{yes}} ~~\| Application~~ \|Education ~~\| [[Smalltalk]] like, Component based code reuse, [[C]] compatibility~~ \|Simple syntax, Turtle graphics, Interactive programming \|- ~~! [[Ocaml]]~~ ~~\| [[object-oriented]], [[functional programming]], [[imperative programming]], [[generic programming]]~~ ! {{anchor\|Lua\|[[Lua]]}} ~~\| {{no}}~~ \|[[procedural programming\|procedural]], [[imperative programming\|imperative]], [[classless-objects\|classless]], [[reflective programming\|reflective]] ~~\| strong~~ \|{{no}} ~~\| safe~~ \|strong ~~\| implicit~~ \|safe ~~\| structural~~ \|implicit ~~\| static~~ \| ~~\| by value~~ \|dynamic ~~\| Application~~ \| ~~\| Efficiency, Robustness, Correctness~~ \|{{yes}} \|Host-driven Scripting \|Small, embedded, configuration. \|- ~~! [[Oz]]~~ ~~\| logic programming, [[functional programming]], [[imperative programming]], [[object-oriented]], [[concurrent programming]]~~ ! {{anchor\|Lucid\|[[Lucid]]}} ~~\| {{no}}~~ \|[[dataflow programming\|dataflow]], [[functional programming\|functional]] \| \|{{no}} \| \|strong \| \|safe ~~\| dynamic~~ \| \| ~~\| Education~~ \|dynamic \| \| \| \|stream processing \|dataflow \|- ! {{anchor\|Luck\|[[Luck]]}} \|[[imperative programming\|imperative]], [[functional programming\|functional]] \|{{no}} \|weak \|unsafe \|explicit, partially inferred \|nominative \|static \|by value or by reference \|{{yes}} \|systems programming \|fast, C compatible, high-level language \|- ~~! [[Pascal]]~~ ~~\| [[imperative programming]], [[procedural programming]]~~ ! {{anchor\|Mathematica\|[[Mathematica]]}} ~~\| {{yes}} (Extended Pascal standardized under [[ISO]])~~ \|[[functional programming\|functional]], [[procedural programming\|procedural]] ~~\| strong~~ \|{{no}} ~~\| safe~~ \|strong ~~\| explicit~~ \| \| ~~\| static~~ \| \|dynamic \| \|{{yes}} \|Numeric and symbolic computation, visualization \| ~~\| Education~~ ~~\| Readability, Discipline, Modularity~~ \|- ~~! [[Perl]]~~ ~~\| [[imperative programming]], [[procedural programming]], [[reflective programming]], [[functional programming]], [[object-oriented]], [[generic programming]]~~ ! {{anchor\|MATLAB\|[[MATLAB]]}} ~~\| {{no}}~~ \|[[procedural programming\|procedural]], [[imperative programming\|imperative]], [[array]] programming ~~\| weak~~ \|{{no\|No, however the language is also implemented in [[Octave]] and [[FreeMat]]}} \| \|strong ~~\| implicit~~ \|unsafe \| \| ~~\| dynamic~~ \| ~~\| by reference~~ \|dynamic ~~\| Text processing, Scripting~~ \|by value ~~\| Terseness, Expressiveness~~ \|{{yes}} \|Numeric computation and visualization \|At the beginning designed as interpreter for easy use of fortran libraries, nowadays high performance numerical analysis and visualization \|- ~~! [[PHP]]~~ ~~\| [[imperative programming]], [[object-oriented]], [[reflective programming]]~~ ! {{anchor\|MAXScript\|[[MAXScript]]}} ~~\| {{no}}~~ \|[[imperative programming\|imperative]], [[object-oriented]], [[procedural programming\|procedural]] ~~\| weak~~ \|{{no}} \| \|strong \| \|safe \| \|implicit ~~\| dynamic~~ \| \|dynamic ~~\| Web Application, CLI~~ \|by value, by reference ~~\| Robustness and Simplicity~~ \| \|3D Art Tools, Scripting \|Simplicity, Accessibilty \|- ~~! [[Prolog]]~~ ~~\| logic programming~~ \|! {{~~yes}},~~ anchor\|Modula-3\|[[~~ISO~~Modula-3]]}} \|[[imperative programming\|imperative]], [[object-oriented]], [[procedural programming\|procedural]], [[generic programming\|generic]] ~~\| strong~~ \|{{no}} \| \|strong \| \|safe (unsafe allowed) \| \|explicit ~~\| dynamic~~ \|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 \| \| ~~\| Problem solving, Artificial intelligence~~ \| ~~\| [[declarative programming]]~~ \|by value, by reference \|{{yes}} \| \|Built-in Persistent Storage \|- ~~! [[Python]]~~ ~~\| [[imperative programming]], [[object-oriented]], [[functional programming]], [[aspect-oriented programming]], [[reflective programming]]~~ ! {{anchor\|Nial\|[[Nial]]}} ~~\| {{no}}~~ \|[[functional programming\|functional]], [[array]] programming ~~\| strong~~ \|{{no}} ~~\| safe~~ \|strong ~~\| implicit~~ \| ~~\| dynamic~~ \| \| ~~\| Application, Education, Scripting~~ \| ~~\| Simplicity, Readability, Expressiveness, Modularity~~ \|dynamic \| \| \|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 \|- ~~! [[RapidQ]]~~ ~~\| [[imperative programming]], component-oriented programming, [[event-driven programming]]~~ ! {{anchor\|Objeck\|[[Objeck]]}} ~~\| {{no}}~~ \|[[object-oriented]],[[functional programming\|functional]] ~~\| strong (none for Variant type)~~ \|{{no}} ~~\| safe~~ \|strong \| \|safe \| \|explicit ~~\| static~~ \|nominative ~~\| by reference, by value~~ \|static ~~\| Application~~ \|by value ~~\| Rapid application development, Simplicity, [[BASIC]] compatibility~~ \|{{yes}} \|General, Education \|Minimalist, Cross-Platform, Modular \|- ~~! [[Ruby]]~~ ~~\| [[imperative programming]], [[object-oriented]], [[aspect-oriented programming]], [[reflective programming]]~~ ! {{anchor\|Object Pascal\|[[Object Pascal]]}} ({{anchor\|Delphi\|[[Delphi]]}}) ~~\| {{no}}~~ \|[[imperative programming\|imperative]], [[object-oriented]], [[generic programming\|generic]] ~~\| strong~~ \|{{no}} \| \|strong ~~\| implicit~~ \|safe (unsafe allowed) \| \|explicit ~~\| dynamic~~ \|nominative ~~\| by reference~~ \|static, dynamic ~~\| Application, Scripting~~ \|by reference, by value ~~\| Expressiveness, Readability~~ \|{{optional\|some types}} \|Application, System \|Readability, Rapid application development, Modularity \|- ~~! [[Scala]]~~ ~~\| [[object-oriented]], [[functional programming]], [[generic programming]]~~ ! {{anchor\|Objective-C\|[[Objective-C]]}} ~~\| {{no}}~~ \|[[imperative programming\|imperative]], [[object-oriented]], [[reflective programming\|reflective]], [[generic programming\|generic]] (as of Xcode 7) ~~\| strong~~ \|{{no}} \| \|weak ~~\| partially implicit~~ \| ~~\| static~~ \| \|explicit ~~\| Education~~ \| \|static \|by value \|{{yes\|Yes (as of 2.0)}} \|Application \|[[Smalltalk]] like, Component based code reuse, [[C]]/[[C++]] compatibility \|- ~~! [[Scheme]]~~ ~~\| [[functional programming]]~~ ! {{anchor\|OCaml\|[[OCaml]]}} ~~\| {{yes}}~~ \|[[object-oriented]], [[functional programming\|functional]], [[imperative programming\|imperative]], [[generic programming\|generic]] ~~\| strong~~ \|{{no\|No, [http://caml.inria.fr/pub/docs/manual-ocaml/index.html the manual] includes language specification}} \| \|strong \| \|safe \| \|inferred, optional explicit annotations ~~\| dynamic (latent)~~ \|polymorphic structural ~~\| by value~~ \|static ~~\| General, Education~~ \|by value ~~\| Minimalistic, Lexical Scoping~~ \|{{yes}} \|Application \|Efficiency, Robustness, Correctness \|- ~~! [[Smalltalk]]~~ ~~\| [[object-oriented]], [[concurrent programming]], [[event-driven programming]], [[imperative programming]], [[declarative programming]]~~ \|! {{~~yes}},~~ anchor\|Oz\|[[~~ANSI~~Oz]] }} \|logic programming, [[functional programming\|functional]], [[imperative programming\|imperative]], [[object-oriented]], [[concurrent programming\|concurrent]] ~~\| strong~~ \|{{no}} ~~\| safe~~ \|strong ~~\| implicit~~ \|safe \| \|implicit ~~\| dynamic~~ \|structural \|dynamic \|by reference (though often immutable) \|{{yes}} \|Application, Education, Distribution \| ~~\| Application, Education~~ ~~\| Uniformity, Pure object oriented~~ \|- ~~! [[Tcl]]~~ ~~\| [[imperative programming]], [[procedural programming]], [[event-driven programming]]~~ ! {{anchor\|PARI/GP\|[[PARI/GP]]}} ~~\| {{no}}~~ \|[[imperative programming\|imperative]], [[procedural programming\|procedural]] \| \|{{no}} \| \|weak \| \|unsafe \| \|implicit ~~\| dynamic~~ \|nominal \|dynamic \|by value, by reference \|{{yes}} \|Mathematics, especially number theory \| ~~\| Application, Scripting~~ \| \|- ~~! [[V]]~~ ~~\| [[functional programming]], [[stack]]-oriented,[[concatenative]]~~ ! {{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 \| \|explicit ~~\| dynamic~~ \| \|static (some dialects also dynamic) ~~\| [[functional programming]] research~~ \|by reference, by value ~~\| [[concatenative]]~~ \|{{no}} \|General, Application, Education, System \|Readability, Discipline, Modularity \|- ~~! [[Visual Basic]]~~ ~~\| component-oriented programming, [[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}} ~~\| safe~~ \|weak \| \| ~~\| nominative~~ \|implicit ~~\| static~~ \| ~~\| by reference, by value (explicit)~~ \|dynamic, static ~~\| Application~~ \|by reference ~~\| Rapid application development, Simplicity~~ \|{{optional\|Reference counting}} \|Text processing, Scripting \|Terseness, Expressiveness \|- ~~! [[Visual Basic .NET]]~~ ~~\| [[object-oriented]], [[event-driven programming]]~~ ! {{anchor\|Phix\|[[Phix]]}} ~~\| {{no}}~~ \|[[imperative programming\|imperative]], [[procedural programming\|procedural]], [[object-oriented]] ~~\| strong~~ \|<!-- Std -->{{no}} \| \|<!-- Strength -->strong \| \|<!-- Safety -->safe \| \|<!-- Expr -->explicit, partially implicit ~~\| static~~ \|<!-- Compat -->duck ~~\| by reference, by value (both explicit)~~ \|<!-- Check -->dynamic, static ~~\| Application~~ \|<!-- Passing -->copy on write, immutable reference, multiple returns ~~\| Rapid application development, Simplicity~~ \|<!-- GC -->{{optional\|Reference counting or JavaScript compatible}} \|<!-- Uses -->Application, Educational, General, High-level scripting, Text processing \|<!-- Design goals -->Simplicity, Readability, Ease of use \|- ~~! [[Windows PowerShell]]~~ ~~\| [[imperative programming]], [[object-oriented]], [[functional programming]], [[pipeline programming]], [[reflective programming]]~~ ! {{anchor\|PHP\|[[PHP]]}} ~~\| {{no}}~~ \|[[imperative programming\|imperative]], [[object-oriented]], [[reflective programming\|reflective]] ~~\| strong~~ \|{{no}} ~~\| safe~~ \|weak ~~\| implicit~~ \| ~~\| dynamic~~ \| \| ~~\| 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" ! [[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]]