Comparison of programming languages: Difference between revisions
GreenC bot (talk | contribs) Move 1 url. Wayback Medic 2.5 per WP:URLREQ#ieee.org |
|||
(421 intermediate revisions by more than 100 users not shown) | |||
Line 1: | Line 1: | ||
{{short description|none}} |
|||
{{ProgLangCompare}} |
{{ProgLangCompare}} |
||
[[Programming language]]s are used for controlling the behavior of a machine (often a [[computer]]). Like [[natural language]]s, programming languages |
[[Programming language]]s are used for controlling the behavior of a machine (often a [[computer]]). Like [[natural language]]s, programming languages follow rules for [[syntax]] and [[semantics]]. |
||
There are [[list of programming languages|thousands of programming languages]]<ref>As of May 2006 Diarmuid Pigott's [http://hopl.murdoch.edu.au/ Encyclopedia of Computer Languages] hosted at [[Murdoch University]], [[Australia]] lists 8512 computer languages.</ref> and new ones are created every year. Few languages ever become sufficiently popular that they are used by more than a few people, but professional [[programmer]]s may use dozens of languages in a career. |
There are [[list of programming languages|thousands of programming languages]]<ref>As of May 2006 Diarmuid Pigott's [http://hopl.murdoch.edu.au/ Encyclopedia of Computer Languages] {{webarchive|url=https://web.archive.org/web/20110220044217/http://hopl.murdoch.edu.au/ |date=2011-02-20}} hosted at [[Murdoch University]], [[Australia]] lists 8512 computer languages.</ref> and new ones are created every year. Few languages ever become sufficiently popular that they are used by more than a few people, but professional [[programmer]]s may use dozens of languages in a career. |
||
Most programming languages are not standardized by an international (or national) standard, even widely used ones, such as [[Perl]] or [[Standard ML]] (despite the name). Notable standardized programming languages include [[ALGOL]], [[C (programming language)|C]], [[C++]], JavaScript (under the name [[ECMAScript]]), [[Smalltalk]], [[Prolog]], [[Common Lisp]], [[Scheme (programming language)|Scheme]] ([[IEEE]] standard), [[ISLISP]], [[Ada (programming language)|Ada]], [[Fortran]], [[COBOL]], [[SQL]], and [[XQuery]]. |
|||
__TOC__ |
__TOC__ |
||
Line 8: | Line 11: | ||
==General comparison== |
==General comparison== |
||
The following table compares general and technical information for a selection of commonly used [[programming language]]s. See the individual languages' articles for further |
The following table compares general and technical information for a selection of commonly used [[programming language]]s. See the individual languages' articles for further information. |
||
<!-- Per [[WP:REPEATLINK]]: Wikilink terms on 1st instance only, remove later repeat links. --> |
<!-- Per [[WP:REPEATLINK]]: Wikilink terms on 1st instance only, remove later repeat links. --> |
||
{{sticky header}} |
|||
{|class="wikitable sortable" style="text-align:center; |
|||
{|class="wikitable sortable sticky-header" style="text-align:center;" |
|||
|- |
|||
! scope="col" | Language |
|||
! scope="col" | Original purpose |
|||
! scope="col" | [[Imperative programming|Imperative]] |
|||
! scope="col" | [[Object-oriented programming|Object-oriented]] |
|||
! scope="col" | [[Functional programming|Functional]] |
|||
! scope="col" | [[Procedural programming|Procedural]] |
|||
! scope="col" | [[Generic programming|Generic]] |
|||
! scope="col" | [[Reflective programming|Reflective]] |
|||
! scope="col" | Other [[Programming paradigm|paradigms]] |
|||
! scope="col" | [[Standardization|Standardized]] |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[1C:Enterprise programming language]] |
|||
! Language |
|||
| <!-- Original purpose --> [[Application software development|Application]], [[Rapid application development|RAD]], business, [[General-purpose programming language|general]], [[Web development|web]], [[Mobile app development|mobile]] |
|||
! Intended use <!--What this was to be used for originally. Not what it is used for now, which is hard to verify.--> |
|||
! |
| <!-- Imperative --> {{yes}} |
||
| <!-- Object-oriented --> {{no}} |
|||
! |
| <!-- Functional --> {{yes}} |
||
! |
| <!-- Procedural --> {{yes}} |
||
| <!-- Generic --> {{yes}} |
|||
! [[generic programming|Generic]] |
|||
! |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> [[Object-based]], Prototype-based programming |
|||
! [[event-driven programming|Event-driven]] |
|||
| <!-- Standardized? --> {{no}} |
|||
! Other [[programming paradigm|paradigm]](s) |
|||
! [[standardization|Standardized]]? |
|||
|- |
|||
|- align="center" |
|||
! [[ActionScript]] |
! scope="row" | [[ActionScript]] |
||
| <!-- Original purpose --> Application, [[client-side]], web |
|||
| Application, client-side, Web <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for ActionScript 3.0 --> |
|||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- |
| <!-- Other paradigms --> [[prototype-based]] |
||
| <!-- Standardized? --> {{yes}}<br/>1999-2003, [[ECMAScript|ActionScript 1.0 with ES3, ActionScript 2.0 with ES3 and partial ES4 draft, ActionScript 3.0 with ES4 draft]],<!-- ECMA-262 --> [[ECMAScript for XML|ActionScript 3.0 with E4X]]<!-- ECMA-357 --> |
|||
| {{Yes}}<!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
|||
| {{yes|1996}}, ECMA <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[Ada (programming language)|Ada]] |
! scope="row" | [[Ada (programming language)|Ada]] |
||
| Application, embedded, realtime, [[System programming language|system]] |
| <!-- Original purpose --> Application, [[Embedded system|embedded]], [[Real-time computing|realtime]], [[System programming language|system]] |
||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- Object-oriented --> {{yes}}<ref>[http://www.adaic.org/standards/05rm/html/RM-TTL.html Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3], [http://www.adaic.org/standards/05rm/html/RM-3-9.html 3.9 Tagged Types and Type Extensions]</ref> |
|||
| {{Yes}}<!-- Imperative --> |
|||
| |
| <!-- Functional --> {{no}} |
||
| <!-- Procedural --> {{yes}}<ref>[http://www.adaic.org/standards/05rm/html/RM-TTL.html Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3], [http://www.adaic.org/standards/05rm/html/RM-6.html Section 6: Subprograms]</ref> |
|||
| <!-- Functional --> |
|||
| {{ |
| <!-- Generic --> {{yes}}<ref>[http://www.adaic.org/standards/05rm/html/RM-TTL.html Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3], [http://www.adaic.org/standards/05rm/html/RM-12.html Section 12: Generic Units]</ref> |
||
| <!-- Reflective --> {{no}} |
|||
| |
|<!-- Other paradigms -->[[concurrent programming language|Concurrent]],<ref>[http://www.adaic.org/standards/05rm/html/RM-TTL.html Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3], [http://www.adaic.org/standards/05rm/html/RM-9.html Section 9: Tasks and Synchronization]</ref> [[distributed programming|distributed]]<ref>[http://www.adaic.org/standards/05rm/html/RM-TTL.html Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3] [http://www.adaic.org/standards/05rm/html/RM-E.html Annex E: Distributed Systems]</ref> |
||
| <!-- Standardized? --> {{yes}}<br/>1983, 2005, 2012, ANSI, ISO, [[GOST]] 27831-88<ref>{{Cite web |url=http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27831-88.pdf |title=Vak.ru |access-date=2008-08-09 |archive-url=https://web.archive.org/web/20170330020459/http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27831-88.pdf |archive-date=2017-03-30 |url-status=dead}}</ref> |
|||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| [[concurrent programming language|concurrent]],<ref>[http://www.adaic.org/standards/05rm/html/RM-TTL.html Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3], [http://www.adaic.org/standards/05rm/html/RM-9.html Section 9: Tasks and Synchronization]</ref> [[distributed programming|distributed]],<ref>[http://www.adaic.org/standards/05rm/html/RM-TTL.html Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3] [http://www.adaic.org/standards/05rm/html/RM-E.html Annex E: Distributed Systems]</ref> imperative object-oriented<ref>[http://www.adaic.org/standards/05rm/html/RM-TTL.html Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3], [http://www.adaic.org/standards/05rm/html/RM-3-9.html 3.9 Tagged Types and Type Extensions]</ref> <!-- Other paradigms --> |
|||
| {{yes|1983}}, 2005, 2012, ANSI, ISO, [[GOST]] 27831-88<ref>[http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27831-88.pdf Vak.ru]</ref> <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[Aldor]] |
! scope="row" | [[Aldor]] |
||
| <!-- Original purpose --> Highly [[Domain-specific language|domain-specific]], [[Computer algebra|symbolic computing]] |
|||
| Highly domain-specific, symbolic computing <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[ALGOL 58]] |
! scope="row" | [[ALGOL 58]] |
||
| |
| <!-- Original purpose --> Application |
||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for ALGOL 58 --> |
|||
| |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[ALGOL 60]] |
! scope="row" | [[ALGOL 60]] |
||
| |
| <!-- Original purpose --> Application |
||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for ALGOL 60 --> |
|||
| |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| {{yes |
| <!-- Standardized? --> {{yes}}<br/>1960, [[IFIP WG 2.1]], ISO<ref>[http://www.open-std.org/jtc1/sc22/docs/oldwgs/wg6.html ISO 1538:1984]</ref> |
||
|- |
|||
|- align="center" |
|||
! [[ALGOL 68]] |
! scope="row" | [[ALGOL 68]] |
||
| |
| <!-- Original purpose --> Application |
||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for ALGOL 68 --> |
|||
| |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- |
| <!-- Other paradigms --> Concurrent |
||
| <!-- Standardized? --> {{yes}}<br/>1968, [[IFIP WG 2.1]], [[GOST 27974-88]],<ref>{{Cite web |url=http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf |title=Vak.ru |access-date=2008-08-09 |archive-url=https://web.archive.org/web/20170324231641/http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf |archive-date=2017-03-24 |url-status=dead}}</ref> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| concurrent <!-- Other paradigms --> |
|||
| {{yes|1968}}, [[IFIP WG 2.1]], [[GOST 27974-88]],<ref>[http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf Vak.ru]</ref> <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[Ateji PX]] |
! scope="row" | [[Ateji PX]] |
||
| <!-- Original purpose --> Parallel application |
|||
| Parallel application <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{no}} |
||
| <!-- |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- |
| <!-- Other paradigms --> [[pi calculus]] |
||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| [[pi calculus]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[APL (programming language)|APL]] |
! scope="row" | [[APL (programming language)|APL]] |
||
| <!-- Original purpose --> Application, [[data processing]] |
|||
| Application, data processing <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> [[array programming|Array-oriented]], [[tacit programming|tacit]] |
|||
| <!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{yes}}<br/>1989, ISO |
||
<!-- -------------------- --> |
|||
| [[array programming|array-oriented]], [[tacit programming|tacit]] <!-- Other paradigms --> |
|||
| {{yes|1989}}, ISO <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[Assembly language]] |
! scope="row" | [[Assembly language]] |
||
| <!-- Original purpose --> General |
|||
| [[General purpose programming language|General]] <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Assembly language --> |
|||
| |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> Any, syntax is usually highly specific, related to the target processor |
|||
| <!-- Reflective --> |
|||
| <!-- Standardized? --> {{yes}}<br/>1985 IEEE 694-1985<ref>[https://standards.ieee.org/ieee/694/950/ IEEE 694-1985]</ref> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| any, syntax is usually highly specific, related to the target processor <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[AutoHotkey]] |
! scope="row" | [[AutoHotkey]] |
||
| GUI automation (macros), highly domain-specific |
| <!-- Original purpose --> GUI automation ([[Macro (computer science)#Application macros and scripting|macros]]), highly domain-specific |
||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for AutoHotkey --> |
|||
| <!-- Object-oriented --> {{yes}}<br/><ref>[https://www.autohotkey.com/docs/Objects.htm Objects - Definition & Usage]</ref> |
|||
| {{Yes}}<!-- Imperative --> |
|||
| <!-- |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[AutoIt]] |
! scope="row" | [[AutoIt]] |
||
| GUI automation (macros), highly domain-specific |
| <!-- Original purpose --> GUI automation (macros), highly domain-specific |
||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| {{Yes}}<!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Ballerina (programming language)|Ballerina]] |
|||
! [[Bash (Unix shell)|Bash]] <!-- Language --> |
|||
| <!-- Original purpose --> Integration, agile, [[server-side]], general |
|||
| Shell, scripting <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> Concurrent, transactional, statically and strongly typed, diagrammatic–visual |
|||
| <!-- Reflective --> |
|||
| <!-- Standardized? --> {{maybe|De facto}}<br/>standard via Ballerina Language Specification<ref>{{cite web |url=https://ballerina.io/res/Ballerina-Language-Specification-WD-2015-05-01.pdf |publisher=WSO2 |title=Ballerina Language Specification |date=2018-05-01 |access-date=2018-05-03 |archive-date=2018-05-04 |archive-url=https://web.archive.org/web/20180504090305/https://ballerina.io/res/Ballerina-Language-Specification-WD-2015-05-01.pdf |url-status=dead}}</ref> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
|||
| <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Bash (Unix shell)|Bash]] |
|||
! [[BASIC]] <!-- Language --> |
|||
| <!-- Original purpose --> [[Shell (computing)|Shell]], [[Scripting language|scripting]] |
|||
| Application, education <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| <!-- Standardized? --> {{maybe|Optionally}}<br/>[[POSIX.2]]<ref name="POSIX 1003">[[POSIX.2]], Shell and Utilities, Command Interpreter (IEEE Std 1003.2-1992.)</ref> |
|||
| {{yes|1983}}, [http://portal.acm.org/citation.cfm?id=988221 ANSI], ISO <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[BASIC]] |
|||
! [[BBj]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, education |
|||
| Application, business, Web <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{yes}}<br/>1983, ANSI, ISO, ECMA |
||
|- |
|||
|- align="center" |
|||
! [[BeanShell]] |
! scope="row" | [[BeanShell]] |
||
| <!-- Original purpose --> Application, scripting |
|||
| Application, scripting <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for BeanShell --> |
|||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| {{no |
| <!-- Standardized? --> {{no}}<br/>In progress, [[Java Community Process|JCP]]<ref>[http://jcp.org/en/jsr/detail?id=274 JSR 274]</ref> |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[BLISS]] |
|||
! [[BitC]] <!-- Language --> |
|||
| |
| <!-- Original purpose --> System |
||
<!-- |
| <!-- Imperative --> {{no}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[BlitzMax]] |
|||
! [[BLISS]] <!-- Language --> |
|||
| |
| <!-- Original purpose --> Application, game |
||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Boo (programming language)|Boo]] |
|||
! [[BlitzMax]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, game scripting |
|||
| Application, game <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{no}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[C (programming language)|C]] |
||
| <!-- Original purpose --> Application, system,<ref>[https://www.bell-labs.com/usr/dmr/www/chist.html bell-labs.com]</ref> general purpose, low-level operations |
|||
| Education <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| <!-- Standardized? --> {{yes}}<br/>1989, [[ANSI C|ANSI C89, ISO/IEC C90, ISO/IEC C95, ISO/IEC C99, ISO/IEC C11, ISO/IEC C17, ISO/IEC C2x]]<ref>[http://www.open-std.org/JTC1/SC22/WG14/ ANSI C89, ISO/IEC 9899:1990, 1999, 2011, 2018]</ref> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[C++]] |
|||
! [[Boo (programming language)|Boo]] <!-- Language --> |
|||
| |
| <!-- Original purpose --> Application, system |
||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| <!-- Standardized? --> {{yes}}<br/>1998, [[C++#Standardization|ISO/IEC C++98, ISO/IEC C++03, ISO/IEC C++11, ISO/IEC C++14, ISO/IEC C++17, ISO/IEC C++20, ISO/IEC C++23]]<ref>[http://www.open-std.org/JTC1/SC22/WG21/ ISO/IEC 14882:1998, 2003, 2011, 2014, 2017, 2020]</ref> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[C Sharp (programming language)|C#]] |
|||
! [[Bro (software)|Bro]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, RAD, business, client-side, general, server-side, web, [[game programming]] |
|||
| domain-specific, application <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- Functional --> {{yes}}<ref>[http://www.codeproject.com/KB/cs/intro_functional_csharp.aspx Codeproject.com: Functional Programming in C# 3.0 using Lambda Expression]</ref> |
|||
| <!-- Object-oriented --> |
|||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- |
| <!-- Other paradigms --> Structured, concurrent |
||
| <!-- Standardized? --> {{yes}}<br/>2000, ECMA, ISO<ref>ECMA-334; ISO/IEC 23270:2006</ref> |
|||
| {{Yes}}<!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[Clarion (programming language)|Clarion]] |
||
| <!-- Original purpose --> General, business, web |
|||
| Application, system,<ref>[http://cm.bell-labs.com/cm/cs/who/dmr/chist.html CM.bell-labs.com]</ref> general purpose, low-level operations <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- Functional --> {{yes}}<ref>[http://www.softvelocity.com Softvelocity.com]</ref> |
|||
| <!-- Object-oriented --> |
|||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| <!-- Standardized? --> {{unknown}} |
|||
| {{yes|1989}}, [[ANSI C|ANSI C89, ISO C90, ISO C99, ISO C11]]<ref>[http://www.open-std.org/JTC1/SC22/WG14/ ANSI C89, ISO/IEC 9899:1990, 1999, 2011]</ref> <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Clean (programming language)|Clean]] |
|||
! [[C++]] <!-- Language --> |
|||
| |
| <!-- Original purpose --> General |
||
<!-- |
| <!-- Imperative --> {{no}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| <!-- Standardized? --> {{no}} |
|||
| {{yes|1998}}, ISO/IEC 1998, ISO/IEC 2003, ISO/IEC 2011<ref>[http://www.open-std.org/JTC1/SC22/WG21/ ISO/IEC 14882:1998, 2003, 2011]</ref> <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Clojure]] |
|||
! [[C Sharp (programming language)|C#]] <!-- Language --> |
|||
| <!-- Original purpose --> General |
|||
| Application, RAD, business, client-side, general, server-side, Web <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{no}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| <!-- Procedural --> {{no}} |
|||
| {{Yes}}<ref>[http://www.codeproject.com/KB/cs/intro_functional_csharp.aspx Codeproject.com: Functional Programming in C# 3.0 using Lambda Expression]</ref> <!-- Functional --> |
|||
| |
| <!-- Generic --> {{no}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| |
| <!-- Other paradigms --> Concurrent |
||
| |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| structured, concurrent <!-- Other paradigms --> |
|||
| {{yes|2000}}, ECMA, ISO<ref>ECMA-334; ISO/IEC 23270:2006</ref> <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[CLU (programming language)|CLU]] |
||
| |
| <!-- Original purpose --> General |
||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- Procedural --> {{yes}} |
|||
| {{Yes}}<ref>[http://www.softvelocity.com Softvelocity.com]</ref> <!-- Functional --> |
|||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[COBOL]] |
|||
! [[Clean (programming language)|Clean]] <!-- Language --> |
|||
| |
| <!-- Original purpose --> Application, business |
||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{yes}}<br/>1968 ANSI X3.23, 1974, 1985; ISO/IEC 1989:1985, 2002, 2014, 2023 |
||
|- align="center" |
|||
! [[Clojure]] <!-- Language --> |
|||
| General <!-- Intended use --> |
|||
<!-- Sparse matrix for Clojure --> |
|||
| <!-- Imperative --> |
|||
| <!-- Object-oriented --> |
|||
| {{Yes}}<!-- Functional --> |
|||
| <!-- Procedural --> |
|||
| <!-- Generic --> |
|||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| concurrent <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[Cobra (programming language)|Cobra]] |
||
| <!-- Original purpose --> Application, business, general, web |
|||
| General <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{yes}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[ColdFusion Markup Language|ColdFusion]] (CFML) |
||
| |
| <!-- Original purpose --> Web |
||
<!-- |
| <!-- Imperative --> {{no}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Common Lisp]] |
|||
! [[Cobra (programming language)|Cobra]] <!-- Language --> |
|||
| <!-- Original purpose --> General |
|||
| Application, business, general, Web <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> Extensible syntax, [https://github.com/equwal/CLAPL Array-oriented], [[Macro (computer science)#Syntactic macros|syntactic macros]], [[multiple dispatch]], concurrent |
|||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{yes}}<br/>1994, ANSI |
||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[COMAL]] 80 |
|||
! [[ColdFusion Markup Language|ColdFusion]] (CFML) <!-- Language --> |
|||
| |
| <!-- Original purpose --> Education |
||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for ColdFusion(CFML) --> |
|||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Crystal (programming language)|Crystal]] |
|||
! [[Common Lisp]] <!-- Language --> |
|||
| |
| <!-- Original purpose --> General purpose |
||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Common Lisp --> |
|||
| <!-- Object-oriented --> {{yes}}<ref>{{Cite web|url=https://github.com/crystal-lang/crystal#why|title=Crystal|website=[[GitHub]]|date=2 November 2021}}</ref> |
|||
| {{Yes}}<!-- Imperative --> |
|||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- Generic --> {{yes}}<ref>{{Cite web|url=https://crystal-lang.org/reference/1.12/syntax_and_semantics/generics.html|title=Crystal Generics|website=crystal-lang.org|date=13 April 2024}}</ref> |
|||
| {{Yes}}<!-- Procedural --> |
|||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms -->Concurrent<ref>{{Cite web |title=Concurrency - Crystal |url=https://crystal-lang.org/reference/1.11/guides/concurrency.html |access-date=2024-04-02 |website=crystal-lang.org}}</ref> |
|||
| {{Yes}}<!-- Reflective --> |
|||
| |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| extensible syntax, [[Macro (computer science)#Syntactic macros|syntactic macros]], [[multiple dispatch]]<!-- Other paradigms --> |
|||
| {{yes|1994}}, ANSI <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Curry (programming language)|Curry]] |
|||
! [[COMAL]] 80 <!-- Language --> |
|||
| |
| <!-- Original purpose --> Application |
||
<!-- |
| <!-- Imperative --> {{no}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> [[lazy evaluation]], non-determinism |
|||
| <!-- Reflective --> |
|||
| <!-- Standardized? --> {{maybe|De facto}} standard via Curry Language Report |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Cython]] |
|||
! Crystal 1.0.0 <!-- Language --> |
|||
| <!-- Original purpose --> Application, general, [[numerical computing]] |
|||
| Education <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Crystal 1.0.0 --> |
|||
| |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> [[aspect-oriented programming|Aspect-oriented]] |
|||
| <!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[D (programming language)|D]] |
|||
! [[Cython]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, system |
|||
| Application, general, numerical computing <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> Generative, concurrent |
|||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| [[aspect-oriented programming|aspect-oriented]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[Dart (programming language)|Dart]] |
||
| <!-- Original purpose --> Application, web, server-side, mobile, [[Internet of things|IoT]] |
|||
| Application, system <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- |
| <!-- Other paradigms --> Structured |
||
| <!-- |
| <!-- Standardized? --> {{yes}}<br/>ECMA-408 standard |
||
<!-- -------------------- --> |
|||
| generative, concurrent <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Delphi (software)|Delphi]], [[Object Pascal]] |
|||
! [[Dart (programming language)|Dart]] <!-- Language --> |
|||
| <!-- Original purpose --> General purpose |
|||
| Application, Web <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| structured <!-- Other paradigms --> |
|||
| {{yes|Ecma-408 standard}} <!-- Standardized? --> |
|||
|- align="center" |
|||
! [[Dylan (programming language)|Dylan]] <!-- Language --> |
|||
| Application <!-- Intended use --> |
|||
<!-- Sparse matrix for Dylan --> |
|||
| <!-- Imperative --> |
|||
| {{Yes}}<!-- Object-oriented --> |
|||
| {{Yes}}<!-- Functional --> |
|||
| <!-- Procedural --> |
|||
| <!-- Generic --> |
|||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --><br/>? |
||
|- align="center" |
|||
|- |
|||
! [[Eiffel (programming language)|Eiffel]] <!-- Language --> |
|||
! scope="row" | [[Dylan (programming language)|Dylan]] |
|||
| Application <!-- Intended use --> |
|||
<!-- |
| <!-- Original purpose --> Application |
||
| |
| <!-- Imperative --> {{no}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- Functional --> |
| <!-- Functional --> {{yes}} |
||
| <!-- Procedural --> |
| <!-- Procedural --> {{no}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- Reflective --> |
| <!-- Reflective --> {{no}} |
||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[Eiffel (programming language)|Eiffel]] |
||
| <!-- Original purpose --> General, application, business, client-side, server-side, web (EWF) |
|||
| Application, distributed <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- Functional --> {{yes}}<ref>[http://se.ethz.ch/~meyer/publications/online/eiffel/basic.html#Agents: Basic Eiffel language mechanisms]</ref><ref>[[Closure (computer programming)#Inline agents .28Eiffel.29:|Closure (computer programming)]]</ref> |
|||
| <!-- Object-oriented --> |
|||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- Reflective --> {{yes}} [http://se.inf.ethz.ch/old/people/leitner/erl_g Erl-G] |
|||
| <!-- Generic --> |
|||
| <!-- Other paradigms --> Distributed [https://docs.eiffel.com/book/solutions/concurrent-eiffel-scoop: SCOOP], [https://docs.eiffel.com/book/method/void-safe-programming-eiffel: Void-safe] |
|||
| <!-- Reflective --> |
|||
| <!-- Standardized? --> {{yes}}<br/>2005, ECMA, ISO<ref>ECMA-367; ISO/IEC 25436:2006</ref> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| concurrent, [[distributed programming|distributed]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[ELAN (programming language)|ELAN]] |
||
| <!-- Original purpose --> Education |
|||
| Application, distributed, telecom <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> [[Structured programming|Structured]], [[Top-down and bottom-up design|stepwise refinement]] |
|||
| <!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| concurrent, [[distributed programming|distributed]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[Elixir (programming language)|Elixir]] |
||
| <!-- Original purpose --> Application, [[Distributed computing|distributed]] |
|||
| Application<!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{no}} |
||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> Concurrent, distributed |
|||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[Erlang (programming language)|Erlang]] |
||
| <!-- |
| <!-- Original purpose --> Application, distributed |
||
<!-- |
| <!-- Imperative --> {{no}} |
||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- |
| <!-- Other paradigms --> Concurrent, distributed |
||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| [[stack-oriented programming language|stack-oriented]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[Euphoria (programming language)|Euphoria]] |
||
| <!-- Original purpose --> Application |
|||
| General, Application <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{no}} |
||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{no}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- |
| <!-- Other paradigms --> |
||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| prototype OOP, message oriented, tabular programming <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[Factor (programming language)|Factor]] |
||
| <!-- |
| <!-- Original purpose --> General |
||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{maybe|Can be viewed as}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> [[stack-oriented programming|Stack-oriented]] |
|||
| <!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
|- |
|||
! scope="row" | [[FP (programming language)|FP]] |
|||
| <!-- Original purpose --> |
|||
| <!-- Imperative --> {{no}} |
|||
| <!-- Object-oriented --> {{no}} |
|||
| <!-- Functional --> {{yes}} |
|||
| <!-- Procedural --> {{no}} |
|||
| <!-- Generic --> {{no}} |
|||
| <!-- Reflective --> {{no}} |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[F Sharp (programming language)|F#]] |
! scope="row" | [[F Sharp (programming language)|F#]] |
||
| |
| <!-- Original purpose --> Application |
||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{yes}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[Forth (programming language)|Forth]] |
! scope="row" | [[Forth (programming language)|Forth]] |
||
| |
| <!-- Original purpose --> General |
||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- |
| <!-- Other paradigms --> Stack-oriented |
||
| <!-- |
| <!-- Standardized? --> {{yes}}<br/>1994, ANSI |
||
<!-- -------------------- --> |
|||
| stack-oriented <!-- Other paradigms --> |
|||
| {{yes|1994}}, ANSI <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[Fortran]] |
! scope="row" | [[Fortran]] |
||
| <!-- Original purpose --> Application, numerical computing |
|||
| Application, numerical computing <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> Array-based, vectorized, concurrent, native distributed/shared-memory parallelism |
|||
| <!-- Reflective --> |
|||
| <!-- Standardized? --> {{yes}}<br/>1966, ANSI 66, ANSI 77, MIL-STD-1753, ISO 90, ISO 95, ISO 2003, ISO/IEC 1539-1:2010 (2008), ISO/IEC JTC1/SC22/WG5 N2145 (2018) |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
|- |
|||
! scope="row" | [[FreeBASIC]] |
|||
| <!-- Original purpose --> Application, numerical computing |
|||
| <!-- Imperative --> {{yes}} |
|||
| <!-- Object-oriented --> {{yes}} |
|||
| <!-- Functional --> {{no}} |
|||
| <!-- Procedural --> {{yes}} |
|||
| <!-- Generic --> {{yes}} |
|||
| <!-- Reflective --> {{no}} |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| <!-- Standardized? --> {{no}} |
|||
| {{yes|1966}}, ANSI 66, ANSI 77, MIL-STD-1753, ISO 90, ISO 95, ISO 2003, ISO/IEC 1539-1:2010 (2008) <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Gambas]] |
|||
! [[FreeBASIC]] <!-- Language --> |
|||
| <!-- Original purpose --> Application |
|||
| Application, numerical computing <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for FreeBASIC --> |
|||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| |
| <!-- Generic --> {{no}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Game Maker Language]] |
|||
! G2 <!-- Language --> |
|||
| <!-- Original purpose --> Application, game programming |
|||
| Application, inference, expert system <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| {{Yes}}<!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| common graphical development and runtime environment <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- align="center" |
|||
! [[Gambas]] <!-- Language --> |
|||
| Application <!-- Intended use --> |
|||
<!-- Sparse matrix for Gambas --> |
|||
| {{Yes}}<!-- Imperative --> |
|||
| {{Yes}}<!-- Object-oriented --> |
|||
| <!-- Functional --> |
|||
| <!-- Procedural --> |
|||
| <!-- Generic --> |
|||
| <!-- Reflective --> |
|||
| {{Yes}}<!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[GLBasic]] |
|||
! [[Game Maker Language]] |
|||
| Application, games |
| <!-- Original purpose --> Application, games |
||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Game Maker Language --> |
|||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- |
| <!-- Other paradigms --> Simple object-oriented |
||
| |
| <!-- Standardized? --> {{no}} |
||
<!-- Other paradigms --> |
|||
| <!-- Other paradigms for Game Maker Language --> |
|||
| {{no}} |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Go (programming language)|Go]] |
|||
! [[GLBasic]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, web, server-side |
|||
| Application, games <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- Object-oriented --> {{maybe|Can be viewed as}}<ref>[https://golang.org/doc/faq#Is_Go_an_object-oriented_language The Go Programming Language (FAQ)]</ref> |
|||
| {{Yes}}<!-- Imperative --> |
|||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- |
| <!-- Other paradigms --> Concurrent |
||
| <!-- Standardized? --> {{maybe|De facto}} standard via Go Language Specification |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| simple object-oriented <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- align="center" |
|||
! [[Go (programming language)|Go]] <!-- Language --> |
|||
| Application, Web, server-side<!-- Intended use --> |
|||
<!-- Sparse matrix for Go --> |
|||
| {{Yes}}<!-- Imperative --> |
|||
| <!-- Object-oriented --> |
|||
| <!-- Functional --> |
|||
| {{Yes}}<!-- Procedural --> |
|||
| <!-- Generic --> |
|||
| {{Yes}}<!-- Reflective --> |
|||
| {{Yes}}<!-- Event-driven (channels are built-in) --> |
|||
<!-- -------------------- --> |
|||
| concurrent <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[Gosu (programming language)|Gosu]] |
! scope="row" | [[Gosu (programming language)|Gosu]] |
||
| <!-- Original purpose --> Application, general, scripting, web |
|||
| Application, general, scripting, Web <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{yes}} |
||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[GraphTalk]] |
! scope="row" | [[GraphTalk]] |
||
| |
| <!-- Original purpose --> Application |
||
| <!-- Imperative --> {{no}} |
|||
<!-- Sparse matrix for GraphTalk --> |
|||
| <!-- |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- |
| <!-- Other paradigms --> Logic |
||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| logic <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[Groovy (programming language)|Groovy]] |
! scope="row" | [[Groovy (programming language)|Groovy]] |
||
| <!-- Original purpose --> Application, general, scripting, web |
|||
| Application, general, scripting, Web <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- |
| <!-- Other paradigms --> Meta-programming |
||
| <!-- Standardized? --> {{no|In progress}}, [[Java Community Process|JCP]]<ref>[http://jcp.org/en/jsr/detail?id=241 JSR 241]</ref> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| aspect-oriented <!-- Other paradigms --> |
|||
| {{no|In progress}}, [[Java Community Process|JCP]]<ref>[http://jcp.org/en/jsr/detail?id=241 JSR 241]</ref> <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[Harbour (programming language)|Harbour]] |
! scope="row" | [[Harbour (programming language)|Harbour]] |
||
| Application, business, data processing, general, |
| <!-- Original purpose --> Application, business, data processing, general, web |
||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> [[declarative programming|Declarative]] |
|||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| [[declarative programming|declarative]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Haskell]] |
|||
! [[Haskell (programming language)|Haskell]] <!-- Language --> |
|||
| |
| <!-- Original purpose --> Application |
||
<!-- |
| <!-- Imperative --> {{no}} |
||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- |
| <!-- Other paradigms --> Lazy evaluation |
||
| <!-- Standardized? --> {{yes}}<br/>2010, Haskell 2010<ref>{{cite web |url=http://www.haskell.org/onlinereport/haskell2010/ |title=The Haskell 2010 Language Report |access-date=2011-12-07}} Most Haskell implementations extend the Haskell 2010 standard.</ref> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| [[lazy evaluation]] <!-- Other paradigms --> |
|||
| {{yes|2010}}, Haskell 2010<ref>{{cite web|url=http://www.haskell.org/onlinereport/haskell2010/ |title=The Haskell 2010 Language Report |accessdate=2011-12-07}} Most Haskell implementations extend the Haskell 2010 standard.</ref> <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[Haxe]] |
! scope="row" | [[Haxe]] |
||
| <!-- Original purpose --> Application, general, web |
|||
| Application, general, Web <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{yes}} |
||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[HyperTalk]] |
|||
! [[HyperNext]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, RAD, general |
|||
| Application, education <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for HyperNext --> |
|||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- |
| <!-- Other paradigms --> Weakly typed |
||
| |
| <!-- Standardized? --> {{unknown}} |
||
<!-- -------------------- --> |
|||
| [[weak typing|weakly typed]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Io (programming language)|Io]] |
|||
! [[HyperTalk]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, host-driven scripting |
|||
| Application, RAD, General <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for HyperTalk --> |
|||
| <!-- |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| [[weak typing|weakly typed]] <!-- Other paradigms --> |
|||
| {{unk}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Information Processing Language|IPL]] |
|||
! [[Io (programming language)|Io]] <!-- Language --> |
|||
| <!-- Original purpose --> General |
|||
| Application, host-driven scripting <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{no}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{unknown}} |
||
|- |
|||
|- align="center" |
|||
! [[ISLISP]] |
! scope="row" | [[ISLISP]] |
||
| |
| <!-- Original purpose --> General |
||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| {{yes |
| <!-- Standardized? --> {{yes}}<br/>1997, 2007, [[International Organization for Standardization|ISO]] |
||
|- |
|||
|- align="center" |
|||
! [[J (programming language)|J]] |
! scope="row" | [[J (programming language)|J]] |
||
| <!-- Original purpose --> Application, [[data processing]] |
|||
| Data processing <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> Array-oriented, [[function-level programming|function-level]], tacit, concurrent |
|||
| <!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| array-oriented, [[function-level programming|function-level]], tacit <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[JADE (programming language)|JADE]] |
! scope="row" | [[JADE (programming language)|JADE]] |
||
| <!-- Original purpose --> Application, distributed |
|||
| Application, distributed <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[Java (programming language)|Java]] |
! scope="row" | [[Java (programming language)|Java]] |
||
| Application, business, client-side, general, mobile development, server-side, |
| <!-- Original purpose --> Application, business, client-side, general, mobile development, server-side, web |
||
| <!-- Imperative --> {{yes}} |
|||
<!-- |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{yes}} |
||
| |
| <!-- Other paradigms --> Concurrent |
||
| <!-- Standardized? --> {{maybe|De facto}} standard via Java Language Specification |
|||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| concurrent <!-- Other paradigms --> |
|||
| {{yes|''De facto'' standard}} via [http://docs.oracle.com/javase/specs/jls/se8/html/index.html Java Language Specification] <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[JavaScript]] |
|||
! [[Julia (programming language)|Julia]] <!-- Language --> |
|||
| <!-- Original purpose --> Client-side, server-side, web |
|||
| General and made for technical computing <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| |
| <!-- Reflective --> {{yes}} |
||
| |
| <!-- Other paradigms --> [[prototype-based]] |
||
| <!-- Standardized? --> {{yes}}<br/>1997-2022, [[ECMA-262]] |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| [[multiple dispatch]], meta, scalar and [[Array programming|array-oriented]], parallel, concurrent, distributed ("cloud") <!-- Other paradigms --> |
|||
| {{No}}<!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Joy (programming language)|Joy]] |
|||
! [[JavaScript]] <!-- Language --> |
|||
| <!-- Original purpose --> Research |
|||
| Client-side, Server-side, Web <!-- Intended use --> |
|||
| <!-- Imperative --> {{no}} |
|||
<!-- Sparse matrix for JavaScript --> |
|||
| |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| |
| <!-- Other paradigms --> Stack-oriented |
||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| [[prototype-based]] <!-- Other paradigms --> |
|||
| {{yes|1997}}, ECMA <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[jq (programming language)|jq]] |
||
| |
| <!-- Original purpose --> "awk for JSON" |
||
<!-- |
| <!-- Imperative --> {{no}} |
||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> [[Tacit programming|Tacit]], [[Backtracking]], [[Generator (computer programming)|Streaming]], [[Parsing expression grammar|PEG]] |
|||
| <!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| stack-oriented <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[Julia (programming language)|Julia]] |
||
| <!-- Original purpose --> General, technical computing |
|||
| Data processing, business <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> Multiple dispatch, meta, scalar and array-oriented, parallel, concurrent, distributed ("cloud") |
|||
| <!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| array-oriented, tacit <!-- Other paradigms --> |
|||
| {{unk}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[K (programming language)|K]] |
||
| <!-- Original purpose --> Data processing, business |
|||
| Application, mobile development, server-sider, client-side, Web<!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{no}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{no}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> Array-oriented, tacit |
|||
| {{Yes}}<ref>{{cite web|url=http://blog.jetbrains.com/kotlin/2014/07/m8-is-out/|title=M8 is out!|quote=As a first peek into the future reflective capabilities of Kotlin, you can now access properties as first-class objects in Kotlin}}</ref><!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{unknown}} |
||
<!-- -------------------- --> |
|||
|- |
|||
! scope="row" | [[Kotlin (programming language)|Kotlin]] |
|||
| <!-- Original purpose --> Application, mobile development, server-side, client-side, web |
|||
| <!-- Imperative --> {{yes}} |
|||
| <!-- Object-oriented --> {{yes}} |
|||
| <!-- Functional --> {{yes}} |
|||
| <!-- Procedural --> {{yes}} |
|||
| <!-- Generic --> {{yes}} |
|||
| <!-- Reflective --> {{yes}}<ref>{{cite web |url=http://blog.jetbrains.com/kotlin/2014/07/m8-is-out/ |title=M8 is out! |date=2 July 2014 |quote=As a first peek into the future reflective capabilities of Kotlin, you can now access properties as first-class objects in Kotlin}}</ref> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{maybe|De facto}} standard via Kotlin Language Specification |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[KornShell|Ksh]] |
|||
! [[LabVIEW]] (G) <!-- Language --> |
|||
| <!-- Original purpose --> [[Shell (computing)|Shell]], [[Scripting language|scripting]] |
|||
| Application, industrial instrumentation-automation <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for LabVIEW (G) --> |
|||
| <!-- |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> Several variants, custom programmable, dynamic loadable modules |
|||
| <!-- Reflective --> |
|||
| <!-- Standardized? --> {{maybe|Optionally}}<br/>[[POSIX.2]]<ref name="POSIX 1003">[[POSIX.2]], Shell and Utilities, Command Interpreter (IEEE Std 1003.2-1992.)</ref> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| [[dataflow programming|dataflow]], [[visual programming language|visual]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[LabVIEW]] (G) |
|||
! [[Lisp (programming language)|Lisp]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, industrial instrumentation-automation |
|||
| General <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> [[dataflow programming|Dataflow]], [[visual programming language|visual]] |
|||
| <!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
|- |
|||
! scope="row" | [[Lisp (programming language)|Lisp]] |
|||
| <!-- Original purpose --> General |
|||
| <!-- Imperative --> {{no}} |
|||
| <!-- Object-oriented --> {{no}} |
|||
| <!-- Functional --> {{yes}} |
|||
| <!-- Procedural --> {{no}} |
|||
| <!-- Generic --> {{no}} |
|||
| <!-- Reflective --> {{no}} |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{unknown}} |
||
|- |
|||
|- align="center" |
|||
! [[LiveCode |
! scope="row" | [[LiveCode]] |
||
| <!-- Original purpose --> Application, RAD, general |
|||
| Application, RAD, General <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Livecode --> |
|||
| <!-- |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- |
| <!-- Other paradigms --> Weakly typed |
||
| |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| [[weak typing|weakly typed]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[Logtalk]] |
! scope="row" | [[Logtalk]] |
||
| <!-- Original purpose --> Artificial intelligence, application |
|||
| Artificial intelligence, application <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{no}} |
||
| <!-- |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| |
| <!-- Other paradigms --> Logic |
||
| |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| logic <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Linden Scripting Language]] (LSL) |
|||
! [[Lua (programming language)|Lua]] <!-- Language --> |
|||
| <!-- Original purpose --> Virtual worlds content scripting and animation |
|||
| Application, embedded scripting <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| <!-- Functional --> {{no}} |
|||
| {{Yes}}<ref>Lua doesn't have explicit "object" type (more general type of "table" is used for object definition), but does have explicit syntax for object method calling</ref> <!-- Object-oriented --> |
|||
| |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> Scripts exist in in-world objects |
|||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- Standardized? --> {{maybe|De facto}} reference is the [[Second Life]] implementation of [[Linden Scripting Language|LSL]].<ref>Halcyon (Inworldz) and Open Sims propose compatible implementations with additional functions.</ref> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| aspect-oriented <!-- Other paradigms --> |
|||
| {{no}}<ref>Version releases are accompanied with a definitive Lua Reference Manual showing full syntax and semantics; a reference implementation, and a test suite. These are used to generate other Lua [[virtual machine|VM]] implementations and compilers such as [[Kahlua (software)|Kahlua]] and [[LLVM-Lua]].</ref> <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Lua (programming language)|Lua]] |
|||
! [[Maple (software)|Maple]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, embedded scripting |
|||
| Symbolic computation, numerical computing <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- Object-oriented --> {{yes}}<ref>Lua does not have explicit "object" type (more general type of "table" is used for object definition), but does have explicit syntax for object method calling</ref> |
|||
| {{Yes}}<!-- Imperative --> |
|||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> Aspect-oriented, prototype-based |
|||
| <!-- Reflective --> |
|||
| <!-- Standardized? --> {{no}}<ref>Version releases are accompanied with a definitive Lua Reference Manual showing full syntax and semantics; a reference implementation, and a test suite. These are used to generate other Lua [[virtual machine|VM]] implementations and compilers such as Kahlua and LLVM-Lua.</ref> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| [[distributed programming|distributed]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Maple (software)|Maple]] |
|||
! [[Mathematica]] <!-- Language --> |
|||
| <!-- Original purpose --> Symbolic computation, numerical computing |
|||
| Symbolic language <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Mathematica --> |
|||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- |
| <!-- Other paradigms --> Distributed |
||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| logic, distributed <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Mathematica]] |
|||
! [[MATLAB]] <!-- Language --> |
|||
| <!-- Original purpose --> [[Symbolic language (programming)|Symbolic language]] |
|||
| Highly domain-specific, numerical computing <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- |
| <!-- Other paradigms --> Logic, distributed |
||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
|- |
|||
! scope="row" | [[MATLAB]] |
|||
| <!-- Original purpose --> Highly domain-specific, numerical computing |
|||
| <!-- Imperative --> {{yes}} |
|||
| <!-- Object-oriented --> {{yes}} |
|||
| <!-- Functional --> {{no}} |
|||
| <!-- Procedural --> {{yes}} |
|||
| <!-- Generic --> {{no}} |
|||
| <!-- Reflective --> {{no}} |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[Modula-2]] |
! scope="row" | [[Modula-2]] |
||
| <!-- Original purpose --> Application, system |
|||
| Application, system <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Modula-2 --> |
|||
| |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| {{yes |
| <!-- Standardized? --> {{yes}}<br/>1996, ISO<ref>ISO/IEC 10514-1:1996</ref> |
||
|- |
|||
|- align="center" |
|||
! [[Modula-3]] |
! scope="row" | [[Modula-3]] |
||
| |
| <!-- Original purpose --> Application |
||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Modula-3 --> |
|||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[MUMPS |
! scope="row" | [[MUMPS]] (M) |
||
| <!-- Original purpose --> General, application, databases |
|||
| Application, databases <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- Object-oriented --> {{planned|Approved for next Standard}} |
|||
| {{Yes}}<!-- Imperative --> |
|||
| <!-- |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- Generic --> {{some|Partially}} Thru Indirection and Xecute |
|||
| {{Yes}}<!-- Procedural --> |
|||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> [[Concurrent computing|Concurrent]], [[multi-user]], [[NoSQL]], [[transaction processing]] |
|||
| <!-- Reflective --> |
|||
| <!-- Standardized? --> {{yes}}<br/>1977 ANSI, 1995, ISO 2020 |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| [[Concurrent computing|concurrent]], [[multi-user]], [[NoSQL]], [[transaction processing]]<!-- Other paradigms --> |
|||
| {{yes|1977}}, ANSI <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[Nim (programming language)|Nim]] |
! scope="row" | [[Nim (programming language)|Nim]] |
||
| Application, general, |
| <!-- Original purpose --> Application, general, web, scripting, system |
||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> Multiple dispatch, concurrent, [[Metaprogramming|meta]] |
|||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| [[Multiple dispatch|multiple dispatch]], Concurrent, [[Metaprogramming|meta]]<!-- Other paradigms --> |
|||
| {{no}}<!-- Standardized? --> |
|||
|- |
|||
! scope="row" | [[Oberon (programming language)|Oberon]] |
|||
|- align="center" |
|||
| <!-- Original purpose --> Application, system |
|||
! [[Oberon (programming language)|Oberon]] <!-- Language --> |
|||
| |
| <!-- Imperative --> {{yes}} |
||
<!-- |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Generic --> |
|||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[Object Pascal]] |
! scope="row" | [[Object Pascal]] |
||
| <!-- Original purpose --> Application, general, mobile app, web |
|||
| Application, general, mobile App, Web <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{yes}} |
||
| |
| <!-- Other paradigms --> Structured |
||
| |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| structured <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[Objective-C]] |
! scope="row" | [[Objective-C]] |
||
| <!-- Original purpose --> Application, general |
|||
| Application, general <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Objective-C --> |
|||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| |
| <!-- Other paradigms --> Concurrent |
||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| concurrent <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[OCaml]] |
! scope="row" | [[OCaml]] |
||
| <!-- Original purpose --> Application, general |
|||
| Application <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[Occam (programming language)|Occam]] |
! scope="row" | [[Occam (programming language)|Occam]] |
||
| |
| <!-- Original purpose --> General |
||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> Concurrent, [[process-oriented programming|process-oriented]] |
|||
| <!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| concurrent, [[process-oriented programming|process-oriented]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[Opa (programming language)|Opa]] |
! scope="row" | [[Opa (programming language)|Opa]] |
||
| <!-- Original purpose --> Web applications |
|||
| Web applications <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- |
| <!-- Other paradigms --> Distributed |
||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| [[distributed programming|distributed]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[OpenLisp]] |
|||
! [[Oxygene (programming language)|Oxygene]] <!-- Language --> |
|||
| <!-- Original purpose --> General, Embedded Lisp Engine |
|||
| Application <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{maybe|Optionally}}<br/> [[ISLISP]] |
||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[Oxygene (programming language)|Oxygene]] |
||
| <!-- Original purpose --> Application |
|||
| Application, distribution, education <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| concurrent, logic <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- align="center" |
|||
! [[Pascal (programming language)|Pascal]] <!-- Language --> |
|||
| Application, education <!-- Intended use --> |
|||
<!-- Sparse matrix for Pascal --> |
|||
| {{Yes}}<!-- Imperative --> |
|||
| <!-- Object-oriented --> |
|||
| <!-- Functional --> |
|||
| {{Yes}}<!-- Procedural --> |
|||
| <!-- Generic --> |
|||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Oz (programming language)|Oz-Mozart]] |
|||
! [[Perl]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, distribution, education |
|||
| Application, scripting, text processing, Web <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| |
| <!-- Generic --> {{no}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| |
| <!-- Other paradigms --> Concurrent, logic |
||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
|- |
|||
! scope="row" | [[Pascal (programming language)|Pascal]] |
|||
| <!-- Original purpose --> Application, education |
|||
| <!-- Imperative --> {{yes}} |
|||
| <!-- Object-oriented --> {{no}} |
|||
| <!-- Functional --> {{no}} |
|||
| <!-- Procedural --> {{yes}} |
|||
| <!-- Generic --> {{no}} |
|||
| <!-- Reflective --> {{no}} |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{yes}}<br/>1983, ISO<ref>ISO 7185</ref> |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Perl]] |
|||
! [[PHP]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, scripting, text processing, Web |
|||
| Server-side, Web Application, Web <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- Functional --> {{yes}} |
|||
| {{Yes}}<ref>[http://php.net/manual/en/index.php PHP Manual], [http://php.net/manual/en/language.oop5.php Chapter 19. Classes and Objects (PHP 5)],</ref> <!-- Object-oriented --> |
|||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- Generic --> {{yes}} |
|||
| {{Yes}}<ref>[http://php.net/manual/en/index.php PHP Manual], [http://php.net/manual/en/language.functions.php Chapter 17. Functions]</ref> <!-- Procedural --> |
|||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[PHP]] |
|||
! [[PL/I]] <!-- Language --> |
|||
| <!-- Original purpose --> Server-side, web application, web |
|||
| Application <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- Object-oriented --> {{yes}}<ref>[http://php.net/manual/en/index.php PHP Manual], [http://php.net/manual/en/language.oop5.php Chapter 19. Classes and Objects (PHP 5)],</ref> |
|||
| {{Yes}}<!-- Imperative --> |
|||
| <!-- Functional --> {{yes}}<ref>[http://php.net/manual/en/index.php PHP Manual], [http://php.net/manual/en/language.functions.php Chapter 17. Functions]</ref> |
|||
| {{Yes}}<!-- Object-oriented --> |
|||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| <!-- Standardized? --> {{maybe|De facto}} standard via language specification and Requests for Comments (RFCs) |
|||
| {{yes|1969}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[PL/I]] |
|||
! [[Plus (programming language)|Plus]] <!-- Language --> |
|||
| <!-- Original purpose --> Application |
|||
| Application, system development <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{yes}}<br/>1969, ECMA-50 (1976) |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Plus (programming language)|Plus]] |
|||
! [[Prolog]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, system development |
|||
| Application, artificial intelligence <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| logic <!-- Other paradigms --> |
|||
| {{yes|1995}}, ISO <!-- Standardized? --> |
|||
|- align="center" |
|||
! [[PureBasic]] <!-- Language --> |
|||
| Application <!-- Intended use --> |
|||
<!-- Sparse matrix for PureBasic --> |
|||
| <!-- Imperative --> |
|||
| <!-- Object-oriented --> |
|||
| <!-- Functional --> |
|||
| {{Yes}}<!-- Procedural --> |
|||
| <!-- Generic --> |
|||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[PostScript]] |
|||
! [[Python (programming language)|Python]] <!-- Language --> |
|||
| <!-- Original purpose --> Graphics, page description |
|||
| Application, general, Web, scripting, artificial intelligence, scientific computing <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{no}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> [[Concatenative programming language|Concatenative]], [[Stack-oriented programming|stack-oriented]] |
|||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- Standardized? --> {{maybe|De facto}} standard via the PostScript Reference Manual<ref>{{Cite web |url=https://www.adobe.com/products/postscript/pdfs/PLRM.pdf |title=PostScript Language Reference Manual |access-date=2017-02-18 |archive-url=https://web.archive.org/web/20170218093716/https://www.adobe.com/products/postscript/pdfs/PLRM.pdf |archive-date=2017-02-18 |url-status=dead}}</ref> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| aspect-oriented <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Windows PowerShell|PowerShell]] |
|||
! [[Racket (programming language)|Racket]] <!-- Language --> |
|||
| <!-- Original purpose --> Administration, application, general, scripting |
|||
| Education, general, scripting <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> [[pipeline programming|Pipeline]] |
|||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| modular, logic, meta <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Prolog]] |
|||
! [[REALbasic]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, artificial intelligence |
|||
| Application <!-- Intended use --> |
|||
| <!-- Imperative --> {{no}} |
|||
<!-- Sparse matrix for REALbasic --> |
|||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- |
| <!-- Other paradigms --> Logic, declarative |
||
| <!-- Standardized? --> {{yes}}<br/>1995, ISO/IEC 13211-1:1995, TC1 2007, TC2 2012, TC3 2017 |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
|- |
|||
! scope="row" | [[PureBasic]] |
|||
| <!-- Original purpose --> Application |
|||
| <!-- Imperative --> {{yes}} |
|||
| <!-- Object-oriented --> {{no}} |
|||
| <!-- Functional --> {{no}} |
|||
| <!-- Procedural --> {{yes}} |
|||
| <!-- Generic --> {{no}} |
|||
| <!-- Reflective --> {{no}} |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Python (programming language)|Python]] |
|||
! [[REBOL]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, general, web, scripting, artificial intelligence, scientific computing |
|||
| Distributed <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- |
| <!-- Other paradigms --> Aspect-oriented |
||
| <!-- Standardized? --> {{maybe|De facto}} standard via Python Enhancement Proposals (PEPs) |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| [[dialecting|dialected]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[R (programming language)|R]] |
|||
! [[IBM RPG|RPG]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, statistics |
|||
| Application, system <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[Racket (programming language)|Racket]] |
||
| <!-- Original purpose --> Education, general, scripting |
|||
| Application, scripting, Web <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> [[Modular programming|Modular]], logic, meta |
|||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| aspect-oriented <!-- Other paradigms --> |
|||
| {{yes|2011(JIS X 3017), 2012(ISO/IEC 30170)}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[Raku (programming language)|Raku]] |
||
| <!-- Original purpose --> Scripting, text processing, glue |
|||
| Application, system <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> Aspect-oriented, array, lazy evaluation, multiple dispatch, metaprogramming |
|||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| concurrent <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[REALbasic]] |
|||
! [[S (programming language)|S]] <!-- Language --> |
|||
| <!-- Original purpose --> Application |
|||
| Application, statistics <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{no}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{no}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{unknown}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Rebol]] |
|||
! [[S-Lang (programming library)|S-Lang]] <!-- Language --> |
|||
| <!-- Original purpose --> Distributed |
|||
| Application, numerical, scripting <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- |
| <!-- Other paradigms --> [[dialecting|Dialected]] |
||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[REXX]] |
|||
! [[Scala (programming language)|Scala]] <!-- Language --> |
|||
| <!-- Original purpose --> Scripting |
|||
| Application, distributed, Web <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- Object-oriented --> {{yes}} ([[NetRexx]] and [[Object REXX]] dialects) |
|||
| {{Yes}}<!-- Imperative --> |
|||
| |
| <!-- Functional --> {{no}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| {{Yes}}<!-- Reflective --> |
|||
| {{Yes}}<!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| <!-- Standardized? --> {{yes}}<br/>1996 (ANSI X3.274-1996) |
|||
| {{yes|''De facto'' standard}} via [http://www.scala-lang.org/sites/default/files/linuxsoft_archives/docu/files/ScalaReference.pdf Scala Language Specification (SLS)] <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[IBM RPG|RPG]] |
|||
! [[Scheme (programming language)|Scheme]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, system |
|||
| Education, general <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Ring (programming language)|Ring]] |
|||
! [[Seed7]] <!-- Language --> |
|||
| <!-- Original purpose --> Application |
|||
| Application, general, scripting, Web <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> metaprogramming, declarative, [[natural-language programming|natural-language]] |
|||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| multi-paradigm, extensible, structured <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Ruby (programming language)|Ruby]] |
|||
! [[Simula]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, scripting, web |
|||
| Education, general <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- |
| <!-- Other paradigms --> Aspect-oriented |
||
| <!-- Standardized? --> {{yes}}<br/>2011(JIS X 3017), 2012(ISO/IEC 30170) |
|||
| {{Yes}}<!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| [[discrete event simulation]], [[multi-threaded]] (quasi-parallel) program execution <!-- Other paradigms --> |
|||
| {{yes|1968}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Rust (programming language)|Rust]] |
|||
! [[Microsoft Small Basic|Small Basic]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, server-side, system, web |
|||
| Application, education, games <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Small Basic --> |
|||
| <!-- Object-oriented --> {{yes}}<ref>[https://doc.rust-lang.org/book/ch17-00-oop.html Is Rust an Object-Oriented Programming Language?]</ref> |
|||
| {{Yes}}<!-- Imperative --> |
|||
| <!-- |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- Reflective --> {{no}}<ref>{{cite book |last1=Klabnik |first1=Steve |last2=Nichols |first2=Carol |title=The Rust Programming Language |url=https://doc.rust-lang.org/book/title-page.html |chapter=Macros |chapter-url=https://doc.rust-lang.org/book/ch19-06-macros.html}}</ref> |
|||
| <!-- Generic --> |
|||
| <!-- |
| <!-- Other paradigms --> Concurrent |
||
| |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| [[component-oriented programming|component-oriented]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[S (programming language)|S]] |
|||
! [[Smalltalk]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, statistics |
|||
| Application, General, Business, Web, Artificial Intelligence, Education <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Smalltalk --> |
|||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{yes}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| {{Yes}}<!-- Reflective --> |
|||
| {{Yes}}<!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| concurrent, declarative <!-- Other paradigms --> |
|||
| {{yes|1998}}, [http://www.techstreet.com/cgi-bin/detail?product_id=56122 ANSI] <!-- Standardized? --> |
|||
|- align="center" |
|||
! [[SNOBOL]] <!-- Language --> |
|||
| Text processing <!-- Intended use --> |
|||
<!-- Sparse matrix for SNOBOL --> |
|||
| <!-- Imperative --> |
|||
| <!-- Object-oriented --> |
|||
| <!-- Functional --> |
|||
| <!-- Procedural --> |
|||
| <!-- Generic --> |
|||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! scope="row" | [[S-Lang]] |
|||
! [[Standard ML]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, numerical, scripting |
|||
| Application <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Standard ML --> |
|||
| |
| <!-- Object-oriented --> {{no}} |
||
| <!-- |
| <!-- Functional --> {{no}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{no}} |
||
|- |
|||
|- align="center" |
|||
! [[ |
! scope="row" | [[Scala (programming language)|Scala]] |
||
| <!-- Original purpose --> Application, general, parallel, distributed, web |
|||
| Application, general <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> Data-oriented programming, metaprogramming |
|||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- Standardized? --> {{maybe|De facto}} standard via Scala Language Specification (SLS) |
|||
| {{Yes}}<!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| concurrent <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Scheme (programming language)|Scheme]] |
|||
! [[Tcl]] <!-- Language --> |
|||
| <!-- Original purpose --> Education, general |
|||
| Application, scripting, Web <!-- Intended use --> |
|||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> meta, extensible-syntax |
|||
| {{Yes}}<!-- Reflective --> |
|||
| <!-- Standardized? --> {{maybe|De facto}}<br/>1975-2013, R<sup>0</sup>RS, R<sup>1</sup>RS, R<sup>2</sup>RS, R<sup>3</sup>RS, R<sup>4</sup>RS, R<sup>5</sup>RS, R<sup>6</sup>RS, R<sup>7</sup>RS Small Edition<ref>[https://standards.scheme.org/ R<sup>3</sup>RS, R<sup>4</sup>RS, R<sup>5</sup>RS, R<sup>6</sup>RS, R<sup>7</sup>RS Small Edition]</ref><ref>[https://standards.scheme.org/early/ R<sup>0</sup>RS, R<sup>1</sup>RS, R<sup>2</sup>RS]</ref> |
|||
| {{Yes}}<!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Seed7]] |
|||
! [[Visual Basic]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, general, scripting, web |
|||
| Application, RAD, education, business, general, (Includes VBA), office automation <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Visual Basic --> |
|||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| |
| <!-- Reflective --> {{yes}} |
||
| <!-- Other paradigms --> Multi-paradigm, extensible, structured |
|||
| <!-- Reflective --> |
|||
| |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| [[component-oriented programming|component-oriented]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Simula]] |
|||
! {{nowrap|[[Visual Basic .NET]]}} <!-- Language --> |
|||
| <!-- Original purpose --> Education, general |
|||
| Application, RAD, education, Web, business, general <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Visual Basic .NET --> |
|||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> [[discrete event simulation]], [[multi-threaded]] (quasi-parallel) program execution |
|||
| {{Yes}}<!-- Reflective --> |
|||
| |
| <!-- Standardized? --> {{yes}}<br/>1968 |
||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Microsoft Small Basic|Small Basic]] |
|||
! [[Visual FoxPro]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, education, games |
|||
| Application <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Visual FoxPro --> |
|||
| <!-- |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{no}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Other paradigms --> [[component-oriented programming|Component-oriented]] |
|||
| <!-- Reflective --> |
|||
| <!-- |
| <!-- Standardized? --> {{no}} |
||
<!-- -------------------- --> |
|||
| data-centric, logic <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Smalltalk]] |
|||
! [[Visual Prolog]] <!-- Language --> |
|||
| <!-- Original purpose --> Application, general, business, artificial intelligence, education, web |
|||
| Application <!-- Intended use --> |
|||
| <!-- Imperative --> {{yes}} |
|||
<!-- Sparse matrix for Visual Prolog --> |
|||
| |
| <!-- Object-oriented --> {{yes}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| |
| <!-- Procedural --> {{yes}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{yes}} |
||
| <!-- |
| <!-- Other paradigms --> Concurrent, declarative |
||
| |
| <!-- Standardized? --> {{yes}}<br/>1998, ANSI |
||
<!-- -------------------- --> |
|||
| declarative, logic <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[SNOBOL]] |
|||
! [[Windows PowerShell]] <!-- Language --> |
|||
| |
| <!-- Original purpose --> Text processing |
||
| <!-- Imperative --> {{no}} |
|||
<!-- Sparse matrix for Windows PowerShell --> |
|||
| |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{no}} |
||
| |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{no}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| |
| <!-- Other paradigms --> |
||
| <!-- |
| <!-- Standardized? --> {{unknown}} |
||
<!-- -------------------- --> |
|||
| [[pipeline programming|pipeline]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- |
|||
|- align="center" |
|||
! scope="row" | [[Standard ML]] |
|||
! [[XL (programming language)|XL]] <!-- Language --> |
|||
| <!-- |
| <!-- Original purpose --> Application |
||
<!-- |
| <!-- Imperative --> {{yes}} |
||
| |
| <!-- Object-oriented --> {{no}} |
||
| |
| <!-- Functional --> {{yes}} |
||
| <!-- |
| <!-- Procedural --> {{no}} |
||
| <!-- |
| <!-- Generic --> {{yes}} |
||
| <!-- |
| <!-- Reflective --> {{no}} |
||
| <!-- Reflective --> |
|||
| <!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| [[concept programming]] <!-- Other paradigms --> |
|||
| {{no}} <!-- Standardized? --> |
|||
|- align="center" |
|||
! [[Xojo]] <!-- Language --> |
|||
| Application, RAD, General, Web <!-- Intended use --> |
|||
<!-- Sparse matrix for Xojo --> |
|||
| {{Yes}}<!-- Imperative --> |
|||
| {{Yes}}<!-- Object-oriented --> |
|||
| <!-- Functional --> |
|||
| {{Yes}}<!-- Procedural --> |
|||
| <!-- Generic --> |
|||
| {{Yes}}<!-- Reflective --> |
|||
| {{Yes}}<!-- Event-driven --> |
|||
<!-- -------------------- --> |
|||
| <!-- Other paradigms --> |
| <!-- Other paradigms --> |
||
| |
| <!-- Standardized? --> {{yes}}<br/>1997, SML '97<ref>[http://www.smlnj.org/sml97.html SMLNJ.org]</ref> |
||
|- |
|||
<!-- -------------------- --> |
|||
! scope="row" | [[Swift (programming language)|Swift]] |
|||
|- align="center"class="sortbottom" |
|||
| <!-- Original purpose --> Application, general |
|||
! Language |
|||
| <!-- Imperative --> {{yes}} |
|||
! Intended use <!--What this was to be used for originally. Not what it is used for now, which is hard to verify.--> |
|||
| <!-- Object-oriented --> {{yes}} |
|||
! Imperative |
|||
| <!-- Functional --> {{yes}} |
|||
! Object-oriented |
|||
| <!-- Procedural --> {{yes}} |
|||
! Functional |
|||
| <!-- Generic --> {{yes}} |
|||
! Procedural |
|||
| <!-- Reflective --> {{yes}} |
|||
! Generic |
|||
| <!-- Other paradigms --> Concurrent, declarative, [[Protocol (object-oriented programming)|protocol-oriented]] |
|||
! Reflective |
|||
| <!-- Standardized? --> {{no}} |
|||
! Event-driven |
|||
! Other paradigm(s) |
|||
! Standardized? |
|||
|} |
|||
==Type systems== |
|||
Brief definitions |
|||
* A [[Nominative type system|nominal type system]] means that the language decides whether types are compatible and/or equivalent based on explicit declarations and names. |
|||
* A [[structural type system]] means that the language decides whether types are compatible and/or equivalent based on the definition and characteristics of the types. |
|||
* ''Type checking'' determines whether and when types are verified. Static checking means that type errors are reported based on a program's text (source code). Dynamic checking means that type errors are reported based on a program's dynamic (run-time) behavior. |
|||
{| class="wikitable sortable" |
|||
|- |
|- |
||
! scope="row" | [[Tcl]] |
|||
! Language |
|||
| <!-- Original purpose --> Application, scripting, web |
|||
! [[Type safety]] |
|||
| <!-- Imperative --> {{yes}} |
|||
! [[Type system#Explicit or implicit declaration and inference|Type expression]] |
|||
| <!-- Object-oriented --> {{yes}} |
|||
! [[Type equivalence|Type compatibility and equivalence]] <!-- dynamic typing doesn't automatically mean it has structural compatibility --> |
|||
| <!-- Functional --> {{yes}} |
|||
! [[Type checking]] |
|||
| <!-- Procedural --> {{yes}} |
|||
| <!-- Generic --> {{no}} |
|||
| <!-- Reflective --> {{yes}} |
|||
| <!-- Other paradigms --> |
|||
| <!-- Standardized? --> {{no}} |
|||
|- |
|- |
||
! scope="row" | [[V (programming language)|V (Vlang)]] |
|||
! [[ActionScript]] 3.0 |
|||
| <!-- Original purpose --> Application, general, system, game, web, server-side |
|||
| {{Yes|safe}} |
|||
| <!-- Imperative --> {{yes}} |
|||
| implicit with optional explicit typing |
|||
| <!-- Object-oriented --> {{maybe|Can be viewed as}} |
|||
| |
|||
| <!-- Functional --> {{maybe|Can be viewed as}} |
|||
| static |
|||
| <!-- Procedural --> {{yes}} |
|||
| <!-- Generic --> {{yes}} |
|||
| <!-- Reflective --> {{yes}} |
|||
| <!-- Other paradigms --> Concurrent |
|||
| <!-- Standardized? --> {{no}} |
|||
|- |
|- |
||
! scope="row" | [[Visual Basic (classic)|Visual Basic]] |
|||
! [[Ada (programming language)|Ada]] |
|||
| <!-- Original purpose --> Application, RAD, education, business, general, (Includes VBA), office automation |
|||
| {{Yes|safe}}<ref group=TS>Unsafe operations are well isolated by a "Unchecked_" prefix.</ref> |
|||
| <!-- Imperative --> {{yes}} |
|||
| explicit |
|||
| <!-- Object-oriented --> {{yes}} |
|||
| nominal |
|||
| <!-- Functional --> {{no}} |
|||
| static |
|||
| <!-- Procedural --> {{yes}} |
|||
| <!-- Generic --> {{yes}} |
|||
| <!-- Reflective --> {{no}} |
|||
| <!-- Other paradigms --> Component-oriented |
|||
| <!-- Standardized? --> {{no}} |
|||
|- |
|- |
||
! scope="row" | {{nowrap|[[Visual Basic .NET]]}} |
|||
! [[Aldor]] |
|||
| <!-- Original purpose --> Application, RAD, education, web, business, general |
|||
| {{No|unsafe}} |
|||
| <!-- Imperative --> {{yes}} |
|||
| implicit |
|||
| <!-- Object-oriented --> {{yes}} |
|||
| |
|||
| <!-- Functional --> {{yes}} |
|||
| static |
|||
| <!-- Procedural --> {{yes}} |
|||
| <!-- Generic --> {{yes}} |
|||
| <!-- Reflective --> {{yes}} |
|||
| <!-- Other paradigms --> Structured, concurrent |
|||
| <!-- Standardized? --> {{no}} |
|||
|- |
|- |
||
! [[ |
! scope="row" | [[Visual FoxPro]] |
||
| <!-- Original purpose --> Application |
|||
| {{Yes|safe}} |
|||
| <!-- Imperative --> {{yes}} |
|||
| explicit |
|||
| <!-- Object-oriented --> {{yes}} |
|||
| |
|||
| <!-- Functional --> {{no}} |
|||
| static |
|||
| <!-- Procedural --> {{yes}} |
|||
| <!-- Generic --> {{no}} |
|||
| <!-- Reflective --> {{no}} |
|||
| <!-- Other paradigms --> Data-centric, logic |
|||
| <!-- Standardized? --> {{no}} |
|||
|- |
|- |
||
! [[ |
! scope="row" | [[Visual Prolog]] |
||
| <!-- Original purpose --> Application |
|||
| {{Yes|safe}} |
|||
| <!-- Imperative --> {{yes}} |
|||
| explicit |
|||
| <!-- Object-oriented --> {{yes}} |
|||
| |
|||
| <!-- Functional --> {{yes}} |
|||
| static |
|||
| <!-- Procedural --> {{no}} |
|||
| <!-- Generic --> {{no}} |
|||
| <!-- Reflective --> {{no}} |
|||
| <!-- Other paradigms --> Declarative, logic |
|||
| <!-- Standardized? --> {{no}} |
|||
|- |
|- |
||
! scope="row" | [[Wolfram Language]] |
|||
! [[ALGOL 68]] |
|||
| <!-- Original purpose --> Symbolic language |
|||
| {{Yes|safe}} |
|||
| <!-- Imperative --> {{yes}} |
|||
| explicit |
|||
| <!-- Object-oriented --> {{yes}} |
|||
| structural |
|||
| <!-- Functional --> {{yes}} |
|||
| static & [[tagged union]]s |
|||
| <!-- Procedural --> {{yes}} |
|||
| <!-- Generic --> {{yes}} |
|||
| <!-- Reflective --> {{yes}} |
|||
| <!-- Other paradigms --> Logic, distributed |
|||
| <!-- Standardized? --> {{no}} |
|||
|- |
|- |
||
! [[ |
! scope="row" | [[XL (programming language)|XL]] |
||
| <!-- Original purpose --> |
|||
| {{Yes|safe}} |
|||
| <!-- Imperative --> {{yes}} |
|||
| |
|||
| <!-- Object-oriented --> {{yes}} |
|||
| |
|||
| <!-- Functional --> {{no}} |
|||
| dynamic |
|||
| <!-- Procedural --> {{no}} |
|||
| <!-- Generic --> {{no}} |
|||
| <!-- Reflective --> {{no}} |
|||
| <!-- Other paradigms --> [[concept programming]] |
|||
| <!-- Standardized? --> {{no}} |
|||
|- |
|- |
||
! scope="row" | [[Xojo]] |
|||
! [[AutoHotkey]] |
|||
| <!-- Original purpose --> Application, RAD, general, web |
|||
| typeless |
|||
| <!-- Imperative --> {{yes}} |
|||
| n/a |
|||
| <!-- Object-oriented --> {{yes}} |
|||
| n/a |
|||
| <!-- Functional --> {{no}} |
|||
| n/a |
|||
| <!-- Procedural --> {{yes}} |
|||
| <!-- Generic --> {{no}} |
|||
| <!-- Reflective --> {{yes}} |
|||
| <!-- Other paradigms --> |
|||
| <!-- Standardized? --> {{no}} |
|||
|- |
|- |
||
! scope="row" | [[XPath]]/[[XQuery]] |
|||
! [[Ateji PX]] |
|||
| <!-- Original purpose --> Databases, data processing, scripting |
|||
| {{Yes|safe}} |
|||
| <!-- Imperative --> {{no}} |
|||
| explicit |
|||
| <!-- Object-oriented --> {{no}} |
|||
| nominal |
|||
| <!-- Functional --> {{yes}} |
|||
| static |
|||
| <!-- Procedural --> {{no}} |
|||
| <!-- Generic --> {{no}} |
|||
| <!-- Reflective --> {{no}} |
|||
| <!-- Other paradigms --> [[Tree (data structure)|Tree-oriented]] |
|||
| <!-- Standardized? --> {{yes}}<br/>1999 W3C XPath 1, 2010 W3C XQuery 1, 2014 W3C XPath/XQuery 3.0 |
|||
|- |
|- |
||
! scope="row" | [[Zeek]] |
|||
! [[Bash (Unix shell)|Bash]] |
|||
| <!-- Original purpose --> Domain-specific, application |
|||
| {{?}} |
|||
| {{ |
| <!-- Imperative --> {{yes}} |
||
| <!-- Object-oriented --> {{no}} |
|||
| {{?}} |
|||
| {{ |
| <!-- Functional --> {{no}} |
||
| <!-- Procedural --> {{no}} |
|||
| <!-- Generic --> {{no}} |
|||
| <!-- Reflective --> {{no}} |
|||
| <!-- Other paradigms --> |
|||
| <!-- Standardized? --> {{no}} |
|||
|- |
|- |
||
! scope="row" | [[Zig (programming language)|Zig]] |
|||
! [[BASIC]] |
|||
| <!-- Original purpose --> Application, general, system |
|||
| {{Yes|safe}} |
|||
| <!-- Imperative --> {{yes}} |
|||
| explicit |
|||
| <!-- Object-oriented --> {{no}} |
|||
| nominal |
|||
| <!-- Functional --> {{yes}} |
|||
| static |
|||
| <!-- Procedural --> {{yes}} |
|||
|- |
|||
| <!-- Generic --> {{yes}} |
|||
! [[BLISS]] |
|||
| <!-- Reflective --> {{yes}} |
|||
| typeless |
|||
| <!-- Other paradigms --> Concurrent |
|||
| n/a |
|||
| <!-- Standardized? --> {{no}} |
|||
| n/a |
|||
| n/a |
|||
|- |
|||
! [[BeanShell]] |
|||
| {{Yes|safe}} |
|||
| |
|||
| nominal |
|||
| dynamic |
|||
|- |
|||
! [[Boo (programming language)|Boo]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| |
|||
| static with optional dynamic typing |
|||
|- |
|||
! [[Bro (software)|Bro]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[C (programming language)|C]] |
|||
| {{No|unsafe}} |
|||
| explicit |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[C++]] ([[ISO/IEC 14882]]) |
|||
| {{No|unsafe}} |
|||
| explicit |
|||
| nominal |
|||
| static<ref group=TS>with optional dynamic type casting (see [[dynamic cast]])</ref> |
|||
|- |
|||
! [[C Sharp (programming language)|C#]] |
|||
| {{No|unsafe}}<ref group=TS name=r2 /> |
|||
| implicit with optional explicit typing |
|||
| nominal |
|||
| static<ref group=TS>with optional dynamic type (see [[C Sharp syntax#Dynamic|dynamic member lookup]])</ref> |
|||
|- |
|||
! [[Clean (programming language)|Clean]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| |
|||
| static |
|||
|- |
|||
! [[Clojure]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[COBOL]] |
|||
| {{Yes|safe}} |
|||
| explicit |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[ColdFusion Markup Language|ColdFusion]] (CFML) |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Common Lisp]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Curl (programming language)|Curl]] |
|||
| {{Yes|safe}} |
|||
| |
|||
| nominal |
|||
| |
|||
|- |
|||
! [[Cython]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| nominal (extension types) and structural (Python) |
|||
| dynamic with optional static typing |
|||
|- |
|||
! [[D (programming language)|D]] |
|||
| {{No|unsafe}}<ref group=TS name=r2>It is almost safe, unsafe features are not commonly used.</ref> |
|||
| explicit |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[Dylan (programming language)|Dylan]] |
|||
| {{Yes|safe}} |
|||
| |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Eiffel (programming language)|Eiffel]] |
|||
| {{Yes|safe}} |
|||
| |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[Erlang (programming language)|Erlang]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Euphoria (programming language)|Euphoria]] |
|||
| {{Yes|safe}} |
|||
| explicit, implicit with objects |
|||
| nominal |
|||
| static, dynamic with objects |
|||
|- |
|||
! [[F Sharp (programming language)|F#]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[Falcon (programming language)|Falcon]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| structural |
|||
| dynamic |
|||
|- |
|||
! [[Forth (programming language)|Forth]] |
|||
| typeless |
|||
| n/a |
|||
| n/a |
|||
| n/a |
|||
|- |
|||
! [[Fortran]] |
|||
| {{Yes|safe}} |
|||
| explicit<ref group=TS>Optionally, typing can be ''explicitly implied'' by the first letter of the identifier (known as implicit typing within the Fortran community).</ref> |
|||
| nominal |
|||
| static |
|||
|- |
|- |
||
! scope="row" | [[Z shell|Zsh]] |
|||
! [[Gambas]] |
|||
| <!-- Original purpose --> [[Shell (computing)|Shell]], [[Scripting language|scripting]] |
|||
| {{Yes|safe}} |
|||
| <!-- Imperative --> {{yes}} |
|||
| explicit |
|||
| <!-- Object-oriented --> {{no}} |
|||
| nominal |
|||
| <!-- Functional --> {{no}} |
|||
| |
|||
| <!-- Procedural --> {{yes}} |
|||
|- |
|||
| <!-- Generic --> {{no}} |
|||
! [[GLBasic]] |
|||
| <!-- Reflective --> {{no}} |
|||
| {{Yes|safe}} |
|||
| <!-- Other paradigms --> Loadable modules |
|||
| explicit. Non-explicit declarations available through project options |
|||
| <!-- Standardized? --> {{maybe|Optionally}}<br/>[[POSIX.2]]<ref name="POSIX 1003">[[POSIX.2]], Shell and Utilities, Command Interpreter (IEEE Std 1003.2-1992.)</ref> |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[Go (programming language)|Go]]<ref>[http://golang.org/doc/go_spec.html The Go Programming Language Specification]</ref> |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| structural |
|||
| static |
|||
|- |
|||
! [[Gosu (programming language)|Gosu]] |
|||
| {{Yes|safe}} |
|||
| partially implicit (local type inference) |
|||
| nominal (subclassing) and structural (structural) |
|||
| static |
|||
|- |
|||
! [[Groovy (programming language)|Groovy]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| |
|||
| dynamic with optional static typing |
|||
|- |
|||
! [[Harbour (programming language)|Harbour]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Haskell (programming language)|Haskell]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| structural |
|||
| static |
|||
|- |
|||
! [[Haxe]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| nominal (subclassing) and structural (structural) |
|||
| static with optional dynamic typing |
|||
|- |
|||
! [[Io (programming language)|Io]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[ISLISP]] |
|||
| {{Yes|safe}} |
|||
| |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[J (programming language)|J]] |
|||
| {{Yes|safe}} |
|||
| |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Java (programming language)|Java]] |
|||
| {{Yes|safe}}<ref>Sheng Liang, Gilad Bracha. [http://doi.acm.org/10.1145/286942.286945 Dynamic class loading in the Java virtual machine]. Volume 33, Issue 10 of ACM SIGPLAN Notices, October 1998.</ref> |
|||
| explicit |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[JavaScript]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| structural |
|||
| dynamic |
|||
|- |
|||
! [[Julia (programming language)|Julia]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing<ref>http://julia.readthedocs.org/en/latest/manual/types/</ref> |
|||
| |
|||
| |
|||
|- |
|||
! [[Joy (programming language)|Joy]] |
|||
| {{Yes|safe}} |
|||
| |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Kotlin (programming language)|Kotlin]] |
|||
| {{Yes|safe}} |
|||
| partially implicit (local type inference) |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[LabVIEW]] |
|||
| {{Yes|safe}} |
|||
| |
|||
| |
|||
| |
|||
|- |
|||
! [[Lua (programming language)|Lua]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Maple (programming language)|Maple]] |
|||
| {{Yes|safe}} |
|||
| |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Mathematica]] |
|||
| {{Yes|safe}} |
|||
| |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[MATLAB]] M-code |
|||
| {{Yes|safe}} |
|||
| |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Modula-2]] |
|||
| {{No|unsafe}}<ref group=TS name=r2 /> |
|||
| explicit |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[Modula-3]] |
|||
| {{No|unsafe}}<ref group=TS name=r2 /> |
|||
| explicit |
|||
| structural |
|||
| static |
|||
|- |
|||
! [[MUMPS|MUMPS (M)]] |
|||
| typeless |
|||
| n/a |
|||
| n/a |
|||
| n/a |
|||
|- |
|||
! [[Oberon (programming language)|Oberon]] |
|||
| {{Yes|safe}} |
|||
| explicit |
|||
| nominal |
|||
| static and partially dynamic<ref group=TS>dynamic checking of type extensions i.e. inherited types</ref> |
|||
|- |
|||
! [[Objective-C]] |
|||
| {{Yes|safe}} |
|||
| explicit |
|||
| nominal |
|||
| dynamic with optional static typing<ref>[http://developer.apple.com/documentation/Cocoa/Conceptual/ObjectiveC/Articles/ocStaticBehavior.html Developer.apple.com]</ref> |
|||
|- |
|||
! [[OCaml]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| structural (records are nominal) |
|||
| static |
|||
|- |
|||
! [[Object Pascal]] ([[Embarcadero Delphi|Delphi]]) |
|||
| {{Yes|safe}} |
|||
| explicit |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[Opa (programming language)|Opa]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| structural |
|||
| static |
|||
|- |
|||
! [[Oxygene (programming language)|Oxygene]] |
|||
| {{No|unsafe}} |
|||
| implicit |
|||
| |
|||
| static |
|||
|- |
|||
! [[Oz (programming language)|Oz]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| structural |
|||
| dynamic |
|||
|- |
|||
! [[Pascal (programming language)|Pascal]] |
|||
| {{No|unsafe}}<ref group=TS name=r2 /> |
|||
| explicit |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[Perl]] 5 |
|||
| |
|||
| implicit |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Perl 6]] |
|||
| |
|||
| partially implicit<ref group=TS>explicit for static types</ref> |
|||
| |
|||
| dynamic with optional static typing |
|||
|- |
|||
! [[PHP]] |
|||
| |
|||
| implicit |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Plus (programming language)|Plus]] |
|||
| {{Yes|safe}} |
|||
| explicit |
|||
| structural |
|||
| static, dynamic (optional) |
|||
|- |
|||
! [[Prolog]] |
|||
| |
|||
| |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Pure (programming language)|Pure]] |
|||
| |
|||
| |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Python (programming language)|Python]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| structural |
|||
| dynamic |
|||
|- |
|||
! [[REBOL]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Rexx]] |
|||
| typeless |
|||
| n/a, implicit wrt numbers |
|||
| n/a |
|||
| static+dynamic wrt numbers |
|||
|- |
|||
! [[IBM RPG|RPG]] |
|||
| {{No|unsafe}} |
|||
| |
|||
| |
|||
| static |
|||
|- |
|||
! [[Ruby (programming language)|Ruby]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| structural |
|||
| dynamic |
|||
|- |
|||
! [[Rust (programming language)|Rust]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| |
|||
| static with optional dynamic typing |
|||
|- |
|||
! [[S (programming language)|S]] |
|||
| |
|||
| |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[S-Lang (programming library)|S-Lang]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Scala (programming language)|Scala]] |
|||
| {{Yes|safe}} |
|||
| partially implicit (local type inference) |
|||
| nominal (subclassing) and structural (structural) |
|||
| static |
|||
|- |
|||
! [[Scheme (programming language)|Scheme]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| |
|||
| dynamic ([[Latent_typing|latent]]) |
|||
|- |
|||
! [[Seed7]] |
|||
| {{Yes|safe}} |
|||
| explicit |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[Simula]] |
|||
| {{Yes|safe}} |
|||
| |
|||
| |
|||
| static<ref group=TS>optional for formal and virtual procedures</ref> |
|||
|- |
|||
! [[Smalltalk]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Swift (programming language)|Swift]] |
|||
| {{Yes|safe}} |
|||
| partially implicit (local type inference) |
|||
| nominal (subclassing) and structural (structural) |
|||
| static |
|||
|- |
|||
! [[Standard ML]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| structural |
|||
| static |
|||
|- |
|||
! [[Tcl]] |
|||
| |
|||
| |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[Visual Basic]] |
|||
| {{Yes|safe}} |
|||
| implicit with optional explicit typing |
|||
| nominal |
|||
| static |
|||
|- |
|||
! {{nowrap|[[Visual Basic .NET]]}} |
|||
| {{No|unsafe}}<ref group=TS name=r2 /> |
|||
| explicit |
|||
| |
|||
| static |
|||
|- |
|||
! [[Visual Prolog]] |
|||
| {{Yes|safe}} |
|||
| partially implicit |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[Windows PowerShell]] |
|||
| {{Yes|safe}} |
|||
| implicit |
|||
| |
|||
| dynamic |
|||
|- |
|||
! [[XL (programming language)|XL]] |
|||
| {{Yes|safe}} |
|||
| |
|||
| nominal |
|||
| static |
|||
|- |
|||
! [[Xojo]] |
|||
| {{Yes|safe}} |
|||
| explicit |
|||
| nominal |
|||
| static |
|||
|- class="sortbottom" |
|||
! Language |
|||
! Type safety |
|||
! Type expression |
|||
! Type compatibility among composites |
|||
! Type checking |
|||
|} |
|} |
||
==Type systems== |
|||
{{Reflist|group=TS}} |
|||
{{main|Comparison of programming languages by type system}} |
|||
==Failsafe I/O and system calls== |
==Failsafe I/O and system calls== |
||
Most programming languages will print an [[error message]] |
Most programming languages will print an [[error message]] or throw an [[exception handling|exception]] if an [[input/output]] operation or other [[system call]] (e.g., [[chmod]], [[kill (Unix)|kill]]) fails, unless the programmer has explicitly arranged for different handling of these events. Thus, these languages [[failsafe|fail safely]] in this regard. |
||
Some (mostly older) languages require that |
Some (mostly older) languages require that programmers explicitly add checks for these kinds of errors. Psychologically, different [[List of cognitive biases|cognitive biases]] (e.g., [[optimism bias]]) may affect novices and experts alike and lead them to skip these checks. This can lead to [[software bug|erroneous behavior]]. |
||
'''Failsafe I/O''' is a feature of [[1C:Enterprise programming language|1C:Enterprise]], [[Ada (programming language)|Ada]] (exceptions), [[ALGOL]] (exceptions or return value depending on function), [[Ballerina (programming language)|Ballerina]], [[C Sharp (programming language)|C#]], [[Common Lisp]] ("conditions and restarts" system), [[Curry (programming language)|Curry]], [[D (programming language)|D]] (throwing on failure),<ref>{{Cite web|url=https://dlang.org/phobos/std_stdio.html|title=STD.stdio - D Programming Language}}</ref> [[Erlang (programming language)|Erlang]], [[Fortran]], [[Go (programming language)|Go]] (unless result explicitly ignored), [[Gosu (programming language)|Gosu]], [[Harbour (programming language)|Harbour]], [[Haskell]], [[ISLISP]], [[Java (programming language)|Java]], [[Julia (programming language)|Julia]], [[Kotlin (programming language)|Kotlin]], [[LabVIEW]], [[Mathematica]], [[Objective-C]] (exceptions), [[OCaml]] (exceptions), [[OpenLisp]], [[PHP]], [[Python (programming language)|Python]], [[Raku (programming language)|Raku]], [[Rebol]], [[Rexx]] (with optional '''signal on'''... trap handling), [[Ring (programming language)|Ring]], [[Ruby (programming language)|Ruby]], [[Rust (programming language)|Rust]] (unless result explicitly ignored), [[Scala (programming language)|Scala]],<ref>Scala runs on the Java Virtual Machine from which it inherits the runtime exception handling.</ref> [[Smalltalk]], [[Standard ML]] {{citation needed|date=February 2011}}, [[Swift (programming language)|Swift ≥ 2.0]] (exceptions), [[Tcl]], [[Visual Basic (classic)|Visual Basic]], [[Visual Basic (.NET)|Visual Basic .NET]], [[Visual Prolog]], [[Wolfram Language]], [[Xojo]], [[XPath]]/[[XQuery]] (exceptions), and [[Zeek]]. |
|||
{|class="wikitable sortable" |
|||
|- |
|||
'''No Failsafe I/O''': |
|||
! Language |
|||
[[AutoHotkey]] (global ErrorLevel must be explicitly checked), [[C (programming language)|C]],<ref name="VS">[[GNU compiler collection|gcc]] can warn on unchecked [[errno.h|errno]]. Newer versions of [[Visual Studio]] usually throw exceptions on failed I/O when using [[C file input/output|stdio]].</ref> [[COBOL]], [[Eiffel (programming language)|Eiffel]] (it actually depends on the library and it is not defined by the language), [[GLBasic]] (will generally cause program to crash), [[IBM RPG|RPG]], [[Lua (programming language)|Lua]] (some functions do not warn or throw exceptions), and [[Perl]].<ref>Considerable error checking can be enabled optionally, but by default Perl is not failsafe.</ref> |
|||
! Failsafe I/O |
|||
|- |
|||
! [[Ada (programming language)|Ada]] |
|||
| {{yes}} (exceptions) |
|||
|- |
|||
! [[ALGOL]] |
|||
| {{yes}} (exceptions or return value depending on function) |
|||
|- |
|||
! [[AutoHotkey]] |
|||
| {{no}} (global ErrorLevel must be explicitly checked) |
|||
|- |
|||
! [[Bash (Unix shell)|Bash]] |
|||
| {{?}} |
|||
|- |
|||
! [[Bro (software)|Bro]] |
|||
| {{yes}} |
|||
|- |
|||
! [[C (programming language)|C]] |
|||
| {{no}}<ref group="FSIO">[[GNU compiler collection|gcc]] can warn on unchecked error status. Newer versions of [[Visual Studio]] usually throw exceptions on failed I/O when using stdio.</ref> |
|||
|- |
|||
! [[C++]] |
|||
| {{no}}<ref name="VS" group="FSIO">[[GNU compiler collection|g++]] can warn on unchecked error status. Newer versions of [[Visual Studio]] usually throw exceptions on failed I/O when using stdio.</ref> |
|||
|- |
|||
! [[C Sharp (programming language)|C#]] |
|||
| {{yes}} |
|||
|- |
|||
! [[COBOL]] |
|||
| {{no}} |
|||
|- |
|||
! [[Common Lisp]] |
|||
| {{yes}} |
|||
|- |
|||
! [[D (programming language)|D]] |
|||
| {{yes}}{{citation needed|date=February 2011}} |
|||
|- |
|||
! [[Eiffel (programming language)|Eiffel]] |
|||
| {{no}} – It actually depends on the library and it is not defined by the language |
|||
|- |
|||
! [[Erlang (programming language)|Erlang]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Falcon (programming language)|Falcon]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Fortran]] |
|||
| {{yes}} |
|||
|- |
|||
! [[GLBasic]] |
|||
| {{no}} – Will generally cause program to crash |
|||
|- |
|||
! [[Go (programming language)|Go]] |
|||
| {{yes}} (unless result explicitly ignored) |
|||
|- |
|||
! [[Gosu (programming language)|Gosu]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Harbour (programming language)|Harbour]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Haskell (programming language)|Haskell]] |
|||
| {{yes}} |
|||
|- |
|||
! [[ISLISP]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Java (programming language)|Java]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Julia (programming language)|Julia]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Kotlin (programming language)|Kotlin]] |
|||
| {{yes}} |
|||
|- |
|||
! [[LabVIEW]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Lua (programming language)|Lua]] |
|||
| {{no}} (some functions do not warn or throw exceptions) |
|||
|- |
|||
! [[Mathematica]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Object Pascal]] ([[Embarcadero Delphi|Delphi]]) |
|||
| {{some}} |
|||
|- |
|||
! [[Objective-C]] |
|||
| {{yes}} (exceptions) |
|||
|- |
|||
! [[OCaml]] |
|||
| {{yes}} (exceptions) |
|||
|- |
|||
! [[Perl]] |
|||
| {{no}}<ref group="FSIO">Considerable error checking can be enabled optionally, but by default Perl is not failsafe.</ref> |
|||
|- |
|||
! [[Perl 6]] |
|||
| {{yes}} |
|||
|- |
|||
! [[PHP]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Python (programming language)|Python]] |
|||
| {{yes}} |
|||
|- |
|||
! [[REBOL]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Rexx]] |
|||
| {{yes}} (with optional '''signal on'''… trap handling) |
|||
|- |
|||
! [[IBM RPG|RPG]] |
|||
| {{no}} |
|||
|- |
|||
! [[Ruby (programming language)|Ruby]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Rust (programming language)|Rust]] |
|||
| {{yes}} (unless result explicitly ignored) |
|||
|- |
|||
! [[S (programming language)|S]] |
|||
| {{unknown}} |
|||
|- |
|||
! [[Smalltalk (programming language)|Smalltalk]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Scala (programming language)|Scala]] |
|||
| {{yes}}<ref>Scala runs on the Java Virtual Machine from which it inherits the runtime exception handling.</ref> |
|||
|- |
|||
! [[Standard ML]] |
|||
| {{yes}}{{citation needed|date=February 2011}} |
|||
|- |
|||
! [[Tcl]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Visual Basic]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Visual Prolog]] |
|||
| {{yes}} |
|||
|- |
|||
! [[Xojo]] |
|||
| {{yes}} |
|||
|- class="sortbottom" |
|||
! Language |
|||
! Failsafe I/O |
|||
|} |
|||
Some I/O checking is built in [[C++]] ([[Input/output (C++)|STL iostreams]] throw on failure but C APIs like [[C file input/output|stdio]] or [[C POSIX library|POSIX]] do not)<ref name="VS"/> and [[Object Pascal]], in [[Bash (Unix shell)|Bash]]<ref><code>set -e</code> enables termination if any unchecked [[exit status]] is nonzero.</ref> it is optional. |
|||
{{Reflist|group=FSIO}} |
|||
==Expressiveness== |
==Expressiveness== |
||
{| |
{|class="wikitable sortable" style="float:right;" |
||
|- |
|- |
||
! scope="col" | Language |
|||
! Language !! Statements ratio<ref>Data from [http://books.google.at/books?id=3JfE7TGUwvgC&pg=PT100 Code Complete, p. 100]. The ''Statements ratio'' column "shows typical ratios of source statements in several high-level languages to the equivalent code in C. A higher ratio means that each line of code in the language listed accomplishes more than does each line of code in C.</ref> |
|||
! scope="col" | Statements ratio<ref>Data from {{cite book |last=McConnell |first=Steve |date=30 November 2009 |url=https://books.google.com/books?id=3JfE7TGUwvgC&pg=PT100 |title=Code Complete |page=100 |publisher=Microsoft Press |isbn=9780735636972}} The ''Statements ratio'' column "shows typical ratios of source statements in several high-level languages to the equivalent code in C. A higher ratio means that each line of code in the language listed accomplishes more than does each line of code in C.</ref> |
|||
! Lines ratio<ref>The ratio of line count tests won by each language to the number won by C when using the ''Compare to'' feature at [http://benchmarksgame.alioth.debian.org/debian/c.php benchmarksgame.alioth.debian.org]. Last updated May, 2006. C gcc was used for C, C++ g++ was used for C++, FORTRAN G95 was used for FORTRAN, Java JDK Server was used for Java, and Smalltalk GST was used for Smalltalk.</ref> |
|||
! scope="col" | Lines ratio<ref>The ratio of line count tests won by each language to the number won by C when using the ''Compare to'' feature at {{cite web |url=https://blog.wolfram.com/2012/11/14/code-length-measured-in-14-languages/ |title=Code Length Measured in 14 Languages |last=McLoone |first=Jon |date=November 14, 2012 |archive-url=https://web.archive.org/web/20121119043607/https://blog.wolfram.com/2012/11/14/code-length-measured-in-14-languages/ |archive-date=2012-11-19}} C gcc was used for C, C++ g++ was used for C++, FORTRAN G95 was used for FORTRAN, Java JDK Server was used for Java, and Smalltalk GST was used for Smalltalk.</ref> |
|||
|- |
|- |
||
| C || 1 || 1 |
| C || 1 || 1 |
||
Line 2,680: | Line 1,735: | ||
|} |
|} |
||
The literature on programming languages contains an abundance of informal claims about their relative [[expressive power]], but there is no framework for formalizing such statements nor for deriving interesting consequences.<ref>{{cite conference | |
The literature on programming languages contains an abundance of informal claims about their relative [[Expressive power (computer science)|expressive power]], but there is no framework for formalizing such statements nor for deriving interesting consequences.<ref>{{cite conference |citeseerx=10.1.1.51.4656 |title=On the Expressive Power of Programming Languages |first=Matthias |last=Felleisen |conference=ESOP '90 3rd European Symposium on Programming}}</ref> This table provides two measures of expressiveness from two different sources. An additional measure of expressiveness, in GZip bytes, can be found on the Computer Language Benchmarks Game.<ref>{{Cite web|url=https://benchmarksgame-team.pages.debian.net/benchmarksgame/how-programs-are-measured.html#source-code|title=How programs are measured |website=Computer Language Benchmarks Game|access-date=2018-05-29}}</ref> |
||
{{-}} |
{{-}} |
||
==Benchmarks== |
==Benchmarks== |
||
[[File:Barplot language speeds (Benchmarks Game Mandelbrot).svg|thumb|Barplot of log-time to produce a 1600² Mandelbrot<ref>{{Cite book|last=Mandelbrot|first=Benoit B. |title=The fractal geometry of nature|date=1982|isbn=0-7167-1186-9|edition=Revised |location=San Francisco|oclc=7876824}}</ref> as reported in ''The Benchmarks Game''<ref>{{Cite web|title=Mandelbrot |website=Computer Language Benchmarks Game|url=https://benchmarksgame-team.pages.debian.net/benchmarksgame/performance/mandelbrot.html|access-date=2021-07-09}}</ref>]] |
|||
[[benchmark (computing)|Benchmarks]] are designed to mimic a particular type of workload on a component or system. The computer programs used for compiling some of the benchmark data in this section may not have been fully optimized, and the relevance of the data is disputed. The most accurate benchmarks are those that are customized to your particular situation. Other people's benchmark data may have some value to others, but proper interpretation brings many [[benchmark (computing)#Challenges|challenges]]. [http://benchmarksgame.alioth.debian.org/ The Computer Language Benchmarks Game] site warns against [http://benchmarksgame.alioth.debian.org/dont-jump-to-conclusions.php over-generalizing from benchmark data], but contains a large number of micro-benchmarks of reader-contributed code snippets, with an interface that generates various charts and tables comparing specific programming languages and types of tests. |
|||
[[benchmark (computing)|Benchmarks]] are designed to mimic a particular type of workload on a component or system. The computer programs used for compiling some of the benchmark data in this section may not have been fully optimized, and the relevance of the data is disputed. The most accurate benchmarks are those that are customized to your particular situation. Other people's benchmark data may have some value to others, but proper interpretation brings many [[benchmark (computing)#Challenges|challenges]]. [[The Computer Language Benchmarks Game]] site warns against over-generalizing from benchmark data, but contains a large number of micro-benchmarks of reader-contributed code snippets, with an interface that generates various charts and tables comparing specific programming languages and types of tests.<ref>{{Cite web |url=https://benchmarksgame-team.pages.debian.net/benchmarksgame/dont-jump-to-conclusions.html |title=The Ultimate Benchmark |website=The Computer Language Benchmarks Game |access-date=2018-05-29}}</ref> |
|||
==Timeline of specific language comparisons== |
==Timeline of specific language comparisons== |
||
* |
* 1974 – Comparative Notes on Algol 68 and PL/I<ref>{{cite journal |last1=Valentine |first1=S. H. |date=November 1974 |title=Comparative Notes on Algol 68 and PL/I |journal=The Computer Journal |volume=17 |issue=4 |pages=325–331 |doi=10.1093/comjnl/17.4.325 |doi-access=free}}</ref> – S. H. Valentine – November 1974 |
||
* 1976 – Evaluation of [[ALGOL 68]], [[JOVIAL]] J3B, [[Pascal (programming language)|Pascal]], [[Simula]] 67, and [[TACPOL]] Versus TINMAN – Requirements for a Common High Order Programming Language. |
* 1976 – Evaluation of [[ALGOL 68]], [[JOVIAL]] J3B, [[Pascal (programming language)|Pascal]], [[Simula]] 67, and [[TACPOL]] Versus TINMAN – Requirements for a Common High Order Programming Language.<!-- [https://web.archive.org/web/20170523233517/http://www.dtic.mil/srch/doc?collection=t2&id=ADA037637 Report Number: 1021-14] --> |
||
* 1977 – |
* 1977 – A comparison of PASCAL and ALGOL 68<ref>{{Cite web|url=http://dare.ubvu.vu.nl/bitstream/1871/2609/1/11054.pdf|title=Vrije Universiteit Amsterdam}}</ref> – [[Andrew S. Tanenbaum]] – June 1977. |
||
* 1993 – |
* 1993 – Five Little Languages and How They Grew – [[BLISS]], [[Pascal (programming language)|Pascal]], [[ALGOL 68]], [[BCPL]] & [[C (programming language)|C]] – [[Dennis M. Ritchie]] – April 1993. |
||
* 2009 – |
* 2009 – On Go – oh, go on – How well will Google's [[Go (programming language)|Go]] stand up against Brand X programming language? – David Given – November 2009 |
||
==See also== |
==See also== |
||
{{Category tree all|Lists of programming languages|mode=all|depth=2}} |
|||
* [[Comparison of basic instructions of programming languages]] |
|||
* [[Comparison of programming languages ( |
* [[Comparison of programming languages (basic instructions)]] |
||
* [[Comparison of programming languages (strings)]] |
|||
* [[Comparison of programming languages (syntax)]] |
* [[Comparison of programming languages (syntax)]] |
||
* [[Comparison of |
* [[Comparison of integrated development environments]] |
||
* [[Comparison of programming languages (object-oriented programming)]] |
|||
* [[Comparison of programming languages (list comprehension)]] |
|||
* [[Comparison of programming languages (mapping)]] |
|||
* [[Comparison of programming paradigms]] |
|||
* [[Comparison of multi-paradigm programming languages]] |
* [[Comparison of multi-paradigm programming languages]] |
||
* [[Comparison of type systems]] |
|||
* [[Educational programming language]] |
|||
* [[Hello world program examples]] |
|||
* [[Measuring programming language popularity]] |
|||
* [[Programming language]] |
|||
* [[TIOBE index]] |
* [[TIOBE index]] |
||
==References== |
==References== |
||
{{Reflist| |
{{Reflist|30em}} |
||
==Further reading== |
==Further reading== |
||
* {{cite book|title=A Guide to Programming Languages: Overview and Comparison| |
* {{cite book |last=Cezzar |first=Ruknet |year=1995 |title=A Guide to Programming Languages: Overview and Comparison |publisher=Artech House |isbn=978-0-89006-812-0 |url-access=registration |url=https://archive.org/details/authenticationsy0000oppl}} |
||
{{Programming languages}} |
|||
==External links== |
|||
* {{Dmoz|Computers/Programming/Languages/Comparison_and_Review}} |
|||
* [http://99-bottles-of-beer.net/ 99-bottles-of-beer.net] — one program in over a thousand variations and multiple languages. |
|||
* [http://gmarceau.qc.ca/blog/2009/05/speed-size-and-dependability-of.html The speed, size and dependability of programming languages] — charts and narrative based on The Computer Language Benchmarks Game data. |
|||
* [http://benchmarksgame.alioth.debian.org/u32/code-used-time-used-shapes.php Shapes: Source Code Size and Run Time] - charts based on current Benchmarks Game data. |
|||
* [http://www.scriptol.com/programming/choose.php Comparison of syntaxes] with sample codes. |
|||
* [http://rigaux.org/language-study/syntax-across-languages.html Syntax Across Languages] |
|||
* [http://merd.sourceforge.net/pixel/language-study/scripting-language/ Scriptometer scores] — multiple comparisons of 26 programming languages. |
|||
* [http://pleac.sourceforge.net/ PLEAC] — Programming Language Examples Alike Cookbook. |
|||
* [http://www.ohloh.net/languages OHLOH Language Statistics] — gives an indication of the popularity of programming languages in open-source projects. |
|||
* [http://hhh.gavilan.edu/dvantassel/history/history.html History of Programming Language Statements] — history and comparison of programming languages. |
|||
* [http://rosettacode.org/ Rosetta Code] — a programming language comparison wiki |
|||
[[Category:Programming language comparisons| ]] |
|||
{{DEFAULTSORT:Comparison of programming languages}} |
|||
[[Category:Programming language comparisons]] |
Latest revision as of 03:20, 31 July 2024
Programming languages are used for controlling the behavior of a machine (often a computer). Like natural languages, programming languages follow rules for syntax and semantics.
There are thousands of programming languages[1] and new ones are created every year. Few languages ever become sufficiently popular that they are used by more than a few people, but professional programmers may use dozens of languages in a career.
Most programming languages are not standardized by an international (or national) standard, even widely used ones, such as Perl or Standard ML (despite the name). Notable standardized programming languages include ALGOL, C, C++, JavaScript (under the name ECMAScript), Smalltalk, Prolog, Common Lisp, Scheme (IEEE standard), ISLISP, Ada, Fortran, COBOL, SQL, and XQuery.
General comparison
[edit]The following table compares general and technical information for a selection of commonly used programming languages. See the individual languages' articles for further information.
Language | Original purpose | Imperative | Object-oriented | Functional | Procedural | Generic | Reflective | Other paradigms | Standardized |
---|---|---|---|---|---|---|---|---|---|
1C:Enterprise programming language | Application, RAD, business, general, web, mobile | Yes | No | Yes | Yes | Yes | Yes | Object-based, Prototype-based programming | No |
ActionScript | Application, client-side, web | Yes | Yes | Yes | Yes | No | No | prototype-based | Yes 1999-2003, ActionScript 1.0 with ES3, ActionScript 2.0 with ES3 and partial ES4 draft, ActionScript 3.0 with ES4 draft, ActionScript 3.0 with E4X |
Ada | Application, embedded, realtime, system | Yes | Yes[2] | No | Yes[3] | Yes[4] | No | Concurrent,[5] distributed[6] | Yes 1983, 2005, 2012, ANSI, ISO, GOST 27831-88[7] |
Aldor | Highly domain-specific, symbolic computing | Yes | Yes | Yes | No | No | No | No | |
ALGOL 58 | Application | Yes | No | No | No | No | No | No | |
ALGOL 60 | Application | Yes | No | No | Yes | Yes | No | Yes 1960, IFIP WG 2.1, ISO[8] | |
ALGOL 68 | Application | Yes | No | Yes | Yes | Yes | No | Concurrent | Yes 1968, IFIP WG 2.1, GOST 27974-88,[9] |
Ateji PX | Parallel application | No | Yes | No | No | No | No | pi calculus | No |
APL | Application, data processing | Yes | Yes | Yes | Yes | Yes | Yes | Array-oriented, tacit | Yes 1989, ISO |
Assembly language | General | Yes | No | No | No | No | No | Any, syntax is usually highly specific, related to the target processor | Yes 1985 IEEE 694-1985[10] |
AutoHotkey | GUI automation (macros), highly domain-specific | Yes | Yes [11] |
No | Yes | No | No | No | |
AutoIt | GUI automation (macros), highly domain-specific | Yes | No | No | Yes | No | No | No | |
Ballerina | Integration, agile, server-side, general | Yes | Yes | Yes | Yes | No | No | Concurrent, transactional, statically and strongly typed, diagrammatic–visual | De facto standard via Ballerina Language Specification[12] |
Bash | Shell, scripting | Yes | No | No | Yes | No | No | Optionally POSIX.2[13] | |
BASIC | Application, education | Yes | No | No | Yes | No | No | Yes 1983, ANSI, ISO, ECMA | |
BeanShell | Application, scripting | Yes | Yes | Yes | No | No | Yes | No In progress, JCP[14] | |
BLISS | System | No | No | No | Yes | No | No | No | |
BlitzMax | Application, game | Yes | Yes | No | Yes | No | Yes | No | |
Boo | Application, game scripting | No | Yes | No | No | No | No | No | |
C | Application, system,[15] general purpose, low-level operations | Yes | No | No | Yes | No | No | Yes 1989, ANSI C89, ISO/IEC C90, ISO/IEC C95, ISO/IEC C99, ISO/IEC C11, ISO/IEC C17, ISO/IEC C2x[16] | |
C++ | Application, system | Yes | Yes | Yes | Yes | Yes | No | Yes 1998, ISO/IEC C++98, ISO/IEC C++03, ISO/IEC C++11, ISO/IEC C++14, ISO/IEC C++17, ISO/IEC C++20, ISO/IEC C++23[17] | |
C# | Application, RAD, business, client-side, general, server-side, web, game programming | Yes | Yes | Yes[18] | Yes | Yes | Yes | Structured, concurrent | Yes 2000, ECMA, ISO[19] |
Clarion | General, business, web | Yes | Yes | Yes[20] | No | No | No | Unknown | |
Clean | General | No | No | Yes | No | Yes | No | No | |
Clojure | General | No | No | Yes | No | No | No | Concurrent | No |
CLU | General | Yes | Yes | No | Yes | Yes | No | No | |
COBOL | Application, business | Yes | Yes | No | Yes | No | No | Yes 1968 ANSI X3.23, 1974, 1985; ISO/IEC 1989:1985, 2002, 2014, 2023 | |
Cobra | Application, business, general, web | Yes | Yes | Yes | No | Yes | Yes | No | |
ColdFusion (CFML) | Web | No | Yes | No | Yes | No | No | No | |
Common Lisp | General | Yes | Yes | Yes | Yes | Yes | Yes | Extensible syntax, Array-oriented, syntactic macros, multiple dispatch, concurrent | Yes 1994, ANSI |
COMAL 80 | Education | Yes | No | No | Yes | No | No | No | |
Crystal | General purpose | Yes | Yes[21] | Yes | Yes | Yes[22] | No | Concurrent[23] | No |
Curry | Application | No | No | Yes | No | Yes | No | lazy evaluation, non-determinism | De facto standard via Curry Language Report |
Cython | Application, general, numerical computing | Yes | Yes | Yes | No | No | Yes | Aspect-oriented | No |
D | Application, system | Yes | Yes | Yes | Yes | Yes | Yes | Generative, concurrent | No |
Dart | Application, web, server-side, mobile, IoT | Yes | Yes | Yes | Yes | Yes | No | Structured | Yes ECMA-408 standard |
Delphi, Object Pascal | General purpose | Yes | Yes | Yes | Yes | Yes | Yes | ?
| |
Dylan | Application | No | Yes | Yes | No | No | No | No | |
Eiffel | General, application, business, client-side, server-side, web (EWF) | Yes | Yes | Yes[24][25] | No | Yes | Yes Erl-G | Distributed SCOOP, Void-safe | Yes 2005, ECMA, ISO[26] |
ELAN | Education | Yes | No | No | Yes | No | No | Structured, stepwise refinement | No |
Elixir | Application, distributed | No | No | Yes | No | No | Yes | Concurrent, distributed | No |
Erlang | Application, distributed | No | No | Yes | No | No | Yes | Concurrent, distributed | No |
Euphoria | Application | No | No | No | Yes | No | Yes | No | |
Factor | General | Yes | No | Can be viewed as | No | Yes | Yes | Stack-oriented | No |
FP | No | No | Yes | No | No | No | No | ||
F# | Application | Yes | Yes | Yes | Yes | Yes | Yes | No | |
Forth | General | Yes | No | Yes | Yes | No | Yes | Stack-oriented | Yes 1994, ANSI |
Fortran | Application, numerical computing | Yes | Yes | Yes | Yes | Yes | No | Array-based, vectorized, concurrent, native distributed/shared-memory parallelism | Yes 1966, ANSI 66, ANSI 77, MIL-STD-1753, ISO 90, ISO 95, ISO 2003, ISO/IEC 1539-1:2010 (2008), ISO/IEC JTC1/SC22/WG5 N2145 (2018) |
FreeBASIC | Application, numerical computing | Yes | Yes | No | Yes | Yes | No | No | |
Gambas | Application | Yes | Yes | No | No | No | No | No | |
Game Maker Language | Application, game programming | Yes | Yes | No | No | No | No | No | |
GLBasic | Application, games | Yes | Yes | No | Yes | No | No | Simple object-oriented | No |
Go | Application, web, server-side | Yes | Can be viewed as[27] | No | Yes | Yes | Yes | Concurrent | De facto standard via Go Language Specification |
Gosu | Application, general, scripting, web | Yes | Yes | No | No | Yes | Yes | No | |
GraphTalk | Application | No | Yes | No | No | No | No | Logic | No |
Groovy | Application, general, scripting, web | Yes | Yes | Yes | Yes | Yes | Yes | Meta-programming | In progress, JCP[28] |
Harbour | Application, business, data processing, general, web | Yes | Yes | Yes | Yes | Yes | Yes | Declarative | No |
Haskell | Application | No | No | Yes | No | Yes | No | Lazy evaluation | Yes 2010, Haskell 2010[29] |
Haxe | Application, general, web | Yes | Yes | Yes | No | Yes | Yes | No | |
HyperTalk | Application, RAD, general | Yes | No | No | Yes | No | Yes | Weakly typed | Unknown |
Io | Application, host-driven scripting | Yes | Yes | No | No | No | No | No | |
IPL | General | No | No | Yes | No | No | No | Unknown | |
ISLISP | General | Yes | Yes | Yes | No | Yes | No | Yes 1997, 2007, ISO | |
J | Application, data processing | Yes | Yes | Yes | Yes | Yes | Yes | Array-oriented, function-level, tacit, concurrent | No |
JADE | Application, distributed | Yes | Yes | No | No | No | No | No | |
Java | Application, business, client-side, general, mobile development, server-side, web | Yes | Yes | Yes | Yes | Yes | Yes | Concurrent | De facto standard via Java Language Specification |
JavaScript | Client-side, server-side, web | Yes | Yes | Yes | Yes | No | Yes | prototype-based | Yes 1997-2022, ECMA-262 |
Joy | Research | No | No | Yes | No | No | No | Stack-oriented | No |
jq | "awk for JSON" | No | No | Yes | No | No | No | Tacit, Backtracking, Streaming, PEG | No |
Julia | General, technical computing | Yes | No | Yes | Yes | Yes | Yes | Multiple dispatch, meta, scalar and array-oriented, parallel, concurrent, distributed ("cloud") | No |
K | Data processing, business | No | No | No | No | No | No | Array-oriented, tacit | Unknown |
Kotlin | Application, mobile development, server-side, client-side, web | Yes | Yes | Yes | Yes | Yes | Yes[30] | De facto standard via Kotlin Language Specification | |
Ksh | Shell, scripting | Yes | Yes | No | Yes | No | No | Several variants, custom programmable, dynamic loadable modules | Optionally POSIX.2[13] |
LabVIEW (G) | Application, industrial instrumentation-automation | Yes | Yes | Yes | No | No | No | Dataflow, visual | No |
Lisp | General | No | No | Yes | No | No | No | Unknown | |
LiveCode | Application, RAD, general | Yes | Yes | No | Yes | No | Yes | Weakly typed | No |
Logtalk | Artificial intelligence, application | No | Yes | No | No | No | Yes | Logic | No |
Linden Scripting Language (LSL) | Virtual worlds content scripting and animation | Yes | No | No | Yes | No | No | Scripts exist in in-world objects | De facto reference is the Second Life implementation of LSL.[31] |
Lua | Application, embedded scripting | Yes | Yes[32] | Yes | Yes | No | Yes | Aspect-oriented, prototype-based | No[33] |
Maple | Symbolic computation, numerical computing | Yes | Yes | Yes | Yes | No | No | Distributed | No |
Mathematica | Symbolic language | Yes | Yes | Yes | Yes | Yes | Yes | Logic, distributed | No |
MATLAB | Highly domain-specific, numerical computing | Yes | Yes | No | Yes | No | No | No | |
Modula-2 | Application, system | Yes | No | No | No | Yes | No | Yes 1996, ISO[34] | |
Modula-3 | Application | Yes | Yes | No | No | Yes | No | No | |
MUMPS (M) | General, application, databases | Yes | Approved for next Standard | No | Yes | Partially Thru Indirection and Xecute | Yes | Concurrent, multi-user, NoSQL, transaction processing | Yes 1977 ANSI, 1995, ISO 2020 |
Nim | Application, general, web, scripting, system | Yes | Yes | Yes | Yes | Yes | Yes | Multiple dispatch, concurrent, meta | No |
Oberon | Application, system | Yes | Yes | No | No | No | No | No | |
Object Pascal | Application, general, mobile app, web | Yes | Yes | No | Yes | Yes | Yes | Structured | No |
Objective-C | Application, general | Yes | Yes | No | Yes | No | Yes | Concurrent | No |
OCaml | Application, general | Yes | Yes | Yes | Yes | Yes | No | No | |
Occam | General | Yes | No | No | Yes | No | No | Concurrent, process-oriented | No |
Opa | Web applications | Yes | No | Yes | No | Yes | No | Distributed | No |
OpenLisp | General, Embedded Lisp Engine | Yes | Yes | Yes | No | Yes | No | Optionally ISLISP | |
Oxygene | Application | Yes | Yes | No | No | Yes | No | No | |
Oz-Mozart | Application, distribution, education | Yes | Yes | Yes | No | No | No | Concurrent, logic | No |
Pascal | Application, education | Yes | No | No | Yes | No | No | Yes 1983, ISO[35] | |
Perl | Application, scripting, text processing, Web | Yes | Yes | Yes | Yes | Yes | Yes | No | |
PHP | Server-side, web application, web | Yes | Yes[36] | Yes[37] | Yes | No | Yes | De facto standard via language specification and Requests for Comments (RFCs) | |
PL/I | Application | Yes | Yes | No | Yes | No | No | Yes 1969, ECMA-50 (1976) | |
Plus | Application, system development | Yes | No | No | Yes | No | No | No | |
PostScript | Graphics, page description | Yes | No | No | Yes | No | No | Concatenative, stack-oriented | De facto standard via the PostScript Reference Manual[38] |
PowerShell | Administration, application, general, scripting | Yes | Yes | Yes | Yes | No | Yes | Pipeline | No |
Prolog | Application, artificial intelligence | No | No | Yes | Yes | No | Yes | Logic, declarative | Yes 1995, ISO/IEC 13211-1:1995, TC1 2007, TC2 2012, TC3 2017 |
PureBasic | Application | Yes | No | No | Yes | No | No | No | |
Python | Application, general, web, scripting, artificial intelligence, scientific computing | Yes | Yes | Yes | Yes | Yes | Yes | Aspect-oriented | De facto standard via Python Enhancement Proposals (PEPs) |
R | Application, statistics | Yes | Yes | Yes | Yes | No | Yes | No | |
Racket | Education, general, scripting | Yes | Yes | Yes | Yes | No | Yes | Modular, logic, meta | No |
Raku | Scripting, text processing, glue | Yes | Yes | Yes | Yes | Yes | Yes | Aspect-oriented, array, lazy evaluation, multiple dispatch, metaprogramming | No |
REALbasic | Application | No | No | No | Yes | No | No | Unknown | |
Rebol | Distributed | Yes | Yes | Yes | Yes | No | Yes | Dialected | No |
REXX | Scripting | Yes | Yes (NetRexx and Object REXX dialects) | No | Yes | No | No | Yes 1996 (ANSI X3.274-1996) | |
RPG | Application, system | Yes | No | No | Yes | No | No | No | |
Ring | Application | Yes | Yes | Yes | Yes | Yes | Yes | metaprogramming, declarative, natural-language | No |
Ruby | Application, scripting, web | Yes | Yes | Yes | No | No | Yes | Aspect-oriented | Yes 2011(JIS X 3017), 2012(ISO/IEC 30170) |
Rust | Application, server-side, system, web | Yes | Yes[39] | Yes | Yes | Yes | No[40] | Concurrent | No |
S | Application, statistics | Yes | Yes | Yes | Yes | No | No | No | |
S-Lang | Application, numerical, scripting | Yes | No | No | Yes | No | No | No | |
Scala | Application, general, parallel, distributed, web | Yes | Yes | Yes | No | Yes | Yes | Data-oriented programming, metaprogramming | De facto standard via Scala Language Specification (SLS) |
Scheme | Education, general | Yes | No | Yes | No | No | No | meta, extensible-syntax | De facto 1975-2013, R0RS, R1RS, R2RS, R3RS, R4RS, R5RS, R6RS, R7RS Small Edition[41][42] |
Seed7 | Application, general, scripting, web | Yes | Yes | No | No | Yes | Yes | Multi-paradigm, extensible, structured | No |
Simula | Education, general | Yes | Yes | No | No | No | No | discrete event simulation, multi-threaded (quasi-parallel) program execution | Yes 1968 |
Small Basic | Application, education, games | Yes | No | No | No | No | No | Component-oriented | No |
Smalltalk | Application, general, business, artificial intelligence, education, web | Yes | Yes | Yes | Yes | No | Yes | Concurrent, declarative | Yes 1998, ANSI |
SNOBOL | Text processing | No | No | No | No | No | No | Unknown | |
Standard ML | Application | Yes | No | Yes | No | Yes | No | Yes 1997, SML '97[43] | |
Swift | Application, general | Yes | Yes | Yes | Yes | Yes | Yes | Concurrent, declarative, protocol-oriented | No |
Tcl | Application, scripting, web | Yes | Yes | Yes | Yes | No | Yes | No | |
V (Vlang) | Application, general, system, game, web, server-side | Yes | Can be viewed as | Can be viewed as | Yes | Yes | Yes | Concurrent | No |
Visual Basic | Application, RAD, education, business, general, (Includes VBA), office automation | Yes | Yes | No | Yes | Yes | No | Component-oriented | No |
Visual Basic .NET | Application, RAD, education, web, business, general | Yes | Yes | Yes | Yes | Yes | Yes | Structured, concurrent | No |
Visual FoxPro | Application | Yes | Yes | No | Yes | No | No | Data-centric, logic | No |
Visual Prolog | Application | Yes | Yes | Yes | No | No | No | Declarative, logic | No |
Wolfram Language | Symbolic language | Yes | Yes | Yes | Yes | Yes | Yes | Logic, distributed | No |
XL | Yes | Yes | No | No | No | No | concept programming | No | |
Xojo | Application, RAD, general, web | Yes | Yes | No | Yes | No | Yes | No | |
XPath/XQuery | Databases, data processing, scripting | No | No | Yes | No | No | No | Tree-oriented | Yes 1999 W3C XPath 1, 2010 W3C XQuery 1, 2014 W3C XPath/XQuery 3.0 |
Zeek | Domain-specific, application | Yes | No | No | No | No | No | No | |
Zig | Application, general, system | Yes | No | Yes | Yes | Yes | Yes | Concurrent | No |
Zsh | Shell, scripting | Yes | No | No | Yes | No | No | Loadable modules | Optionally POSIX.2[13] |
Type systems
[edit]Failsafe I/O and system calls
[edit]Most programming languages will print an error message or throw an exception if an input/output operation or other system call (e.g., chmod, kill) fails, unless the programmer has explicitly arranged for different handling of these events. Thus, these languages fail safely in this regard.
Some (mostly older) languages require that programmers explicitly add checks for these kinds of errors. Psychologically, different cognitive biases (e.g., optimism bias) may affect novices and experts alike and lead them to skip these checks. This can lead to erroneous behavior.
Failsafe I/O is a feature of 1C:Enterprise, Ada (exceptions), ALGOL (exceptions or return value depending on function), Ballerina, C#, Common Lisp ("conditions and restarts" system), Curry, D (throwing on failure),[44] Erlang, Fortran, Go (unless result explicitly ignored), Gosu, Harbour, Haskell, ISLISP, Java, Julia, Kotlin, LabVIEW, Mathematica, Objective-C (exceptions), OCaml (exceptions), OpenLisp, PHP, Python, Raku, Rebol, Rexx (with optional signal on... trap handling), Ring, Ruby, Rust (unless result explicitly ignored), Scala,[45] Smalltalk, Standard ML [citation needed], Swift ≥ 2.0 (exceptions), Tcl, Visual Basic, Visual Basic .NET, Visual Prolog, Wolfram Language, Xojo, XPath/XQuery (exceptions), and Zeek.
No Failsafe I/O: AutoHotkey (global ErrorLevel must be explicitly checked), C,[46] COBOL, Eiffel (it actually depends on the library and it is not defined by the language), GLBasic (will generally cause program to crash), RPG, Lua (some functions do not warn or throw exceptions), and Perl.[47]
Some I/O checking is built in C++ (STL iostreams throw on failure but C APIs like stdio or POSIX do not)[46] and Object Pascal, in Bash[48] it is optional.
Expressiveness
[edit]Language | Statements ratio[49] | Lines ratio[50] |
---|---|---|
C | 1 | 1 |
C++ | 2.5 | 1 |
Fortran | 2 | 0.8 |
Java | 2.5 | 1.5 |
Perl | 6 | 6 |
Smalltalk | 6 | 6.25 |
Python | 6 | 6.5 |
The literature on programming languages contains an abundance of informal claims about their relative expressive power, but there is no framework for formalizing such statements nor for deriving interesting consequences.[51] This table provides two measures of expressiveness from two different sources. An additional measure of expressiveness, in GZip bytes, can be found on the Computer Language Benchmarks Game.[52]
Benchmarks
[edit]Benchmarks are designed to mimic a particular type of workload on a component or system. The computer programs used for compiling some of the benchmark data in this section may not have been fully optimized, and the relevance of the data is disputed. The most accurate benchmarks are those that are customized to your particular situation. Other people's benchmark data may have some value to others, but proper interpretation brings many challenges. The Computer Language Benchmarks Game site warns against over-generalizing from benchmark data, but contains a large number of micro-benchmarks of reader-contributed code snippets, with an interface that generates various charts and tables comparing specific programming languages and types of tests.[55]
Timeline of specific language comparisons
[edit]- 1974 – Comparative Notes on Algol 68 and PL/I[56] – S. H. Valentine – November 1974
- 1976 – Evaluation of ALGOL 68, JOVIAL J3B, Pascal, Simula 67, and TACPOL Versus TINMAN – Requirements for a Common High Order Programming Language.
- 1977 – A comparison of PASCAL and ALGOL 68[57] – Andrew S. Tanenbaum – June 1977.
- 1993 – Five Little Languages and How They Grew – BLISS, Pascal, ALGOL 68, BCPL & C – Dennis M. Ritchie – April 1993.
- 2009 – On Go – oh, go on – How well will Google's Go stand up against Brand X programming language? – David Given – November 2009
See also
[edit]To display all pages, subcategories and images click on the "►": |
---|
- Comparison of programming languages (basic instructions)
- Comparison of programming languages (syntax)
- Comparison of integrated development environments
- Comparison of multi-paradigm programming languages
- TIOBE index
References
[edit]- ^ As of May 2006 Diarmuid Pigott's Encyclopedia of Computer Languages Archived 2011-02-20 at the Wayback Machine hosted at Murdoch University, Australia lists 8512 computer languages.
- ^ Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3, 3.9 Tagged Types and Type Extensions
- ^ Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3, Section 6: Subprograms
- ^ Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3, Section 12: Generic Units
- ^ Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3, Section 9: Tasks and Synchronization
- ^ Ada Reference Manual, ISO/IEC 8652:2005(E) Ed. 3 Annex E: Distributed Systems
- ^ "Vak.ru" (PDF). Archived from the original (PDF) on 2017-03-30. Retrieved 2008-08-09.
- ^ ISO 1538:1984
- ^ "Vak.ru" (PDF). Archived from the original (PDF) on 2017-03-24. Retrieved 2008-08-09.
- ^ IEEE 694-1985
- ^ Objects - Definition & Usage
- ^ "Ballerina Language Specification" (PDF). WSO2. 2018-05-01. Archived from the original (PDF) on 2018-05-04. Retrieved 2018-05-03.
- ^ a b c POSIX.2, Shell and Utilities, Command Interpreter (IEEE Std 1003.2-1992.)
- ^ JSR 274
- ^ bell-labs.com
- ^ ANSI C89, ISO/IEC 9899:1990, 1999, 2011, 2018
- ^ ISO/IEC 14882:1998, 2003, 2011, 2014, 2017, 2020
- ^ Codeproject.com: Functional Programming in C# 3.0 using Lambda Expression
- ^ ECMA-334; ISO/IEC 23270:2006
- ^ Softvelocity.com
- ^ "Crystal". GitHub. 2 November 2021.
- ^ "Crystal Generics". crystal-lang.org. 13 April 2024.
- ^ "Concurrency - Crystal". crystal-lang.org. Retrieved 2024-04-02.
- ^ Basic Eiffel language mechanisms
- ^ Closure (computer programming)
- ^ ECMA-367; ISO/IEC 25436:2006
- ^ The Go Programming Language (FAQ)
- ^ JSR 241
- ^ "The Haskell 2010 Language Report". Retrieved 2011-12-07. Most Haskell implementations extend the Haskell 2010 standard.
- ^ "M8 is out!". 2 July 2014.
As a first peek into the future reflective capabilities of Kotlin, you can now access properties as first-class objects in Kotlin
- ^ Halcyon (Inworldz) and Open Sims propose compatible implementations with additional functions.
- ^ Lua does not have explicit "object" type (more general type of "table" is used for object definition), but does have explicit syntax for object method calling
- ^ Version releases are accompanied with a definitive Lua Reference Manual showing full syntax and semantics; a reference implementation, and a test suite. These are used to generate other Lua VM implementations and compilers such as Kahlua and LLVM-Lua.
- ^ ISO/IEC 10514-1:1996
- ^ ISO 7185
- ^ PHP Manual, Chapter 19. Classes and Objects (PHP 5),
- ^ PHP Manual, Chapter 17. Functions
- ^ "PostScript Language Reference Manual" (PDF). Archived from the original (PDF) on 2017-02-18. Retrieved 2017-02-18.
- ^ Is Rust an Object-Oriented Programming Language?
- ^ Klabnik, Steve; Nichols, Carol. "Macros". The Rust Programming Language.
- ^ R3RS, R4RS, R5RS, R6RS, R7RS Small Edition
- ^ R0RS, R1RS, R2RS
- ^ SMLNJ.org
- ^ "STD.stdio - D Programming Language".
- ^ Scala runs on the Java Virtual Machine from which it inherits the runtime exception handling.
- ^ a b gcc can warn on unchecked errno. Newer versions of Visual Studio usually throw exceptions on failed I/O when using stdio.
- ^ Considerable error checking can be enabled optionally, but by default Perl is not failsafe.
- ^
set -e
enables termination if any unchecked exit status is nonzero. - ^ Data from McConnell, Steve (30 November 2009). Code Complete. Microsoft Press. p. 100. ISBN 9780735636972. The Statements ratio column "shows typical ratios of source statements in several high-level languages to the equivalent code in C. A higher ratio means that each line of code in the language listed accomplishes more than does each line of code in C.
- ^ The ratio of line count tests won by each language to the number won by C when using the Compare to feature at McLoone, Jon (November 14, 2012). "Code Length Measured in 14 Languages". Archived from the original on 2012-11-19. C gcc was used for C, C++ g++ was used for C++, FORTRAN G95 was used for FORTRAN, Java JDK Server was used for Java, and Smalltalk GST was used for Smalltalk.
- ^ Felleisen, Matthias. On the Expressive Power of Programming Languages. ESOP '90 3rd European Symposium on Programming. CiteSeerX 10.1.1.51.4656.
- ^ "How programs are measured". Computer Language Benchmarks Game. Retrieved 2018-05-29.
- ^ Mandelbrot, Benoit B. (1982). The fractal geometry of nature (Revised ed.). San Francisco. ISBN 0-7167-1186-9. OCLC 7876824.
{{cite book}}
: CS1 maint: location missing publisher (link) - ^ "Mandelbrot". Computer Language Benchmarks Game. Retrieved 2021-07-09.
- ^ "The Ultimate Benchmark". The Computer Language Benchmarks Game. Retrieved 2018-05-29.
- ^ Valentine, S. H. (November 1974). "Comparative Notes on Algol 68 and PL/I". The Computer Journal. 17 (4): 325–331. doi:10.1093/comjnl/17.4.325.
- ^ "Vrije Universiteit Amsterdam" (PDF).
Further reading
[edit]- Cezzar, Ruknet (1995). A Guide to Programming Languages: Overview and Comparison. Artech House. ISBN 978-0-89006-812-0.