Language Comparison Table: Difference between revisions

From Rosetta Code
Content added Content deleted
m (Added link to paradigms cat)
(Added Plain English)
 
(288 intermediate revisions by more than 100 users not shown)
Line 1: Line 1:
[[Category:Encyclopedia]]

See also [[TL;DR]] (Brief descriptions of languages).
{|class="wikitable sortable"
{|class="wikitable sortable"
! [[Programming Language|Language]]
![[:Category:Programming Languages|Language]]
! [[:Category:Programming Paradigms|Paradigm(s)]]
![[:Category:Programming paradigm|Paradigm(s)]]
! Standardized
!Standardized
! [[Type strength]]
![[Type strength]]
! [[Type safety]]
![[Type safety]]
! Expression of types
!Expression of types
! [[Type compatibility]]
![[Type compatibility]]
! Type checking
![[Type checking]]
![[Parameter Passing]] Methods Available
! Intended use
![[Garbage collection]]
! Design goals
!Intended use
!Design goals
|-
|-

! [[ActionScript]]

| [[imperative programming]], [[object-oriented]], [[event-driven programming]]
| {{yes}}, [[ECMA]]
! {{anchor|ACL2|[[ACL2]]}}
|[[functional programming|functional]]
| strong
|{{yes}}
| safe
|strong
|
|unsafe
|
|implicit
| static
|
| Web design
|dynamic
|
|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]]
|[[imperative programming|imperative]], [[object-oriented]],[[:Category:Programming paradigm/Distributed|distributed]]
| strong
|{{yes|Yes, [[wp:Ecma_International|ECMA]]}}
| safe
|strong
| explicit
|safe
| nominative
|
| static
|
| Embedded, Real-time applications
|static
| Reliability
|
|{{yes}}
|Web design
|
|-
|-

! [[ALGOL 68]]

| [[concurrent programming|concurrent]], [[imperative programming]]
! {{anchor|Ada|[[Ada]]}}
| {{no}}
|[[concurrent programming|concurrent]], [[:Category:Programming paradigm/Distributed|distributed]], [[generic programming|generic]], [[imperative programming|imperative]], [[object-oriented]]
| strong
|{{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]}}
| safe
|strong
|
|safe
| structural
|explicit
| static or dynamic
|nominative
| Application
|static
| Readability, Structure
|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]
|-
|-

! [[BASIC]]

| [[procedural programming]]
| {{yes}}, [[ANSI]], [[ISO]]
! {{anchor|ALGOL_68|[[ALGOL 68]]}}
|[[concurrent programming|concurrent]], [[imperative programming|imperative]]
| varies by dialect
|{{yes|Yes, [http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf GOST 27974-88]}}
|
|strong
|
|safe
|
|explicit
|
|structural
| Education
|static or dynamic (programmer chosen)
| Simplicity
|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)
|-
|-

! [[C]]

| [[imperative programming]]
! {{anchor|ALGOL_W|[[ALGOL W]]}}
| {{yes}}, [[ANSI]] [[C89]], [[ISO]] [[C90]]/[[C99]]
|[[imperative programming|imperative]]
| weak
|{{no}}
| unsafe
|strong
| explicit
|safe
| nominative
|explicit
| static
|nominative
| System
|static or dynamic (programmer chosen)
| Low level access, Minimal constraint
|by value, by reference or by name (programmer chosen)
|{{yes}}
|Application, Education
|
|-
|-

