Language Comparison Table: Difference between revisions

From Rosetta Code
Content added Content deleted
(Anchors away!)
m (A little whitespace and extra text cleanup)
Line 1: Line 1:
[[Category:Encyclopedia]]
[[Category:Encyclopedia]]
{|class="wikitable sortable"
{|class="wikitable sortable"
! [[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
![[Parameter Passing]] Methods Available
! [[Garbage collection|Garbage Collected]]
![[Garbage collection]]
! Intended use
!Intended use
! Design goals
!Design goals
|-
|-
! {{anchor|ActionScript|[[ActionScript]]}}
! {{anchor|ActionScript|[[ActionScript]]}}
| [[imperative programming]], [[object-oriented]], [[event-driven programming]]
|[[imperative programming]], [[object-oriented]], [[event-driven programming]]
| {{yes}}, [[ECMA]]
|{{yes}}, [[ECMA]]
| strong
|strong
| safe
|safe
|
|
|
|
| static
|static
|
|{{yes}}
|Web design
|
|
| {{yes}}
| Web design
|
|-
|-
! {{anchor|Ada|[[Ada]]}}
! {{anchor|Ada|[[Ada]]}}
| [[concurrent programming|concurrent]], [[distributed programming]], [[generic programming]], [[imperative programming]], [[object-oriented]]
|[[concurrent programming]], [[distributed programming]], [[generic programming]], [[imperative programming]], [[object-oriented]]
| {{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]
|{{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
|strong
| safe
|safe
| explicit
|explicit
| nominative
|nominative
| static
|static
| by value, by reference (compiler chosen if not determined by the data type)
|by value, by reference (compiler chosen if not determined by the data type)
| {{optional|GC is allowed, but not mandated}}
|{{optional|GC is allowed, but not mandated}}
| Embedded, [[real-time computing|real-time]], mission-critical, long-lived, and large scale systems
|Embedded, [[real-time computing|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]
|Reliability and maintenance, Programming as a human activity, Efficiency [http://www.adaic.com/standards/05rm/html/RM-0-3.html Language Reference Manual]
|-
|-
! {{anchor|ALGOL_68|[[ALGOL 68]]}}
! {{anchor|ALGOL_68|[[ALGOL 68]]}}
| [[concurrent programming|concurrent]], [[imperative programming]]
|[[concurrent programming|concurrent]], [[imperative programming]]
| {{yes}}, [http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf GOST 27974-88]
|{{yes}}, [http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf GOST 27974-88]
| strong
|strong
| safe
|safe
| explicit
|explicit
| structural
|structural
| static or dynamic (programmer chosen)
|static or dynamic (programmer chosen)
| by value or by reference (programmer chosen)
|by value or by reference (programmer chosen)
| {{yes}}
|{{yes}}
| Application
|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)
|Completeness and clarity of design, Orthogonal design, Security, Efficiency (Static mode checking, Mode-independent parsing, Independent compilation, Loop optimization, Representations in minimal & larger character sets)
|-
|-
! {{anchor|AutoHotkey|[[AutoHotkey]]}}
! {{anchor|AutoHotkey|[[AutoHotkey]]}}
| [[imperative programming]]
|[[imperative programming]]
| {{no}}
|{{no}}
| untyped
|untyped
|
|
|
|
|
|
|
|
| by value or by reference
|by value or by reference
| {{no}}
|{{no}}
| End User Programming
|End User Programming
| simplicity, speed, stability
|simplicity, speed, stability
|-
|-
! {{anchor|BASIC|[[BASIC]]}}
! {{anchor|BASIC|[[BASIC]]}}
| [[procedural programming]]
|[[procedural programming]]
| {{yes}}, [[ANSI]], [[ISO]]
|{{yes}}, [[ANSI]], [[ISO]]
| varies by dialect
|varies by dialect
|
|
|
|
|
|
|
| {{optional|varies by dialect}}
|
| Education
|
| Simplicity
|
|{{optional|varies by dialect}}
|Education
|Simplicity
|-
|-
! {{anchor|C|[[C]]}}
! {{anchor|C|[[C]]}}
| [[imperative programming]]
|[[imperative programming]]
| {{yes}}, [[ANSI]] [[C89]], [[ISO]] [[C90]]/[[C99]]
|{{yes}}, [[ANSI]] [[C89]], [[ISO]] [[C90]]/[[C99]]
| weak
|weak
| unsafe
|unsafe
| explicit
|explicit
| nominative
|nominative
| static
|static
| by value, by reference (through pointers)
|by value, by reference (through pointers)
| {{no}}
|{{no}}
| System, Embedded
|System, Embedded
| Low level access, Minimal constraint
|Low level access, Minimal constraint
|-
|-
! {{anchor|C_Sharp|[[C sharp|C#]]}}
! {{anchor|C_Sharp|[[C sharp|C#]]}}
| [[imperative programming]], [[object-oriented]], [[generic programming]], [[reflective programming]]
|[[imperative programming]], [[object-oriented]], [[generic programming]], [[reflective programming]]
| {{yes}}, [[ECMA]], [[ISO]]
|{{yes}}, [[ECMA]], [[ISO]]
| strong
|strong
| safe (unsafe allowed)
|safe (unsafe allowed)
| implicit
|implicit
| nominative
|nominative
| static
|static
|
|
| {{yes}}
|{{yes}}
| Application
|Application
| Rapid application development
|Rapid application development
|-
|-
! {{anchor|C++|[[C++]]}}
! {{anchor|C++|[[C++]]}}
| [[imperative programming]], [[object-oriented]], [[generic programming]]
|[[imperative programming]], [[object-oriented]], [[generic programming]]
| {{yes}}, [[ISO]]
|{{yes}}, [[ISO]]
| strong
|strong
| safe (unsafe allowed)
|safe (unsafe allowed)
| explicit, partially implicit
|explicit, partially implicit
| nominative, structural
|nominative, structural
| static, dynamic
|static, dynamic
| by value, by reference (through reference types)
|by value, by reference (through reference types)
| {{no}}
|{{no}}
| Application, System
|Application, System
| Abstraction, Efficiency, Compatibility
|Abstraction, Efficiency, Compatibility
|-
|-
! {{anchor|Clean|[[Clean]]}}
! {{anchor|Clean|[[Clean]]}}
| [[functional programming]], [[generic programming]]
|[[functional programming]], [[generic programming]]
| {{no}}
|{{no}}
| strong
|strong
|
|
| implicit
|implicit
|
|
| static
|static
|
|
| {{yes}}
|{{yes}}
| General
|General
| Correctness, Modularity
|Correctness, Modularity
|-
|-
! {{anchor|COBOL|[[COBOL]]}}
! {{anchor|COBOL|[[COBOL]]}}
| [[imperative programming]], [[object-oriented]]
|[[imperative programming]], [[object-oriented]]
| {{yes}}
|{{yes}}
| strong
|strong
|
|
|
| static
|
|
|
| {{no}}
|
| Business and Financial Applications
|static
| Readability
|
|{{no}}
|Business and Financial Applications
|Readability
|-
|-
! {{anchor|ColdFusion|[[ColdFusion]]}}
! {{anchor|ColdFusion|[[ColdFusion]]}}
| [[procedural programming]], [[object-oriented]]
|[[procedural programming]], [[object-oriented]]
| {{no}}
|{{no}}
| weak
|weak
|
| implicit
|
| dynamic
|
|
|implicit
|
|
|dynamic
| Web Development
|
| Rapid Application Development, Ease of use
|
|Web Development
|Rapid Application Development, Ease of use
|-
|-
! {{anchor|Common Lisp|[[Common Lisp]]}}
! {{anchor|Common Lisp|[[Common Lisp]]}}
| [[imperative programming]], [[functional programming]], [[object-oriented]]
|[[imperative programming]], [[functional programming]], [[object-oriented]]
| {{yes}}
|{{yes}}
| strong
|strong
| safe
|safe
|
|
| dynamic, static
|
|
|
| {{yes}}
|dynamic, static
| General
|
| Standardize [[Lisp]]
|{{yes}}
|General
|Standardize [[Lisp]]
|-
|-
! {{anchor|D|[[D]]}}
! {{anchor|D|[[D]]}}
| [[imperative programming]], [[object-oriented]], [[generic programming]]
|[[imperative programming]], [[object-oriented]], [[generic programming]]
| {{no}}
|{{no}}
| strong
|strong
| safe, unsafe allowed
|safe, unsafe allowed
| explicit, optional inferred
|explicit, optional inferred
| nominative, structural
|nominative, structural
| static, dynamic
|static, dynamic
| by value, by reference (through reference types)
|by value, by reference (through reference types)
| {{yes}}
|{{yes}}
| Application, System
|Application, System
| Compilability, Correctness, Efficiency
|Compilability, Correctness, Efficiency
|-
|-
! {{anchor|E|[[E]]}}
! {{anchor|E|[[E]]}}
| [[imperative programming|imperative]], [[object-oriented]], [[object-capability]], [[communicating event loops]]
|[[imperative programming|imperative]], [[object-oriented]], [[object-capability]], [[communicating event loops]]
| <!-- Std -->{{no}}, still in development
|<!-- Std -->{{no}}, still in development
| <!-- Strength -->strong (runtime)
|<!-- Strength -->strong (runtime)
| <!-- Safety -->safe
|<!-- Safety -->safe
| <!-- Expr -->optional explicit
|<!-- Expr -->optional explicit
| <!-- Compat -->duck
|<!-- Compat -->duck
| <!-- Check -->dynamic
|<!-- Check -->dynamic
| <!-- Passing -->by value
|<!-- Passing -->by value
| <!-- GC -->{{yes}}
|<!-- GC -->{{yes}}
| <!-- Uses -->Secure collaboration, distributed systems, running untrusted applications, high-level “scripting”
|<!-- 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
|<!-- Design goals -->Familiarity to [[C]]/[[Java]]/[[JavaScript|JS]] users; less error-prone concurrency & security
|-
|-
! {{anchor|eC|[[eC]]}}
! {{anchor|eC|[[eC]]}}
| [[imperative programming]], [[object-oriented]], [[generic programming]], [[reflective programming]]
|[[imperative programming]], [[object-oriented]], [[generic programming]], [[reflective programming]]
| {{no}}
|{{no}}
| weak
|weak
| unsafe
|unsafe
| explicit, partially implicit
|explicit, partially implicit
| nominative, complex conversions system
|nominative, complex conversions system
| static, dynamic
|static, dynamic
| according to data type, or explicitly by value, by reference
|according to data type, or explicitly by value, by reference
| {{optional|Reference counting}}
|{{optional|Reference counting}}
| Applications, GUIs, System, Games
|Applications, GUIs, System, Games
| Elegance, Performance, Simplicity, Lightness, 99.9% [[C]] compatibility
|Elegance, Performance, Simplicity, Lightness, 99.9% [[C]] compatibility
|-
|-
! {{anchor|Eiffel|[[Eiffel]]}}
! {{anchor|Eiffel|[[Eiffel]]}}
| [[imperative programming]], [[object-oriented]], [[generic programming]]
|[[imperative programming]], [[object-oriented]], [[generic programming]]
| {{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]
|{{yes}}, [http://www.ecma-international.org/publications/standards/Ecma-367.htm ECMA-367], [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=42924 ISO/IEC 25436:2006]
| strong
|strong
| safe
|safe
|
|
| nominative
|nominative
| static
|static
|
|
| {{yes}}
|{{yes}}
| Application
|Application
| Correctness, Efficiency, Design by contract
|Correctness, Efficiency, Design by contract
|-
|-
! {{anchor|Erlang|[[Erlang]]}}
! {{anchor|Erlang|[[Erlang]]}}
| [[functional programming]], [[concurrent programming|concurrent]], [[distributed programming]]
|[[functional programming]], [[concurrent programming]], [[distributed programming]]
| {{no}}
|{{no}}
| strong
|strong
|
|
|
| dynamic
|
|
|
| {{yes}}
|
| Telecom and distributed applications
|dynamic
| Fault tolerance, Scalability
|
|{{yes}}
|Telecom and distributed applications
|Fault tolerance, Scalability
|-
|-
! {{anchor|Forth|[[Forth]]}}
! {{anchor|Forth|[[Forth]]}}
| [[imperative programming]], [[stack]]-oriented
|[[imperative programming]], [[stack]]-oriented
| {{yes}}, [[ANSI]]
|{{yes}}, [[ANSI]]
| none
|none
| n/a
|n/a
| n/a
|n/a
| n/a
|n/a
| n/a
|n/a
|
|
| {{no}}
|{{no}}
| Application, Embedded systems
|Application, Embedded systems
| Compact implementations, Low level access, Interactive programming
|Compact implementations, Low level access, Interactive programming
|-
|-
! {{anchor|Fortran|[[Fortran]]}}
! {{anchor|Fortran|[[Fortran]]}}
| [[imperative programming]], [[procedural programming]], [[object-oriented]]
|[[imperative programming]], [[procedural programming]], [[object-oriented]]
| {{yes}}, [[ISO]], [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=39691 ISO/IEC 1539-1:2004]
|{{yes}}, [[ISO]], [http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=39691 ISO/IEC 1539-1:2004]
| strong
|strong
| safe
|safe
|
| nominative
| static
|
|
|nominative
| {{no}}
|static
| Scientific and numeric applications
|
| Runtime efficiency, Simple syntax
|{{no}}
|Scientific and numeric applications
|Runtime efficiency, Simple syntax
|-
|-
! {{anchor|Groovy|[[Groovy]]}}
! {{anchor|Groovy|[[Groovy]]}}
| [[imperative programming]], [[object-oriented]], [[aspect-oriented programming]]
|[[imperative programming]], [[object-oriented]], [[aspect-oriented programming]]
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
| implicit
|implicit
|
| dynamic
|
|
|dynamic
| {{yes}}
|
| Application
|{{yes}}
| [[JVM]] compatibility
|Application
|[[JVM]] compatibility
|-
|-
! {{anchor|Haskell|[[Haskell]]}}
! {{anchor|Haskell|[[Haskell]]}}
| [[functional programming]], [[generic programming]], [[lazy evaluation]]
|[[functional programming]], [[generic programming]], [[lazy evaluation]]
| {{yes}}, [http://www.haskell.org/haskellwiki/Language_and_library_specification Haskell 98 Report]
|{{yes}}, [http://www.haskell.org/haskellwiki/Language_and_library_specification Haskell 98 Report]
| strong
|strong
| safe
|safe
| inferred, optional explicit annotations
|inferred, optional explicit annotations
| polymorphic structural
|polymorphic structural
| static
|static
|
|
| {{yes}}
|{{yes}}
| Application, Research
|Application, Research
| [[lazy evaluation]], Teaching and research, completely formally described [http://haskell.org/onlinereport/preface-jfp.html Report Preface]
|[[lazy evaluation]], Teaching and research, completely formally described [http://haskell.org/onlinereport/preface-jfp.html Report Preface]
|-
|-
! {{anchor|Io|[[Io]]}}
! {{anchor|Io|[[Io]]}}
| [[object-oriented]], prototype
|[[object-oriented]], prototype
| {{no}}
|{{no}}
| strong
|strong
|
|
|
|
|
|
| dynamic
|dynamic
|
|
| {{yes}}
|{{yes}}
|
|
|
|
|-
|-
! {{anchor|J|[[J]]}}
! {{anchor|J|[[J]]}}
| [[array]] programming, function-level programming, [[tacit programming]]
|[[array]] programming, function-level programming, [[tacit programming]]
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
|
|
|
|
| dynamic
|dynamic
|
|
|
|Data processing
|
|Terseness, Expressiveness, Powerful Data Manipulation
| Data processing
| Terseness, Expressiveness, Powerful Data Manipulation
|-
|-
! {{anchor|Java|[[Java]]}}
! {{anchor|Java|[[Java]]}}
| [[imperative programming]], [[object-oriented]], [[generic programming]], [[reflective programming]]
|[[imperative programming]], [[object-oriented]], [[generic programming]], [[reflective programming]]
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
| explicit
|explicit
| nominative
|nominative
| static
|static
| by value
|by value
| {{yes}}
|{{yes}}
| Application
|Application
| Write once run anywhere
|Write once run anywhere
|-
|-
! {{anchor|JavaScript|[[JavaScript]]}}
! {{anchor|JavaScript|[[JavaScript]]}}
| [[imperative programming]], [[object-oriented]], [[functional programming]], [[reflective programming]]
|[[imperative programming]], [[object-oriented]], [[functional programming]], [[reflective programming]]
| {{yes}}
|{{yes}}
| weak
|weak
|
|
| implicit
|implicit
|
|
| dynamic
|dynamic
|
|{{yes}}
|Client side web scripting
|
|
| {{yes}}
| Client side web scripting
|
|-
|-
! {{anchor|Joy|[[Joy]]}}
! {{anchor|Joy|[[Joy]]}}
| [[functional programming]], [[stack]]-oriented
|[[functional programming]], [[stack]]-oriented
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
|
|
| dynamic
|
|
|
|
|dynamic
| [[functional programming]] research
|
| [[concatenative]]
|
|[[functional programming]] research
|[[concatenative]]
|-
|-
! {{anchor|Lisp|[[Lisp]]}}
! {{anchor|Lisp|[[Lisp]]}}
| [[functional programming]], [[reflective programming]]; others vary by dialect
|[[functional programming]], [[reflective programming]]; others vary by dialect
| {{no}}
|{{no}}
| strong
|strong
|
|
|
| dynamic
|
|
|
| {{yes}}
|
| General
|dynamic
| Simple notation for Lambda calculus, Homoiconicity
|
|{{yes}}
|General
|Simple notation for Lambda calculus, Homoiconicity
|-
|-
! {{anchor|Logo|[[Logo]]}}
! {{anchor|Logo|[[Logo]]}}
| [[procedural programming]], [[functional programming]]
|[[procedural programming]], [[functional programming]]
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
| implicit
|implicit
| structural
|structural
| dynamic
|dynamic
|
|
| {{yes}}
|{{yes}}
| Education
|Education
| Simple syntax, Turtle graphics, Interactive programming
|Simple syntax, Turtle graphics, Interactive programming
|-
|-
! {{anchor|Lua|[[Lua]]}}
! {{anchor|Lua|[[Lua]]}}
| [[procedural programming]], [[imperative programming]], [[reflective programming|reflective]]
|[[procedural programming]], [[imperative programming]], [[reflective programming|reflective]]
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
| implicit
|implicit
|
|
| dynamic
|dynamic
|
|
| {{yes}}
|{{yes}}
| Host-driven Scripting
|Host-driven Scripting
| Small, embedded, configuration.
|Small, embedded, configuration.
|-
|-
! {{anchor|Lucid|[[Lucid]]}}
! {{anchor|Lucid|[[Lucid]]}}
| [[dataflow programming]], [[functional programming]]
|[[dataflow programming]], [[functional programming]]
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
|
|
| dynamic
|
|
|
|
|dynamic
| stream processing
|
| dataflow
|
|stream processing
|dataflow
|-
|-
! {{anchor|Mathematica|[[Mathematica]]}}
! {{anchor|Mathematica|[[Mathematica]]}}
| [[functional programming]], [[procedural programming]]
|[[functional programming]], [[procedural programming]]
| {{no}}
|{{no}}
| strong
|strong
|
|
|
| dynamic
|
|
|
| {{yes}}
|
| Numeric computation and visualization
|dynamic
|
|{{yes}}
|Numeric computation and visualization
|
|
|-
|-
! {{anchor|MAXScript|[[MAXScript]]}}
! {{anchor|MAXScript|[[MAXScript]]}}
| [[imperative programming]], [[object-oriented]], [[procedural programming]]
|[[imperative programming]], [[object-oriented]], [[procedural programming]]
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
| implicit
|implicit
|
| dynamic
| by value, by reference
|
|
|dynamic
| 3D Art Tools, Scripting
|by value, by reference
| Simplicity, Accessibilty
|
|3D Art Tools, Scripting
|Simplicity, Accessibilty
|-
|-
! {{anchor|Modula-3|[[Modula-3]]}}
! {{anchor|Modula-3|[[Modula-3]]}}
| [[imperative programming]], [[object-oriented]], [[procedural programming]], [[generic programming]]
|[[imperative programming]], [[object-oriented]], [[procedural programming]], [[generic programming]]
| {{no}}
|{{no}}
| strong
|strong
| safe (unsafe allowed)
|safe (unsafe allowed)
| explicit
|explicit
| structural
|structural
| static
|static
| by value, by reference
|by value, by reference
| {{yes}}
|{{yes}}
| Application, Systems
|Application, Systems
| Simple, Object oriented
|Simple, Object oriented
|-
|-
! {{anchor|Nial|[[Nial]]}}
! {{anchor|Nial|[[Nial]]}}
| [[functional programming]], [[array]] programming
|[[functional programming]], [[array]] programming
| {{no}}
|{{no}}
| strong
|strong
|
|
|
|
|
|
| dynamic
|dynamic
|
|
|
|Data processing
|
|
| Data processing
|
|-
|-
! {{anchor|Oberon-2|[[Oberon-2]]}}
! {{anchor|Oberon-2|[[Oberon-2]]}}
| [[procedural programming]], [[imperative programming]], [[object-oriented]]
|[[procedural programming]], [[imperative programming]], [[object-oriented]]
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
| explicit
|explicit
| structural
|structural
| static
|static
| by value, by reference
|by value, by reference
| {{yes}}
|{{yes}}
| Teaching, System
|Teaching, System
| Simplicity
|Simplicity
|-
|-
! {{anchor|Object Pascal|[[Object Pascal]]}} ({{anchor|Delphi|[[Delphi]]}})
! {{anchor|Object Pascal|[[Object Pascal]]}} ({{anchor|Delphi|[[Delphi]]}})
| [[imperative programming]], [[object-oriented]], [[generic programming]]
|[[imperative programming]], [[object-oriented]], [[generic programming]]
| {{no}}
|{{no}}
| strong
|strong
| safe (unsafe allowed)
|safe (unsafe allowed)
| explicit
|explicit
| nominative
|nominative
| static
|static
|
|
| {{yes}}
|{{yes}}
| Application, System
|Application, System
| Readability, Rapid application development, Modularity
|Readability, Rapid application development, Modularity
|-
|-
! {{anchor|Objective-C|[[Objective-C]]}}
! {{anchor|Objective-C|[[Objective-C]]}}
| [[imperative programming]], [[object-oriented]], [[reflective programming]]
|[[imperative programming]], [[object-oriented]], [[reflective programming]]
| {{yes}}
|{{yes}}
| weak
|weak
|
| explicit
|
| static
|
|
|explicit
| {{yes}} (as of 2.0)
|
| Application
|static
| [[Smalltalk]] like, Component based code reuse, [[C]] compatibility

|{{yes}}(as of 2.0)
|Application
|[[Smalltalk]] like, Component based code reuse, [[C]] compatibility
|-
|-
! {{anchor|Ocaml|[[Ocaml]]}}
! {{anchor|Ocaml|[[Ocaml]]}}
| [[object-oriented]], [[functional programming]], [[imperative programming]], [[generic programming]]
|[[object-oriented]], [[functional programming]], [[imperative programming]], [[generic programming]]
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
| inferred, optional explicit annotations
|inferred, optional explicit annotations
| polymorphic structural
|polymorphic structural
| static
|static
| by value
|by value
| {{yes}}
|{{yes}}
| Application
|Application
| Efficiency, Robustness, Correctness
|Efficiency, Robustness, Correctness
|-
|-
! {{anchor|Oz|[[Oz]]}}
! {{anchor|Oz|[[Oz]]}}
| logic programming, [[functional programming]], [[imperative programming]], [[object-oriented]], [[concurrent programming]]
|logic programming, [[functional programming]], [[imperative programming]], [[object-oriented]], [[concurrent programming]]
| {{no}}
|{{no}}
|
|
|
|
|
|
|
|
| dynamic
|dynamic
|
|{{yes}}
|Education
|
|
| {{yes}}
| Education
|
|-
|-
! {{anchor|Pascal|[[Pascal]]}}
! {{anchor|Pascal|[[Pascal]]}}
| [[imperative programming]], [[procedural programming]]
|[[imperative programming]], [[procedural programming]]
| {{yes}} (Extended Pascal standardized under [[ISO]])
|{{yes}} (Extended Pascal standardized under [[ISO]])
| strong
|strong
| safe
|safe
| explicit
|explicit
|
|
| static
|static
| by value, by reference
|by value, by reference
| {{no}}
|{{no}}
| Education
|Education
| Readability, Discipline, Modularity
|Readability, Discipline, Modularity
|-
|-
! {{anchor|Perl|[[Perl]]}}
! {{anchor|Perl|[[Perl]]}}
| [[imperative programming]], [[procedural programming]], [[reflective programming]], [[functional programming]], [[object-oriented]], [[generic programming]]
|[[imperative programming]], [[procedural programming]], [[reflective programming]], [[functional programming]], [[object-oriented]], [[generic programming]]
| {{no}}
|{{no}}
| weak
|weak
|
|
| implicit
|implicit
|
|
| dynamic
|dynamic
| by reference
|by reference
| {{optional|Reference counting}}
|{{optional|Reference counting}}
| Text processing, Scripting
|Text processing, Scripting
| Terseness, Expressiveness
|Terseness, Expressiveness
|-
|-
! {{anchor|PHP|[[PHP]]}}
! {{anchor|PHP|[[PHP]]}}
| [[imperative programming]], [[object-oriented]], [[reflective programming]]
|[[imperative programming]], [[object-oriented]], [[reflective programming]]
| {{no}}
|{{no}}
| weak
|weak
|
|
|
|
|
|
| dynamic
|dynamic
|
|
| {{yes}}
|{{yes}}
| Web Application, CLI
|Web Application, CLI
| Robustness and Simplicity
|Robustness and Simplicity
|-
|-
! {{anchor|Pop11|[[Pop11]]}}
! {{anchor|Pop11|[[Pop11]]}}
| [[imperative programming]], [[object-oriented]], [[functional programming]]
|[[imperative programming]], [[object-oriented]], [[functional programming]]
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
| implicit
|implicit
|
|
| dynamic
|dynamic
|
|
| {{yes}}
|{{yes}}
| Application, Education
|Application, Education
|
|
|-
|-
! {{anchor|Prolog|[[Prolog]]}}
! {{anchor|Prolog|[[Prolog]]}}
| logic programming
|logic programming
| {{yes}}, [[ISO]]
|{{yes}}, [[ISO]]
| strong
|strong
|
|
|
| dynamic
|
|
|
| {{yes}}
|
| Problem solving, Artificial intelligence
|dynamic
| [[declarative programming]]
|
|{{yes}}
|Problem solving, Artificial intelligence
|[[declarative programming]]
|-
|-
! {{anchor|Python|[[Python]]}}
! {{anchor|Python|[[Python]]}}
| [[imperative programming]], [[object-oriented]], [[functional programming]], [[aspect-oriented programming]], [[reflective programming]]
|[[imperative programming]], [[object-oriented]], [[functional programming]], [[aspect-oriented programming]], [[reflective programming]]
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
| implicit
|implicit
|
|
| dynamic
|dynamic
| [[wp:Python_syntax_and_semantics#Data_structures|Call by object reference]]
|[[wp:Python_syntax_and_semantics#Data_structures|Call by object reference]]
| {{yes}}
|{{yes}}
| Application, Education, Scripting
|Application, Education, Scripting
| Simplicity, Readability, Expressiveness, Modularity
|Simplicity, Readability, Expressiveness, Modularity
|-
|-
! {{anchor|RapidQ|[[RapidQ]]}}
! {{anchor|RapidQ|[[RapidQ]]}}
| [[imperative programming]], component-oriented programming, [[event-driven programming]]
|[[imperative programming]], component-oriented programming, [[event-driven programming]]
| {{no}}
|{{no}}
| strong (none for Variant type)
|strong (none for Variant type)
| safe
|safe
|
|
| static
| by reference, by value
|
|
|
| Application
|static
| Rapid application development, Simplicity, [[BASIC]] compatibility
|by reference, by value
|
|Application
|Rapid application development, Simplicity, [[BASIC]] compatibility
|-
|-
! {{anchor|Ruby|[[Ruby]]}}
! {{anchor|Ruby|[[Ruby]]}}
| [[imperative programming]], [[object-oriented]], [[aspect-oriented programming]], [[reflective programming]]
|[[imperative programming]], [[object-oriented]], [[aspect-oriented programming]], [[reflective programming]]
| {{no}}
|{{no}}
| strong
|strong
|
|
| implicit
|implicit
|
|
| dynamic
|dynamic
| by reference
|by reference
| {{yes}}
|{{yes}}
| Application, Scripting
|Application, Scripting
| Expressiveness, Readability
|Expressiveness, Readability
|-
|-
! {{anchor|Scala|[[Scala]]}}
! {{anchor|Scala|[[Scala]]}}
| [[object-oriented]], [[functional programming]], [[generic programming]]
|[[object-oriented]], [[functional programming]], [[generic programming]]
| {{no}}
|{{no}}
| strong
|strong
|
|
| partially implicit
|partially implicit
|
|
| static
|static
|
|{{yes}}
|Education
|
|
| {{yes}}
| Education
|
|-
|-
! {{anchor|Scheme|[[Scheme]]}}
! {{anchor|Scheme|[[Scheme]]}}
| [[functional programming]]
|[[functional programming]]
| {{yes}}, R<sup>5</sup>RS, R<sup>6</sup>RS
|{{yes}}, R<sup>5</sup>RS, R<sup>6</sup>RS
| strong
|strong
| safe
|safe
| implicit
|implicit
|
|
| dynamic (latent)
|dynamic (latent)
| by value
|by value
| {{yes}}
|{{yes}}
| General, Education
|General, Education
| Minimalistic, Lexical Scoping
|Minimalistic, Lexical Scoping
|-
|-
! {{anchor|Slate|[[Slate]]}}
! {{anchor|Slate|[[Slate]]}}
| [[object-oriented]], [[imperative programming]], [[functional programming]], [[reflective programming]], prototype, multi-dispatch
|[[object-oriented]], [[imperative programming]], [[functional programming]], [[reflective programming]], prototype, multi-dispatch
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
| implicit, optional
|implicit, optional
| structural (aka duck)
|structural (aka duck)
| dynamic
|dynamic
| by reference
|by reference
| {{yes}}
|{{yes}}
| Application, Embedded, Scripting
|Application, Embedded, Scripting
| Uniformity, Pure object-oriented, expressiveness, readability
|Uniformity, Pure object-oriented, expressiveness, readability
|-
|-
! {{anchor|Smalltalk|[[Smalltalk]]}}
! {{anchor|Smalltalk|[[Smalltalk]]}}
| [[object-oriented]], [[concurrent programming]], [[event-driven programming]], [[imperative programming]], [[declarative programming]]
|[[object-oriented]], [[concurrent programming]], [[event-driven programming]], [[imperative programming]], [[declarative programming]]
| {{yes}}, [[ANSI]]
|{{yes}}, [[ANSI]]
| strong
|strong
| safe
|safe
| implicit
|implicit
|
|
| dynamic
|dynamic
| by reference
|by reference
| {{yes}}
|{{yes}}
| Application, Education
|Application, Education
| Uniformity, Pure object oriented
|Uniformity, Pure object oriented
|-
|-
! {{anchor|Tcl|[[Tcl]]}}
! {{anchor|Tcl|[[Tcl]]}}
| [[imperative programming]], [[procedural programming]], [[event-driven programming]], [[object-oriented]] (via [http://wiki.tcl.tk/970 extensions])
|[[imperative programming]], [[procedural programming]], [[event-driven programming]], [[object-oriented]] (via [http://wiki.tcl.tk/970 extensions])
| {{no}}
|{{no}}
| weak
|weak
| safe
|safe
| implicit
|implicit
| duck
|duck
| dynamic
|dynamic
| by value (also by name and by reference through passing of variable names and <code>upvar</code> command)
|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}}
|{{optional|Only of unnamed entities, e.g., values}}
| Embedded, Application, Scripting
|Embedded, Application, Scripting
| [http://www.tcl.tk/about/history.html Extend, Embed and Integrate]
|[http://www.tcl.tk/about/history.html Extend, Embed and Integrate]
|-
|-
! {{anchor|V|[[V]]}}
! {{anchor|V|[[V]]}}
| [[functional programming]], [[stack]]-oriented, [[concatenative]]
|[[functional programming]], [[stack]]-oriented, [[concatenative]]
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
|
|
| dynamic
|
|
|
|
|dynamic
| [[functional programming]] research
|
| [[concatenative]]
|
|[[functional programming]] research
|[[concatenative]]
|-
|-
! {{anchor|Visual Basic|[[Visual Basic]]}}
! {{anchor|Visual Basic|[[Visual Basic]]}}
| component-oriented programming, [[event-driven programming]]
|component-oriented programming, [[event-driven programming]]
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
|
|
| nominative
|nominative
| static
|static
| by reference, by value (explicit)
|by reference, by value (explicit)
| {{yes}}
|{{yes}}
| Application
|Application
| Rapid application development, Simplicity
|Rapid application development, Simplicity
|-
|-
! {{anchor|Visual Basic .NET|[[Visual Basic .NET]]}}
! {{anchor|Visual Basic .NET|[[Visual Basic .NET]]}}
| [[object-oriented]], [[event-driven programming]]
|[[object-oriented]], [[event-driven programming]]
| {{no}}
|{{no}}
| strong
|strong
|
|
|
|
|
|
| static
|static
| by reference, by value (both explicit)
|by reference, by value (both explicit)
| {{yes}}
|{{yes}}
| Application
|Application
| Rapid application development, Simplicity
|Rapid application development, Simplicity
|-
|-
! {{anchor|Windows PowerShell|[[Windows PowerShell]]}}
! {{anchor|Windows PowerShell|[[Windows PowerShell]]}}
| [[imperative programming]], [[object-oriented]], [[functional programming]], [[pipeline programming]], [[reflective programming]]
|[[imperative programming]], [[object-oriented]], [[functional programming]], [[pipeline programming]], [[reflective programming]]
| {{no}}
|{{no}}
| strong
|strong
| safe
|safe
| implicit
|implicit
|
| dynamic
|
|
|dynamic
|
|
|Scripting
|
|
| Scripting
|
|-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
![[Parameter Passing]] Methods Available
! [[Garbage collection|Garbage Collected]]
![[Garbage collection]]
! Intended use
!Intended use
! Design goals
!Design goals
|}
|}
==External resources==

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

Revision as of 20:23, 28 July 2009

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
ActionScript imperative programming, object-oriented, event-driven programming Yes

, ECMA

strong safe static Yes Web design
Ada concurrent programming, distributed programming, generic programming, imperative programming, object-oriented Yes

, ANSI, ISO, ANSI/MIL-STD-1815A-1983, ISO/IEC 8652, ISO/IEC TR 24718, GOST 27831-88

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 programming 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)
AutoHotkey imperative programming No untyped by value or by reference No End User Programming simplicity, speed, stability
BASIC procedural programming Yes

, ANSI, ISO

varies by dialect varies by dialect Education Simplicity
C imperative programming Yes

, ANSI C89, ISO C90/C99

weak unsafe explicit nominative static by value, by reference (through pointers) No System, Embedded Low level access, Minimal constraint
C# imperative programming, object-oriented, generic programming, reflective programming Yes

, ECMA, ISO

strong safe (unsafe allowed) implicit nominative static Yes Application Rapid application development
C++ imperative programming, object-oriented, generic programming Yes

, ISO

strong safe (unsafe allowed) explicit, partially implicit nominative, structural static, dynamic by value, by reference (through reference types) No Application, System Abstraction, Efficiency, Compatibility
Clean functional programming, generic programming No strong implicit static Yes General Correctness, Modularity
COBOL imperative programming, object-oriented Yes strong static No Business and Financial Applications Readability
ColdFusion procedural programming, object-oriented No weak implicit dynamic Web Development Rapid Application Development, Ease of use
Common Lisp imperative programming, functional programming, object-oriented Yes strong safe dynamic, static Yes General Standardize Lisp
D imperative programming, object-oriented, generic programming No strong safe, unsafe allowed explicit, optional inferred nominative, structural static, dynamic by value, by reference (through reference types) Yes Application, System Compilability, Correctness, Efficiency
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 programming, object-oriented, generic programming, reflective programming 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
Eiffel imperative programming, object-oriented, generic programming Yes

, ECMA-367, ISO/IEC 25436:2006

strong safe nominative static Yes Application Correctness, Efficiency, Design by contract
Erlang functional programming, concurrent programming, distributed programming No strong dynamic Yes Telecom and distributed applications Fault tolerance, Scalability
Forth imperative programming, stack-oriented Yes

, ANSI

none n/a n/a n/a n/a No Application, Embedded systems Compact implementations, Low level access, Interactive programming
Fortran imperative programming, procedural programming, object-oriented Yes

, ISO, ISO/IEC 1539-1:2004

strong safe nominative static No Scientific and numeric applications Runtime efficiency, Simple syntax
Groovy imperative programming, object-oriented, aspect-oriented programming No strong safe implicit dynamic Yes Application JVM compatibility
Haskell functional programming, generic programming, lazy evaluation Yes

, 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
Io object-oriented, prototype No strong dynamic Yes
J array programming, function-level programming, tacit programming No strong safe dynamic Data processing Terseness, Expressiveness, Powerful Data Manipulation
Java imperative programming, object-oriented, generic programming, reflective programming No strong safe explicit nominative static by value Yes Application Write once run anywhere
JavaScript imperative programming, object-oriented, functional programming, reflective programming Yes weak implicit dynamic Yes Client side web scripting
Joy functional programming, stack-oriented No strong safe dynamic functional programming research concatenative
Lisp functional programming, reflective programming; others vary by dialect No strong dynamic Yes General Simple notation for Lambda calculus, Homoiconicity
procedural programming, functional programming No strong safe implicit structural dynamic Yes Education Simple syntax, Turtle graphics, Interactive programming
Lua procedural programming, imperative programming, reflective No strong safe implicit dynamic Yes Host-driven Scripting Small, embedded, configuration.
Lucid dataflow programming, functional programming No strong safe dynamic stream processing dataflow
Mathematica functional programming, procedural programming No strong dynamic Yes Numeric computation and visualization
MAXScript imperative programming, object-oriented, procedural programming No strong safe implicit dynamic by value, by reference 3D Art Tools, Scripting Simplicity, Accessibilty
Modula-3 imperative programming, object-oriented, procedural programming, generic programming No strong safe (unsafe allowed) explicit structural static by value, by reference Yes Application, Systems Simple, Object oriented
Nial functional programming, array programming No strong dynamic Data processing
Oberon-2 procedural programming, imperative programming, object-oriented No strong safe explicit structural static by value, by reference Yes Teaching, System Simplicity
Object Pascal (Delphi) imperative programming, object-oriented, generic programming No strong safe (unsafe allowed) explicit nominative static Yes Application, System Readability, Rapid application development, Modularity
Objective-C imperative programming, object-oriented, reflective programming Yes weak explicit static Yes

(as of 2.0)

Application Smalltalk like, Component based code reuse, C compatibility
Ocaml object-oriented, functional programming, imperative programming, generic programming No strong safe inferred, optional explicit annotations polymorphic structural static by value Yes Application Efficiency, Robustness, Correctness
Oz logic programming, functional programming, imperative programming, object-oriented, concurrent programming No dynamic Yes Education
Pascal imperative programming, procedural programming Yes 
(Extended Pascal standardized under ISO)
strong safe explicit static by value, by reference No Education Readability, Discipline, Modularity
Perl imperative programming, procedural programming, reflective programming, functional programming, object-oriented, generic programming No weak implicit dynamic by reference Reference counting Text processing, Scripting Terseness, Expressiveness
PHP imperative programming, object-oriented, reflective programming No weak dynamic Yes Web Application, CLI Robustness and Simplicity
Pop11 imperative programming, object-oriented, functional programming No strong safe implicit dynamic Yes Application, Education
Prolog logic programming Yes

, ISO

strong dynamic Yes Problem solving, Artificial intelligence declarative programming
Python imperative programming, object-oriented, functional programming, aspect-oriented programming, reflective programming No strong safe implicit dynamic Call by object reference Yes Application, Education, Scripting Simplicity, Readability, Expressiveness, Modularity
RapidQ imperative programming, component-oriented programming, event-driven programming No strong (none for Variant type) safe static by reference, by value Application Rapid application development, Simplicity, BASIC compatibility
Ruby imperative programming, object-oriented, aspect-oriented programming, reflective programming No strong implicit dynamic by reference Yes Application, Scripting Expressiveness, Readability
Scala object-oriented, functional programming, generic programming No strong partially implicit static Yes Education
Scheme functional programming Yes

, R5RS, R6RS

strong safe implicit dynamic (latent) by value Yes General, Education Minimalistic, Lexical Scoping
Slate object-oriented, imperative programming, functional programming, reflective programming, 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 programming, event-driven programming, imperative programming, declarative programming Yes

, ANSI

strong safe implicit dynamic by reference Yes Application, Education Uniformity, Pure object oriented
Tcl imperative programming, procedural programming, event-driven programming, object-oriented (via extensions) 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
V functional programming, stack-oriented, concatenative No strong safe dynamic functional programming research concatenative
Visual Basic component-oriented programming, event-driven programming No strong safe nominative static by reference, by value (explicit) Yes Application Rapid application development, Simplicity
Visual Basic .NET object-oriented, event-driven programming No strong static by reference, by value (both explicit) Yes Application Rapid application development, Simplicity
Windows PowerShell imperative programming, object-oriented, functional programming, pipeline programming, reflective programming No strong safe implicit dynamic Scripting
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=76028"