Rosetta Code

Language Comparison Table: Difference between revisions

Page Discussion

Language Comparison Table (view source)

Revision as of 00:04, 9 March 2024

7,414 bytes added ,  3 months ago
Added Plain English
No edit summary
(Added Plain English)
 
(60 intermediate revisions by 25 users not shown)
Line 1:
[[Category:Encyclopedia]]
 
See also [[TL;DR]] (Brief descriptions of languages).
{|class="wikitable sortable"
![[:Category:Programming Languages|Language]]
Line 64 ⟶ 66:
|[[concurrent programming|concurrent]], [[imperative programming|imperative]]
|{{yes|Yes, [http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf GOST 27974-88]}}
|strong
|soft, weak, meek, firm and strong - depending on context.
|safe
|explicit
Line 103 ⟶ 105:
|Mobile ad hoc networks
|
|-
 
 
! {{anchor|Arturo|[[Arturo]]}}
|[[generic programming|generic]], [[imperative programming|imperative]], [[functional programming|functional]], [[reflective programming|reflective]], [[stack|stack]]-based
|{{no|No, see [https://arturo-lang.io/documentation/ official documentation]}}
|strong
|
|implicit
|
|dynamic
|by value, by reference (literals)
|{{yes}}
|General, Scripting, DSLs, Templating, Portable apps, GUI applications
|Simplicity, Expressiveness, Portability
|-
 
 
! {{anchor|AutoHotkey|[[AutoHotkey]]}}
|[[imperative programming|imperative]], [[classless-objects|classless]]
|{{no}}
|untyped
Line 148 ⟶ 165:
|Education
|Simplicity
|-
 
 
! {{anchor|Blade|[[Blade]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]]
|{{no}}
|strong
|safe
|implicit
|nominative
|dynamic
|by value, by reference (through pointers)
|{{yes}}
|Scripting, Application
|Simple, Lightweight, CLI, Web, Desktop, Mobile
|-
 
Line 174 ⟶ 206:
|nominative
|static, dynamic (for interop)
|by value, by reference (through managed pointers [explicitly in, out, or in-out])
|
|{{yes}}
|Application
Line 243 ⟶ 275:
! {{anchor|COBOL|[[COBOL]]}}
|[[imperative programming|imperative]], [[object-oriented]]
|{{yes|Yes, [[ANSI]] 68, 74, 85 (and subsequent revisions); ECMA; [[ISO]] 1989:2023 (and previous version in 1978, 1985, 2002, 201X2014)}}
|strong
|safe
Line 313 ⟶ 345:
|
|
|-
 
! {{anchor|Dyalect|[[Dyalect]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]]
|{{no}}
|strong
|safe
|implicit
|duck
|dynamic
|by reference
|{{yes}}
|Application
|Portable dynamic scripting language with consistent design and modern syntax
|-
 
Line 358 ⟶ 404:
|Applications, GUIs, System, Games
|Elegance, Performance, Simplicity, Lightness, 99.9% [[C]] compatibility
|-
 
 
! {{anchor|Ecstasy|[[Ecstasy]]}}
|[[object-oriented]], [[generic programming|generic]], [[reflective programming|reflective]], [[functional programming|functional]], [[imperative programming|imperative]]
|{{no|No}}
|strong
|safe
|explicit, optionally inferred
|nominative; duck for interface types
|static; dynamic for generic edge conditions
|by value; by reference
|{{yes}}
|Application
|Predictable, Secure, Composable
|-
 
Line 385 ⟶ 446:
|duck
|dynamic
|by valuereference
|{{yes}}
|Application
Line 473 ⟶ 534:
! {{anchor|Forth|[[Forth]]}}
|[[imperative programming|imperative]], [[stack]]-oriented
|{{yes|Yes, [[ANSI]], [https://www.iso.org/standard/26479.html ISO/IEC 15145:1997]}}
|none
|n/a
Line 505 ⟶ 566:
|{{no|No}}
|strong
|safe
|
|
|
|nominative
|static
|by value, by reference (through pointers)
|{{noyes|NoYes}}
|Educational, Scientific, Prototyping, CommericalCommercial Level Applications
|Mac Freeware, Readability, Simplicity, CompliabilityEfficiency, FreewareC/Objective-C Compatibility, EfficiencyObjective-C Alternative, Builds Xcode Projects
|-
 
Line 532 ⟶ 593:
 
! {{anchor|Go|[[Go]]}}
|[[concurrent programming|concurrent]], [[classless-objects|classless]]
|<!-- Std -->{{no}}, [http://golang.org/ref/spec language specification] available
|<!-- Strength -->strong
Line 590 ⟶ 651:
|-
 
! {{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]]}}
Line 605 ⟶ 679:
|-
 
! {{anchor|Insitux|[[Insitux]]}}
|[[functional programming|functional]], [[imperative programming|imperative]]
|{{no}}
|strong
|safe
|implicit
|
|dynamic
|by value
|{{yes}}
|Host-driven scripting
|Host-extensibility; provide "safe" modding e.g. timeout infinite loops, memory limits; concise code
|-
 
! {{anchor|Io|[[Io]]}}
|[[object-oriented]], [[classless-objects|classless]], prototype
|{{no}}
|strong
Line 652 ⟶ 739:
 
! {{anchor|JavaScript|[[JavaScript]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[classless-objects|classless]], [[functional programming|functional]], [[reflective programming|reflective]]
|{{yes|Yes, [[ECMAScript standard]]}}
|weak
Line 678 ⟶ 765:
|[[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
|-
 
Line 727 ⟶ 890:
 
! {{anchor|Lua|[[Lua]]}}
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[classless-objects|classless]], [[reflective programming|reflective]]
|{{no}}
|strong
Line 833 ⟶ 996:
! {{anchor|MUMPS|[[MUMPS]]}}
|[[procedural programming|procedural]]
|{{yes|Yes, [[https://www.iso.org/standard/29268.html ISO]/IEC 11756:1999]}}
|untyped
|not applicable
Line 866 ⟶ 1,029:
|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.
|-
Line 877 ⟶ 1,040:
 
! {{anchor|Oberon-2|[[Oberon-2]]}}
|[[procedural programming|procedural]], [[imperative programming|imperative]], [[object-oriented]], [[classless-objects|classless]]
|{{no}}
|strong
Line 983 ⟶ 1,146:
! {{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]}}
|{{yes|Yes, Extended Pascal standardized under [[ISO]]}}
|strong
|safe
Line 1,008 ⟶ 1,171:
|Text processing, Scripting
|Terseness, Expressiveness
|-
 
 
! {{anchor|Perl 6|[[Perl 6]]}}
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[reflective programming|reflective]], [[functional programming|functional]], [[object-oriented]], [[generic programming|generic]], [[lazy evaluation]], multiple dispatch, metaprogramming
|{{yes|Yes, [http://perlcabal.org/syn/#doctable Perl 6 Synopses]}}
|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|Phix|[[Phix]]}}
|[[imperative programming|imperative]], [[procedural programming|procedural]], [[object-oriented]]
|<!-- Std -->{{no}}
|<!-- Strength -->strong
Line 1,035 ⟶ 1,183:
|<!-- 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, Facilitate easeEase of programming and maintenanceuse
|-
 
Line 1,068 ⟶ 1,216:
|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
|-
 
Line 1,128 ⟶ 1,291:
|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
|-
 
Line 1,175 ⟶ 1,353:
|-
 
! {{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
! {{anchor|R|[[R]]}}
|{{no|No. The [https://github.com/perl6/roast Repository Of All Spec Tests (aka 'roast') defines the language]}}
|[[functional programming|functional]], [[imperative programming|imperative]], [[reflective programming|reflective]], [[array]]
|{{no}}
|strong
|safe, unsafe
|optional explicit
|implicit
|nominal (duck and structural available via constraints, patterns, generics, and gradual typing)
|Duck, structural
|dynamic, static
|value by needvalue, by name (programmer chosen)reference
|{{yes}}
|Application, text processing, scripting
|Statistics, Numerical computation, Visualization, Education
|Expressiveness, interactive manipulation and analysis of datasetsgenerality
|-
 
 
! {{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]]
| [[dynamic programming|dynamic]], [[procedural programming|procedural]], [[functional programming|functional]]
| {{yes|Yes. &nbsp; There is a ANSI standard (X3.274-1996), &nbsp; but some implementations don't adhere to it.}}
|<!-- Standardized --> {{yes|Yes. <br><br>There is a ANSI standard (X3.274-1996), &nbsp; but some REXX implementations don't adhere to it.}}
| strong
|<!-- Type strength -->&nbsp; strong
| safe
|<!-- Type safety -->&nbsp; safe
| inferred
|<!-- Expression of types -->&nbsp; inferred
| nominal
|<!-- Type compatibility -->&nbsp; nominal
| dynamic &nbsp; (but only when both comparands are numeric ''and'' non-strict comparisons are used)
|<!-- Type checking -->dynamic &nbsp; (but only when both comparands are numeric &nbsp;''and''&nbsp; non─strict comparisons are used)
| by value
|<!-- Parameter Passing -->&nbsp; by&nbsp;value
| {{optional| garbage collection is allowed (and in most cases, automatic), but not mandated}}
|<!-- Garbage collection -->{{optional| garbage collection is allowed (and in most cases, automatic), but not mandated}}
| general, application, algorithms, scripting, host/sub-system scripting/interfacing, data/text processing, programming as a human activity
|<!-- 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
| 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; principle of least astonishment.
|<!-- 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)].
|-
 
Line 1,219 ⟶ 1,397:
|Expressiveness, Readability
|-
 
 
! {{anchor|Rust|[[Rust]]}}
|[[concurrent programming|concurrent]], [[functional programming|functional]], [[imperative programming|imperative]], [[structured]], [[classless-objects|classless]], [[generic programming|generic]]
|{{no}}
|strong
Line 1,399 ⟶ 1,578:
|-
 
 
! {{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]]}}
Line 1,444 ⟶ 1,651:
|-
 
! {{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]]}}
Line 1,468 ⟶ 1,688:
|nominative
|static, dynamic (for interop)
|by value, by reference (through managed pointers [always in-out])
|by reference, by value (both explicit)
|{{yes}}
|Application
Line 1,487 ⟶ 1,707:
|Scripting
|
|-
 
 
! {{anchor|Wren|[[Wren]]}}
|[[imperative programming|imperative]], [[object-oriented]], [[functional programming|functional]], [[concurrent programming|concurrent]]
|{{no}}
|strong
|safe
|implicit
|nominative
|dynamic
|by value
|{{yes}}
|Host-driven Scripting
|Lightweight, class-based, concurrent, easily embeddable
|-
 
 
|-class="sortbottom"
![[Programming Language|Language]]
Line 1,503 ⟶ 1,741:
 
|}
 
 
 
==External resources==
Elenderg
18

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/76176...361402"