! [[C sharp|C#]]

| [[imperative programming]], [[object-oriented]], [[generic programming]], [[reflective programming]]
! {{anchor|AmbientTalk|[[AmbientTalk]]}}
| {{yes}}, [[ECMA]], [[ISO]]
|[[concurrent programming|concurrent]]
| strong
|
| safe (but unsafe allowed)
|strong
| implicit
|safe
| nominative
|explicit
| static
|duck
| Application
|dynamic
| Rapid application development
|by value
|
|Mobile ad hoc networks
|
|-
|-

! [[C++]]

| [[imperative programming]], [[object-oriented]], [[generic programming]]
| {{yes}}, [[ISO]]
! {{anchor|Arturo|[[Arturo]]}}
|[[generic programming|generic]], [[imperative programming|imperative]], [[functional programming|functional]], [[reflective programming|reflective]], [[stack|stack]]-based
| strong
|{{no|No, see [https://arturo-lang.io/documentation/ official documentation]}}
| safe (but unsafe allowed)
|strong
| explicit, partially implicit
|
| nominative, structural
|implicit
| static, dynamic
|
| Application, System
|dynamic
| Abstraction, Efficiency, Compatibility
|by value, by reference (literals)
|{{yes}}
|General, Scripting, DSLs, Templating, Portable apps, GUI applications
|Simplicity, Expressiveness, Portability
|-
|-

! [[Clean]]

| [[functional programming]], [[generic programming]]
! {{anchor|AutoHotkey|[[AutoHotkey]]}}
| {{no}}
|[[imperative programming|imperative]], [[classless-objects|classless]]
| strong
|{{no}}
|
|untyped
| implicit
|
|
|
| static
|
| General
|
| Correctness, Modularity
|by value or by reference
|{{no}}
|End User Programming
|simplicity, speed, stability
|-
|-

! [[COBOL]]

| [[imperative programming]], [[object-oriented]]
! {{anchor|AutoIt|[[AutoIt]]}}
| {{yes}}
|[[imperative programming|imperative]]
| strong
|
|
|
|
|
|
|
| static
|
| Business and Financial Applications
|
| Readability
|by value or by reference
|
|General, scripting, GUI and tasks automation
|Simplicity
|-
|-

! [[ColdFusion]]

| [[procedural programming]], [[object-oriented]]
! {{anchor|BASIC|[[BASIC]]}}
| {{no}}
|[[procedural programming|procedural]]
| weak
|{{yes|Yes, [[ANSI]], [[ISO]]}}
|
|varies by dialect
| implicit
|
|
|
| dynamic
|
| Web Development
|
| Rapid Application Development, Ease of use
|
|{{optional|varies by dialect}}
|Education
|Simplicity
|-
|-

! [[Common Lisp]]

| [[imperative programming]], [[functional programming]], [[object-oriented]]
! {{anchor|Blade|[[Blade]]}}
| {{yes}}
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]]
| strong
|{{no}}
| safe
|strong
|
|safe
|
|implicit
| dynamic
|nominative
| General
|dynamic
| Standardize [[Lisp]]
|by value, by reference (through pointers)
|{{yes}}
|Scripting, Application
|Simple, Lightweight, CLI, Web, Desktop, Mobile
|-
|-

! [[D]]

| [[imperative programming]], [[object-oriented]], [[generic programming]]
| {{no}}
! {{anchor|C|[[C]]}}
|[[imperative programming|imperative]]
| strong
|{{yes|Yes, [[ANSI]] [[C89]], [[ISO]] [[C90]]/[[C99]]}}
| safe
|weak
| explicit
|unsafe
|
|explicit
| static
|nominative
| Application, System
|static
| Compilability, Correctness, Efficiency
|by value, by reference (through pointers)
|{{optional}} through [[wp:Boehm-GC|external tools]]
|System, Embedded
|Low level access, Minimal constraint
|-
|-

! [[Eiffel]]

| [[imperative programming]], [[object-oriented]], [[generic programming]]
! {{anchor|C_sharp|[[C sharp|C#]]}}
| {{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]], [[reflective programming|reflective]], [[functional programming|functional]], [[event-driven programming|event-driven]]
| strong
|{{yes|Yes, [[wp:Ecma_International|ECMA]], [[ISO]]}}
| safe
|strong
|
|safe (unsafe allowed)
| nominative
|implicit
| static
|nominative
| Application
|static, dynamic (for interop)
| Correctness, Efficiency, Design by contract
|by value, by reference (through managed pointers [explicitly in, out, or in-out])
|{{yes}}
|Application
|Rapid application development
|-
|-

! [[Erlang]]

| [[functional programming]], [[concurrent programming|concurrent]], distributed programming
! {{anchor|C++|[[C++]]}}
| {{no}}
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]]
| strong
|{{yes|Yes, [[ISO]] [[C++98]]/[[C++11]]}}
|
|strong
|
|safe (unsafe allowed)
|
|explicit, partially implicit
| dynamic
|nominative, structural
| Telecom and distributed applications
|static, dynamic
| Fault tolerance, Scalability
|by value, by reference (through reference types)
|{{optional}} through [[wp:Boehm-GC|external tools]]
|Application, System
|Abstraction, Efficiency, Compatibility
|-
|-

! [[Forth]]

| [[imperative programming]], [[stack]]-oriented
| {{yes}}, [[ANSI]]
! {{anchor|Chapel|[[Chapel]]}}
|[[concurrent]], [[generic programming|generic]], [[object-oriented]], [[imperative programming|imperative]], [[:Category:Programming paradigm/Distributed|distributed]], [[reflective programming|reflective]]
| none
|{{no|No, still under development, a [http://chapel.cray.com/spec/spec-0.93.pdf preliminary language specification] exists}}
| n/a
|strong
| n/a
|safe
| n/a
|explicit, partially inferred
| n/a
|nominative
| Application, Embedded systems
|static
| Compact implementations
|by value, by reference
|No
|High Performance Computing
|Programmer productivity (compared to C/Fortran), performance
|-
|-

! [[Fortran]]

| [[imperative programming]], [[procedural programming]], [[object-oriented]]
! {{anchor|Clean|[[Clean]]}}
| {{yes}}
|[[functional programming|functional]], [[generic programming|generic]]
| strong
| safe
|{{no}}
|strong
|
|
| nominative
|implicit
| static
|
| Scientific and numeric applications
|static
| Runtime efficiency, Simple syntax
|
|{{yes}}
|General
|Correctness, Modularity
|-
|-

! [[Groovy]]

| [[imperative programming]], [[object-oriented]], [[aspect-oriented programming]]
! {{anchor|Clojure|[[Clojure]]}}
| {{no}}
|[[functional programming|functional]], [[concurrent programming|concurrent]]
| strong
|
| safe
|strong
| implicit
|safe
|
|
| dynamic
|
| Application
|dynamic, static
| [[JVM]] compatibility
|
|{{yes}}
|
|
|-
|-

! [[Haskell]]

| [[functional programming]], [[generic programming]], [[lazy evaluation]]
! {{anchor|COBOL|[[COBOL]]}}
| {{no}}
|[[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)}}
|
|strong
| implicit
|safe
| structural
|explicit
| static
|
| Application
|static
| [[lazy evaluation]], Explicit side-effect
|by value, by reference
|{{no}}
|Business and Financial Applications
|Readability
|-
|-

! [[J]]

| [[array]] programming, function-level programming, [[tacit programming]]
! {{anchor|ColdFusion|[[ColdFusion]]}}
| {{no}}
|[[procedural programming|procedural]], [[object-oriented]]
| strong
|{{no}}
| safe
|weak
|
|
|
|implicit
| dynamic
|
| Data processing
|dynamic
| Terseness, Expressiveness, Powerful Data Manipulation
|
|
|Web Development
|Rapid Application Development, Ease of use
|-
|-

! [[Java]]

| [[imperative programming]], [[object-oriented]], [[generic programming]], [[reflective programming]]
! {{anchor|Common Lisp|[[Common Lisp]]}}
| {{no}}
|[[imperative programming|imperative]], [[functional programming|functional]], [[object-oriented]]
| strong
|{{yes}}
| safe
|strong
| explicit
|safe
| nominative
|
| static
|
| Application
|dynamic, static
| Write once run anywhere
|
|{{yes}}
|General
|Standardize [[Lisp]]
|-
|-

! [[JavaScript]]

| [[imperative programming]], [[object-oriented]], [[functional programming]], [[reflective programming]]
| {{yes}}
! {{anchor|D|[[D]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]]
| weak
|{{no}}
|
|strong
|
|safe
|
|explicit, optional inferred
| dynamic
|nominative, structural
| Client side web scripting
|static, dynamic
|
|by value, by reference (through reference types)
|{{yes}}
|Application, System
|Compilability, Correctness, Efficiency
|-
|-

! [[Joy]]

| [[functional programming]], [[stack]]-oriented
! {{anchor|Dao|[[Dao]]}}
| {{no}}
|[[object-oriented]]
| strong
|
| safe
|strong
|
|safe, unsafe allowed
|
|implicit, explicit
| dynamic
|
| [[functional programming]] research
|static, dynamic
| [[concatenative]]
|
|{{yes}}
|
|
|-
|-

! [[Lisp]]
! {{anchor|Dyalect|[[Dyalect]]}}
| [[functional programming]], reflective; others vary by dialect
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]]
| {{no}}
|{{no}}
| strong
|strong
|
|safe
|
|implicit
|
|duck
| dynamic
|dynamic
| General
|by reference
| Simple notation for Lambda calculus, Homoiconicity
|{{yes}}
|Application
|Portable dynamic scripting language with consistent design and modern syntax
|-
|-

! [[Lua]]

| [[procedural programming]], [[imperative programming]], [[reflective programming|reflective]]
! {{anchor|Dylan|[[Dylan]]}}
| {{no}}
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]], [[procedural programming|procedural]]
| strong
|
| safe
|strong
| implicit
|safe
|
|
| dynamic
|
| Host-driven Scripting
|static, dynamic
| Small, embedded, configuration.
|
|{{yes}}
|
|
|-
|-

! [[Mathematica]]

| [[functional programming]], [[procedural programming]]
| {{no}}
! {{anchor|E|[[E]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[object-capability]], [[communicating event loops]]
| strong
|<!-- Std -->{{no}}, still in development
|
|<!-- Strength -->strong (runtime)
|
|<!-- Safety -->safe
|
|<!-- Expr -->optional explicit
| dynamic
|<!-- Compat -->duck
| Numeric computation and visualization
|<!-- 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
|-
|-

! [[Object Pascal]] ([[Delphi]])

| [[imperative programming]], [[object-oriented]], [[generic programming]]
| {{no}}
! {{anchor|EC|[[eC]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]]
| strong
|{{no}}
| safe (but unsafe allowed)
|weak
| explicit
|unsafe
| nominative
|explicit, partially implicit
| static
|nominative, complex conversions system
| Application, System
|static, dynamic
| Readability, Rapid application development, Modularity
|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
|-
|-

! [[Objective-C]]

| [[imperative programming]], [[object-oriented]], [[reflective programming]]
! {{anchor|Ecstasy|[[Ecstasy]]}}
| {{yes}}
|[[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]], [[functional programming|functional]], [[imperative programming|imperative]]
| weak
|{{no|No}}
|
|strong
| explicit
|safe
|
|explicit, optionally inferred
| static
|nominative; duck for interface types
| Application
|static; dynamic for generic edge conditions
| Smalltalk like, Component based code reuse, C compatibility
|by value; by reference
|{{yes}}
|Application
|Predictable, Secure, Composable
|-
|-

! [[Ocaml]]

| [[object-oriented]], [[functional programming]], [[imperative programming]], generic programming
! {{anchor|Eiffel|[[Eiffel]]}}
| {{no}}
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]]
| strong
|{{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]}}
| safe
|strong
| implicit
|safe
| structural
|
| static
|nominative
| Application
|static
| Efficiency, Robustness, Correctness
|
|{{yes}}
|Application
|Correctness, Efficiency, Design by contract

|-
|-

! [[Oz]]

| logic programming, [[functional programming]], [[imperative programming]], [[object-oriented]], [[concurrent programming]] - multi paradigm
! {{anchor|Ela|[[Ela]]}}
| {{no}}
|[[functional programming|functional]]
|
|{{no}}
|
|strong
|
|safe
|
|implicit
| dynamic
|duck
| Education
|dynamic
|
|by reference
|{{yes}}
|Application
|
|-
|-

! [[Pascal]]
| [[imperative programming]], [[procedural programming]]
| {{yes}}
| strong
| safe
| explicit
|
| static
| Education
| Readability, Discipline, Modularity
|-
|-

! [[Perl]]

| [[imperative programming]], [[procedural programming]], [[reflective programming]], [[functional programming]], [[object-oriented]], [[generic programming]]
! {{anchor|Elm|[[Elm]]}}
| {{no}}
|[[functional programming|functional]], functional reactive programming, [[declarative programming|declarative]], pattern matching
| weak
|{{no}}
|
|strong
| implicit
|safe
|
|inferred, optional explicit annotations
| dynamic
|
| Text processing, Scripting
|static
| Terseness, Expressiveness
|immutable data structures, syntactically by value, time-varying with Signals
|{{yes}}
|Web Development, GUIs, Applications, Games
|Simple, Modular, Safe, Reactive
|-
|-

! [[PHP]]
| [[imperative programming]], [[object-oriented]], [[reflective programming]]
| {{no}}
| weak
|
|
|
| dynamic
| Web Application, CLI
| Robustness and Simplicity
|-
|-

! [[Prolog]]

| logic programming
| {{yes}}, [[ISO]]
! {{anchor|Elena|[[Elena]]}}
|[[object-oriented]]
| strong
|
|
|strong
|
|safe
|
|implicit
| dynamic
|
| Problem solving, Artificial intelligence
|dynamic
| [[declarative programming]]
|
|{{yes}}
|
|
|-
|-

! [[Python]]

| [[imperative programming]], [[object-oriented]], [[functional programming]], [[aspect-oriented programming]], [[reflective 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
| implicit
|safe
|
|implicit
| dynamic
|
| Application, Education, Scripting
|dynamic
| Simplicity, Readability, Expressiveness, Modularity
|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
|-
|-

! [[Ruby]]

| [[imperative programming]], [[object-oriented]], [[aspect-oriented programming]], [[reflective programming]]
! {{anchor|ERRE|[[ERRE]]}}
| {{no}}
|[[imperative programming|imperative]], [[procedural programming|procedural]]
| strong
|{{no}}
|
|weak
| implicit
|unsafe
|
|explicit
| dynamic
|
| Application, Scripting
|static and dynamic
| Expressiveness, Readability
|by value
|{{yes}}
|Education
|Readability, Modularity
|-
|-

! [[Scala]]

| [[object-oriented]], [[functional programming]], [[generic programming]]
! {{anchor|Factor|[[Factor]]}}
| {{no}}
|[[stack]]-oriented
| strong
|<!-- Std -->{{no}}
|
|<!-- Strength -->
| partially implicit
|<!-- Safety -->safe
|
|<!-- Expr -->implicit
| static
|<!-- Compat -->duck
| Education
|<!-- Check -->dynamic
|
|<!-- Passing -->by reference
|<!-- GC -->{{yes}}
|<!-- Uses -->
|<!-- Design goals -->x
|-
|-

! [[Scheme]]

| [[functional programming]]
! {{anchor|Forth|[[Forth]]}}
| {{yes}}
|[[imperative programming|imperative]], [[stack]]-oriented
| strong
|{{yes|Yes, [[ANSI]], [https://www.iso.org/standard/26479.html ISO/IEC 15145:1997]}}
|
|none
|
|
|n/a
|n/a
| dynamic (latent)
|n/a
| General, Education
|n/a
| Minimalistic, Lexical Scoping
|
|{{no}}
|Applications, High reliability, Embedded systems, Booting new hardware.
|Compact implementations, Low level access, Interactive programming, CPU agnostic Assembler Alternative, ultra-small memory systems.
|-
|-

! [[Smalltalk]]

| [[object-oriented]], [[concurrent programming]], [[event-driven programming]], [[imperative programming]], [[declarative programming]]
| {{yes}}, [[ANSI]]
! {{anchor|Fortran|[[Fortran]]}}
|[[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
| implicit
|safe
|
|explicit, partially implicit
| dynamic
|nominative
| Application, Education
|static, dynamic
| Uniformity, Pure object oriented
|by reference, or explicitly by value
|{{no}}
|Scientific and numeric applications
|Runtime efficiency, Simple syntax
|-
|-

! [[Tcl]]

| [[imperative programming]], [[procedural programming]], [[event-driven programming]]
! {{anchor|FutureBasic|[[FutureBasic]]}}
| {{no}}
|[[procedural programming|procedural]]
|
|{{no|No}}
|
|strong
|
|
|
|
| dynamic
|nominative
| Application, Scripting
|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
|-
|-

! [[Visual Basic]]

| component-oriented programming, [[event-driven programming]]
! {{anchor|Gambas|[[Gambas]]}}
| {{no}}
|[[object-oriented|object-oriented]]
| strong
|<!-- Std -->{{no}}
| safe
|<!-- Strength -->strong
|
|<!-- Safety -->safe
| nominative
|<!-- Expr -->explicit
| static
|<!-- Compat -->
| Application
|<!-- Check -->dynamic
| Rapid application development, Simplicity
|<!-- Passing -->by value, by reference
|<!-- GC -->
|<!-- Uses -->Application, Scripting
|<!-- Design goals -->Rapid application development, Visual Basic alternative
|-
|-

! [[Visual Basic .NET]]

| [[object-oriented]], [[event-driven programming]]
| {{no}}
! {{anchor|Go|[[Go]]}}
|[[concurrent programming|concurrent]], [[classless-objects|classless]]
| strong
|<!-- Std -->{{no}}, [http://golang.org/ref/spec language specification] available
|
|<!-- Strength -->strong
|
|<!-- Safety -->safe
|
|<!-- Expr -->explicit, optionally inferred
| static
|<!-- Compat -->nominative; structural for interface types
| Application
|<!-- Check -->static
| Rapid application development, Simplicity
|<!-- Passing -->by value
|<!-- GC -->{{yes}}
|<!-- Uses -->
|<!-- Design goals -->
|-
|-

! [[Windows PowerShell]]

| [[imperative programming]], [[object-oriented]], [[functional programming]], [[pipeline programming]], [[reflective programming]]
! {{anchor|Gosu|[[Gosu]]}}
| {{no}}
|[[imperative programming|imperative]], [[object-oriented]], [[generic programming|generic]], [[functional programming|functional]]
| strong
|{{yes|Yes}}
| safe
|strong
| implicit
|safe
|
|explicit, optionally inferred
| dynamic
|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}}
|Application
|[[JVM]] compatibility
|-


! {{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
| 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|Unicon]] for the unified extended dialect of Icon.
|-

! {{anchor|Insitux|[[Insitux]]}}
|[[functional programming|functional]], [[imperative programming|imperative]]
|{{no}}
|strong
|safe
|implicit
|
|dynamic
|by value
|{{yes}}
|Host-driven scripting
|Host-extensibility; provide "safe" modding e.g. timeout infinite loops, memory limits; concise code
|-

! {{anchor|Io|[[Io]]}}
|[[object-oriented]], [[classless-objects|classless]], prototype
|{{no}}
|strong
|
|
|
|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
|-


! {{anchor|JavaScript|[[JavaScript]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[classless-objects|classless]], [[functional programming|functional]], [[reflective programming|reflective]]
|{{yes|Yes, [[ECMAScript standard]]}}
|weak
|
|implicit
|
|dynamic
|by value
|{{yes}}
|Client side web scripting
|
|-


! {{anchor|Joy|[[Joy]]}}
|[[functional programming|functional]], [[stack]]-oriented
|{{no}}
|strong
|safe
|
|
|dynamic
|
|
|[[functional programming|functional]] research
|[[concatenative programming|concatenative]]
|-

! {{anchor|jq|[[jq]]}}
|[[functional programming|functional]], [[tacit programming|tacit (point-free)]], [[dataflow programming|dataflow]]
|<!-- Std -->{{no|No, but a de facto standard exists in the agreement between the C and Go-based versions}}
|<!-- Strength -->weak
|<!-- Safety -->safe
|<!-- Expr -->implicit
|<!-- Compat -->n.a.
|<!-- Check -->dynamic
|<!-- Passing -->by value, with limited support for closures
|<!-- GC -->{{yes}}
|<!-- Uses -->Processing streams of JSON documents or strings; gojq also supports YAML
|<!-- Design goals -->Turing-completeness; ease of use and economy of expression within functional/dataflow programming frameworks
|-


! {{anchor|Kabap|[[Kabap]]}}
|[[imperative programming|imperative]], [[Dynamic programming|dynamic]], extensible
|{{yes}}
|weak
|unsafe
|implicit
|duck
|dynamic
|by value
|
|User scripting, general
|Safe sandboxed, easy to learn, easier to implement. Use to avoid eval() & reflection
|-


! {{anchor|Keg|[[Keg]]}}
|[[imperative programming|imperative]], [[Concatenative programming|concatenative]]
|{{no}}
|untyped
|unsafe
|implicit
|nominative
|dynamic
|by reference
|{{no}}
|Code Golf, general
|Be simple, readable, and concise
|-


! {{anchor|Kotlin|[[Kotlin]]}}
|[[imperative programming|imperative]], [[object-oriented]],
[[procedural programming|procedural]], [[functional programming|functional]],
[[generic programming|generic]], [[reflective programming|reflective]]
|{{no}}
|strong
|safe
|explicit, optionally inferred
|nominative
|static, dynamic (JS only)
|by value (read-only)
|{{yes}}
|Application
|Pragmatic language for modern multi-platform applications with compilers for JVM, JS and Native code
|-


! {{anchor|LDPL|[[LDPL]]}}
|[[imperative programming|imperative]]
|{{no}}
|strong
|safe
|explicit
|
|static
|
|{{no}}
|Portable applications, readable source codes, teaching
|Readability
|-


! {{anchor|LFE|[[LFE]]}}
|[[functional programming|functional]], [[concurrent programming|concurrent]], [[:Category:Programming paradigm/Distributed|distributed]], [[declarative programming|declarative]] - pattern matching, [[imperative programming|imperative]]
|{{no}}
|strong
|safe
|implicit
|
|dynamic
|immutable data structures, syntactically by value but safe sharing of compound data types
|{{yes}}
|Telecom and distributed applications
|Fault tolerance, Reliability - Nonstop Running, Hot Code Change, Safety, Concurrency, Distribution, Scalability
|-


! {{anchor|Lisp|[[Lisp]]}}
|[[functional programming|functional]], [[reflective programming|reflective]]; others vary by dialect
|{{no}}
|strong
|
|
|
|dynamic
|
|{{yes}}
|General
|Simple notation for Lambda calculus, Homoiconicity
|-


! {{anchor|Logo|[[Logo]]}}
|[[procedural programming|procedural]], [[functional programming|functional]]
|{{no}}
|strong
|safe
|implicit
|structural
|dynamic
|
|{{yes}}
|Education
|Simple syntax, Turtle graphics, Interactive programming
|-


! {{anchor|Lua|[[Lua]]}}
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[classless-objects|classless]], [[reflective programming|reflective]]
|{{no}}
|strong
|safe
|implicit
|
|dynamic
|
|{{yes}}
|Host-driven Scripting
|Small, embedded, configuration.
|-


! {{anchor|Lucid|[[Lucid]]}}
|[[dataflow programming|dataflow]], [[functional programming|functional]]
|{{no}}
|strong
|safe
|
|
|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
|-


! {{anchor|Mathematica|[[Mathematica]]}}
|[[functional programming|functional]], [[procedural programming|procedural]]
|{{no}}
|strong
|
|
|
|dynamic
|
|{{yes}}
|Numeric and symbolic computation, visualization
|
|-


! {{anchor|MATLAB|[[MATLAB]]}}
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[array]] programming
|{{no|No, however the language is also implemented in [[Octave]] and [[FreeMat]]}}
|strong
|unsafe
|
|
|dynamic
|by value
|{{yes}}
|Numeric computation and visualization
|At the beginning designed as interpreter for easy use of fortran libraries, nowadays high performance numerical analysis and visualization
|-


! {{anchor|MAXScript|[[MAXScript]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[procedural programming|procedural]]
|{{no}}
|strong
|safe
|implicit
|
|dynamic
|by value, by reference
|
|3D Art Tools, Scripting
|Simplicity, Accessibilty
|-


! {{anchor|Modula-3|[[Modula-3]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[procedural programming|procedural]], [[generic programming|generic]]
|{{no}}
|strong
|safe (unsafe allowed)
|explicit
|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
|-


! {{anchor|Nial|[[Nial]]}}
|[[functional programming|functional]], [[array]] programming
|{{no}}
|strong
|
|
|
|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
|-


! {{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
|-


! {{anchor|Objective-C|[[Objective-C]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[reflective programming|reflective]], [[generic programming|generic]] (as of Xcode 7)
|{{no}}
|weak
|
|explicit
|
|static
|by value
|{{yes|Yes (as of 2.0)}}
|Application
|[[Smalltalk]] like, Component based code reuse, [[C]]/[[C++]] compatibility
|-


! {{anchor|OCaml|[[OCaml]]}}
|[[object-oriented]], [[functional programming|functional]], [[imperative programming|imperative]], [[generic programming|generic]]
|{{no|No, [http://caml.inria.fr/pub/docs/manual-ocaml/index.html the manual] includes language specification}}
|strong
|safe
|inferred, optional explicit annotations
|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
|
|-


! {{anchor|PARI/GP|[[PARI/GP]]}}
|[[imperative programming|imperative]], [[procedural programming|procedural]]
|{{no}}
|weak
|unsafe
|implicit
|nominal
|dynamic
|by value, by reference
|{{yes}}
|Mathematics, especially number theory
|
|-


! {{anchor|Pascal|[[Pascal]]}}
|[[imperative programming|imperative]], [[procedural programming|procedural]]
|{{yes| [https://www.iso.org/standard/13802.html ISO 7185:1990] and [https://www.iso.org/standard/18237.html ISO 10206:1991]}}
|strong
|safe
|explicit
|
|static (some dialects also dynamic)
|by reference, by value
|{{no}}
|General, Application, Education, System
|Readability, Discipline, Modularity
|-


! {{anchor|Perl|[[Perl]]}}
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[reflective programming|reflective]], [[functional programming|functional]], [[object-oriented]], [[generic programming|generic]]
|{{no}}
|weak
|
|implicit
|
|dynamic, static
|by reference
|{{optional|Reference counting}}
|Text processing, Scripting
|Terseness, Expressiveness
|-


! {{anchor|Phix|[[Phix]]}}
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[object-oriented]]
|<!-- Std -->{{no}}
|<!-- Strength -->strong
|<!-- Safety -->safe
|<!-- Expr -->explicit, partially implicit
|<!-- Compat -->duck
|<!-- Check -->dynamic, static
|<!-- Passing -->copy on write, immutable reference, multiple returns
|<!-- GC -->{{optional|Reference counting or JavaScript compatible}}
|<!-- Uses -->Application, Educational, General, High-level scripting, Text processing
|<!-- Design goals -->Simplicity, Readability, Ease of use
|-


! {{anchor|PHP|[[PHP]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[reflective programming|reflective]]
|{{no}}
|weak
|
|
|
|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&nbsp;Perl&nbsp;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&nbsp;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), &nbsp; but some REXX implementations don't adhere to it.}}
|<!-- Type strength -->&nbsp; strong
|<!-- Type safety -->&nbsp; safe
|<!-- Expression of types -->&nbsp; inferred
|<!-- Type compatibility -->&nbsp; nominal
|<!-- Type checking -->dynamic &nbsp; (but only when both comparands are numeric &nbsp;''and''&nbsp; non─strict comparisons are used)
|<!-- Parameter Passing -->&nbsp; by&nbsp;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;&nbsp; to foster high quality programs by making writing them as simple and enjoyable as possible;&nbsp; designing each part of the language for people to use is more important than providing easy implementation;&nbsp; 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]]
![[Programming Language|Language]]
! [[:Category:Programming Paradigms|Paradigm(s)]]
![[:Category:Programming Paradigms|Paradigm(s)]]
! Standardized
!Standardized
! [[Type strength]]
![[Type strength]]
! [[Type safety]]
![[Type safety]]
! Expression of types
!Expression of types
! [[Type compatibility]]
![[Type compatibility]]
! Type checking
![[Type checking]]
![[Parameter Passing]] Methods Available
! Intended use
![[Garbage collection]]
! Design goals
!Intended use
!Design goals
|-

|}
|}



==External resources==
* [[wp:Comparison_of_programming_languages|Wikipedia: Comparison of programming languages]]

Latest revision as of 00:04, 9 March 2024


See also TL;DR (Brief descriptions of languages).

Language Paradigm(s) Standardized Type strength Type safety Expression of types Type compatibility Type checking Parameter Passing Methods Available Garbage collection Intended use Design goals
ACL2 functional Yes strong unsafe implicit dynamic immutable reference Yes Theorem proving Be logically sound, mimic Common Lisp
ActionScript imperative, object-oriented,distributed Yes, ECMA strong safe static Yes Web design
Ada concurrent, distributed, generic, imperative, object-oriented Yes strong safe explicit nominative static by value, by reference (compiler chosen if not determined by the data type) GC is allowed, but not mandated Embedded, real-time, mission-critical, long-lived, and large scale systems Reliability and maintenance, Programming as a human activity, Efficiency Language Reference Manual
ALGOL 68 concurrent, imperative Yes, GOST 27974-88 strong safe explicit structural static or dynamic (programmer chosen) by value or by reference (programmer chosen) Yes Application Completeness and clarity of design, Orthogonal design, Security, Efficiency (Static mode checking, Mode-independent parsing, Independent compilation, Loop optimization, Representations in minimal & larger character sets)
ALGOL W imperative No strong safe explicit nominative static or dynamic (programmer chosen) by value, by reference or by name (programmer chosen) Yes Application, Education
AmbientTalk concurrent strong safe explicit duck dynamic by value Mobile ad hoc networks
Arturo generic, imperative, functional, reflective, stack-based No, see official documentation strong implicit dynamic by value, by reference (literals) Yes General, Scripting, DSLs, Templating, Portable apps, GUI applications Simplicity, Expressiveness, Portability
AutoHotkey imperative, classless No untyped by value or by reference No End User Programming simplicity, speed, stability
AutoIt imperative by value or by reference General, scripting, GUI and tasks automation Simplicity
BASIC procedural Yes, ANSI, ISO varies by dialect varies by dialect Education Simplicity
Blade imperative, object-oriented, functional No strong safe implicit nominative dynamic by value, by reference (through pointers) Yes Scripting, Application Simple, Lightweight, CLI, Web, Desktop, Mobile
C imperative Yes, ANSI C89, ISO C90/C99 weak unsafe explicit nominative static by value, by reference (through pointers) Optional through external tools System, Embedded Low level access, Minimal constraint
C# imperative, object-oriented, generic, reflective, functional, event-driven Yes, ECMA, ISO strong safe (unsafe allowed) implicit nominative static, dynamic (for interop) by value, by reference (through managed pointers [explicitly in, out, or in-out]) Yes Application Rapid application development
C++ imperative, object-oriented, generic Yes, ISO C++98/C++11 strong safe (unsafe allowed) explicit, partially implicit nominative, structural static, dynamic by value, by reference (through reference types) Optional through external tools Application, System Abstraction, Efficiency, Compatibility
Chapel concurrent, generic, object-oriented, imperative, distributed, reflective No, still under development, a preliminary language specification exists strong safe explicit, partially inferred nominative static by value, by reference No High Performance Computing Programmer productivity (compared to C/Fortran), performance
Clean functional, generic No strong implicit static Yes General Correctness, Modularity
Clojure functional, concurrent strong safe dynamic, static Yes
COBOL imperative, object-oriented Yes, ANSI 68, 74, 85 (and subsequent revisions); ECMA; ISO 1989:2023 (and previous version in 1978, 1985, 2002, 2014) strong safe explicit static by value, by reference No Business and Financial Applications Readability
ColdFusion procedural, object-oriented No weak implicit dynamic Web Development Rapid Application Development, Ease of use
Common Lisp imperative, functional, object-oriented Yes strong safe dynamic, static Yes General Standardize Lisp
D imperative, object-oriented, generic No strong safe explicit, optional inferred nominative, structural static, dynamic by value, by reference (through reference types) Yes Application, System Compilability, Correctness, Efficiency
Dao object-oriented strong safe, unsafe allowed implicit, explicit static, dynamic Yes
Dyalect imperative, object-oriented, functional No strong safe implicit duck dynamic by reference Yes Application Portable dynamic scripting language with consistent design and modern syntax
Dylan imperative, object-oriented, functional, procedural strong safe static, dynamic Yes
E imperative, object-oriented, object-capability, communicating event loops No

, still in development

strong (runtime) safe optional explicit duck dynamic by value Yes Secure collaboration, distributed systems, running untrusted applications, high-level "scripting" Familiarity to C/Java/JS users; less error-prone concurrency & security
eC imperative, object-oriented, generic, reflective No weak unsafe explicit, partially implicit nominative, complex conversions system static, dynamic according to data type, or explicitly by value, by reference Reference counting Applications, GUIs, System, Games Elegance, Performance, Simplicity, Lightness, 99.9% C compatibility
Ecstasy object-oriented, generic, reflective, functional, imperative No strong safe explicit, optionally inferred nominative; duck for interface types static; dynamic for generic edge conditions by value; by reference Yes Application Predictable, Secure, Composable
Eiffel imperative, object-oriented, generic Yes strong safe nominative static Yes Application Correctness, Efficiency, Design by contract
Ela functional No strong safe implicit duck dynamic by reference Yes Application
Elm functional, functional reactive programming, declarative, pattern matching No strong safe inferred, optional explicit annotations static immutable data structures, syntactically by value, time-varying with Signals Yes Web Development, GUIs, Applications, Games Simple, Modular, Safe, Reactive
Elena object-oriented strong safe implicit dynamic Yes
Erlang functional, concurrent, distributed, declarative - pattern matching, imperative No strong safe implicit dynamic immutable data structures, syntactically by value but safe sharing of compound data types Yes Telecom and mission critical distributed applications Fault tolerance, Reliability - Nonstop Running, Hot Code Change, Safety, Concurrency, Distribution, Scalability
ERRE imperative, procedural No weak unsafe explicit static and dynamic by value Yes Education Readability, Modularity
Factor stack-oriented No safe implicit duck dynamic by reference Yes x
Forth imperative, stack-oriented Yes, ANSI, ISO/IEC 15145:1997 none n/a n/a n/a n/a No Applications, High reliability, Embedded systems, Booting new hardware. Compact implementations, Low level access, Interactive programming, CPU agnostic Assembler Alternative, ultra-small memory systems.
Fortran imperative, procedural, object-oriented, (partially) generic, concurrent Yes strong safe explicit, partially implicit nominative static, dynamic by reference, or explicitly by value No Scientific and numeric applications Runtime efficiency, Simple syntax
FutureBasic procedural No strong nominative static by value, by reference (through pointers) Yes Educational, Scientific, Prototyping, Commercial Level Applications Mac Freeware, Readability, Simplicity, Efficiency, C/Objective-C Compatibility, Objective-C Alternative, Builds Xcode Projects
Gambas object-oriented No strong safe explicit dynamic by value, by reference Application, Scripting Rapid application development, Visual Basic alternative
Go concurrent, classless No

, language specification available

strong safe explicit, optionally inferred nominative; structural for interface types static by value Yes
Gosu imperative, object-oriented, generic, functional Yes strong safe explicit, optionally inferred nominative and structural static by value Yes Application Open type system, optional dynamic loading
Groovy imperative, object-oriented, aspect-oriented No strong safe implicit nominative dynamic Yes Application JVM compatibility
Haskell functional, generic, lazy evaluation Yes, Haskell 2010 Report, Haskell 98 Report strong safe inferred, optional explicit annotations polymorphic structural static Yes Application, Research lazy evaluation, Teaching and research, completely formally described Report Preface
Huginn imperative, object-oriented, functional No, language reference included with each version's documentation strong safe implicit dynamic by reference Reference counting Education, Application, Scripting, Interactive system shell Consistency, Simplicity, Readability, Expressiveness, Modularity
icon procedural, structured, goal directed, string scanning, co-expressions No strong Safe implicit nominative dynamic by value and safe reference depending if the type is mutable or immutable Yes Text analysis, text editing, document formatting, artificial intelligence, expert systems, rapid prototyping, symbolic mathematics, text generation, and data laundry Facilitates ease of programming, short concise programs, automatic storage allocation and management, provide a rich base of basic data types and structures, and platform independence. Also see Unicon for the unified extended dialect of Icon.
Insitux functional, imperative No strong safe implicit dynamic by value Yes Host-driven scripting Host-extensibility; provide "safe" modding e.g. timeout infinite loops, memory limits; concise code
Io object-oriented, classless, prototype No strong dynamic Yes
J array programming, function-level programming, tacit No strong safe inferred structural dynamic by value, by name, by address for memory mapped files (and, indirectly, for foreign languages) Yes Data processing, expressing concepts algorithms and architectures Describe computers mathematically and concisely
Java imperative, object-oriented, generic, reflective Yes, Java SE Specifications strong safe explicit nominative static by value Yes Application Write once run anywhere
JavaScript imperative, object-oriented, classless, functional, reflective Yes, ECMAScript standard weak implicit dynamic by value Yes Client side web scripting
Joy functional, stack-oriented No strong safe dynamic functional research concatenative
jq functional, tacit (point-free), dataflow No, but a de facto standard exists in the agreement between the C and Go-based versions weak safe implicit n.a. dynamic by value, with limited support for closures Yes Processing streams of JSON documents or strings; gojq also supports YAML Turing-completeness; ease of use and economy of expression within functional/dataflow programming frameworks
Kabap imperative, dynamic, extensible Yes weak unsafe implicit duck dynamic by value User scripting, general Safe sandboxed, easy to learn, easier to implement. Use to avoid eval() & reflection
Keg imperative, concatenative No untyped unsafe implicit nominative dynamic by reference No Code Golf, general Be simple, readable, and concise
Kotlin imperative, object-oriented,

procedural, functional, generic, 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
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
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)



REXX (Restructured Extended Exxecutor) is an interpreted computer programming language developed at IBM by Mike Cowlishaw circa 1979

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


External resources

Retrieved from "https://rosettacode.org/wiki/Language_Comparison_Table?oldid=361402"