Rosetta Code

Language Comparison Table: Difference between revisions

Page Discussion

Language Comparison Table (view source)

Revision as of 00:04, 9 March 2024

7,975 bytes added ,  2 months ago
Added Plain English
(Updated SkookumScript garbage collection to ref counting and fixed garbage collecting template for Swift)
(Added Plain English)
 
(64 intermediate revisions by 27 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 an ANSI standard, 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,218 ⟶ 1,396:
|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
|-
 
Line 1,385 ⟶ 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,430 ⟶ 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,454 ⟶ 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,473 ⟶ 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,489 ⟶ 1,741:
 
|}
 
 
 
==External resources==
Elenderg
18

edits

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