Language Comparison Table
| Language | Paradigm(s) | Standardized | Type strength | Type safety | Expression of types | Type compatibility | Type checking | Parameter Passing Methods Available | Garbage collection | Intended use | Design goals |
|---|---|---|---|---|---|---|---|---|---|---|---|
| ACL2 | functional | Yes | strong | unsafe | implicit | dynamic | immutable reference | Yes | Theorem proving | Be logically sound, mimic Common Lisp | |
| ActionScript | imperative, object-oriented,distributed | Yes, ECMA | strong | safe | static | Yes | Web design | ||||
| Ada | concurrent, distributed, generic, imperative, object-oriented | Yes | strong | safe | explicit | nominative | static | by value, by reference (compiler chosen if not determined by the data type) | GC is allowed, but not mandated | Embedded, real-time, mission-critical, long-lived, and large scale systems | Reliability and maintenance, Programming as a human activity, Efficiency Language Reference Manual |
| ALGOL 68 | concurrent, imperative | Yes, GOST 27974-88 | strong | safe | explicit | structural | static or dynamic (programmer chosen) | by value or by reference (programmer chosen) | Yes | Application | Completeness and clarity of design, Orthogonal design, Security, Efficiency (Static mode checking, Mode-independent parsing, Independent compilation, Loop optimization, Representations in minimal & larger character sets) |
| ALGOL W | imperative | No | strong | safe | explicit | nominative | static or dynamic (programmer chosen) | by value, by reference or by name (programmer chosen) | Yes | Application, Education | |
| AmbientTalk | concurrent | strong | safe | explicit | duck | dynamic | by value | Mobile ad hoc networks | |||
| Arturo | generic, imperative, functional, reflective, stack-based | No, see official documentation | strong | implicit | dynamic | by value, by reference (literals) | Yes | General, Scripting, DSLs, Templating, Portable apps, GUI applications | Simplicity, Expressiveness, Portability | ||
| AutoHotkey | imperative, classless | No | untyped | by value or by reference | No | End User Programming | simplicity, speed, stability | ||||
| AutoIt | imperative | by value or by reference | General, scripting, GUI and tasks automation | Simplicity | |||||||
| BASIC | procedural | Yes, ANSI, ISO | varies by dialect | varies by dialect | Education | Simplicity | |||||
| Blade | imperative, object-oriented, functional | No | strong | safe | implicit | nominative | dynamic | by value, by reference (through pointers) | Yes | Scripting, Application | Simple, Lightweight, CLI, Web, Desktop, Mobile |
| C | imperative | Yes, ANSI C89, ISO C90/C99 | weak | unsafe | explicit | nominative | static | by value, by reference (through pointers) | Optional through external tools | System, Embedded | Low level access, Minimal constraint |
| C# | imperative, object-oriented, generic, reflective, functional, event-driven | Yes, ECMA, ISO | strong | safe (unsafe allowed) | implicit | nominative | static, dynamic (for interop) | by value, by reference (through managed pointers [explicitly in, out, or in-out]) | Yes | Application | Rapid application development |
| C++ | imperative, object-oriented, generic | Yes, ISO C++98/C++11 | strong | safe (unsafe allowed) | explicit, partially implicit | nominative, structural | static, dynamic | by value, by reference (through reference types) | Optional through external tools | Application, System | Abstraction, Efficiency, Compatibility |
| Chapel | concurrent, generic, object-oriented, imperative, distributed, reflective | No, still under development, a preliminary language specification exists | strong | safe | explicit, partially inferred | nominative | static | by value, by reference | No | High Performance Computing | Programmer productivity (compared to C/Fortran), performance |
| Clean | functional, generic | No | strong | implicit | static | Yes | General | Correctness, Modularity | |||
| Clojure | functional, concurrent | strong | safe | dynamic, static | Yes | ||||||
| COBOL | imperative, object-oriented | Yes, ANSI 68, 74, 85 (and subsequent revisions); ECMA; ISO 1989:2014 (and previous version in 1978, 1985, 2002) | strong | safe | explicit | static | by value, by reference | No | Business and Financial Applications | Readability | |
| ColdFusion | procedural, object-oriented | No | weak | implicit | dynamic | Web Development | Rapid Application Development, Ease of use | ||||
| Common Lisp | imperative, functional, object-oriented | Yes | strong | safe | dynamic, static | Yes | General | Standardize Lisp | |||
| D | imperative, object-oriented, generic | No | strong | safe | explicit, optional inferred | nominative, structural | static, dynamic | by value, by reference (through reference types) | Yes | Application, System | Compilability, Correctness, Efficiency |
| Dao | object-oriented | strong | safe, unsafe allowed | implicit, explicit | static, dynamic | Yes | |||||
| Dyalect | imperative, object-oriented, functional | No | strong | safe | implicit | duck | dynamic | by reference | Yes | Application | Portable dynamic scripting language with consistent design and modern syntax |
| Dylan | imperative, object-oriented, functional, procedural | strong | safe | static, dynamic | Yes | ||||||
| E | imperative, object-oriented, object-capability, communicating event loops | No
, still in development |
strong (runtime) | safe | optional explicit | duck | dynamic | by value | Yes | Secure collaboration, distributed systems, running untrusted applications, high-level "scripting" | Familiarity to C/Java/JS users; less error-prone concurrency & security |
| eC | imperative, object-oriented, generic, reflective | No | weak | unsafe | explicit, partially implicit | nominative, complex conversions system | static, dynamic | according to data type, or explicitly by value, by reference | Reference counting | Applications, GUIs, System, Games | Elegance, Performance, Simplicity, Lightness, 99.9% C compatibility |
| Ecstasy | object-oriented, generic, reflective, functional, imperative | No | strong | safe | explicit, optionally inferred | nominative; duck for interface types | static; dynamic for generic edge conditions | by value; by reference | Yes | Application | Predictable, Secure, Composable |
| Eiffel | imperative, object-oriented, generic | Yes | strong | safe | nominative | static | Yes | Application | Correctness, Efficiency, Design by contract | ||
| Ela | functional | No | strong | safe | implicit | duck | dynamic | by reference | Yes | Application | |
| Elm | functional, functional reactive programming, declarative, pattern matching | No | strong | safe | inferred, optional explicit annotations | static | immutable data structures, syntactically by value, time-varying with Signals | Yes | Web Development, GUIs, Applications, Games | Simple, Modular, Safe, Reactive | |
| Elena | object-oriented | strong | safe | implicit | dynamic | Yes | |||||
| Erlang | functional, concurrent, distributed, declarative - pattern matching, imperative | No | strong | safe | implicit | dynamic | immutable data structures, syntactically by value but safe sharing of compound data types | Yes | Telecom and mission critical distributed applications | Fault tolerance, Reliability - Nonstop Running, Hot Code Change, Safety, Concurrency, Distribution, Scalability | |
| ERRE | imperative, procedural | No | weak | unsafe | explicit | static and dynamic | by value | Yes | Education | Readability, Modularity | |
| Factor | stack-oriented | No | safe | implicit | duck | dynamic | by reference | Yes | x | ||
| Forth | imperative, stack-oriented | Yes, ANSI, ISO/IEC 15145:1997 | none | n/a | n/a | n/a | n/a | No | Applications, High reliability, Embedded systems, Booting new hardware. | Compact implementations, Low level access, Interactive programming, CPU agnostic Assembler Alternative, ultra-small memory systems. | |
| Fortran | imperative, procedural, object-oriented, (partially) generic, concurrent | Yes | strong | safe | explicit, partially implicit | nominative | static, dynamic | by reference, or explicitly by value | No | Scientific and numeric applications | Runtime efficiency, Simple syntax |
| FutureBasic | procedural | No | strong | nominative | static | by value, by reference (through pointers) | Yes | Educational, Scientific, Prototyping, Commercial Level Applications | Mac Freeware, Readability, Simplicity, Efficiency, C/Objective-C Compatibility, Objective-C Alternative, Builds Xcode Projects | ||
| Gambas | object-oriented | No | strong | safe | explicit | dynamic | by value, by reference | Application, Scripting | Rapid application development, Visual Basic alternative | ||
| Go | concurrent, classless | No
, language specification available |
strong | safe | explicit, optionally inferred | nominative; structural for interface types | static | by value | Yes | ||
| Gosu | imperative, object-oriented, generic, functional | Yes | strong | safe | explicit, optionally inferred | nominative and structural | static | by value | Yes | Application | Open type system, optional dynamic loading |
| Groovy | imperative, object-oriented, aspect-oriented | No | strong | safe | implicit | nominative | dynamic | Yes | Application | JVM compatibility | |
| Haskell | functional, generic, lazy evaluation | Yes, Haskell 2010 Report, Haskell 98 Report | strong | safe | inferred, optional explicit annotations | polymorphic structural | static | Yes | Application, Research | lazy evaluation, Teaching and research, completely formally described Report Preface | |
| Huginn | imperative, object-oriented, functional | No, language reference included with each version's documentation | strong | safe | implicit | dynamic | by reference | Reference counting | Education, Application, Scripting, Interactive system shell | Consistency, Simplicity, Readability, Expressiveness, Modularity | |
| icon | procedural, structured, goal directed, string scanning, co-expressions | No | strong | Safe | implicit | nominative | dynamic | by value and safe reference depending if the type is mutable or immutable | Yes | Text analysis, text editing, document formatting, artificial intelligence, expert systems, rapid prototyping, symbolic mathematics, text generation, and data laundry | Facilitates ease of programming, short concise programs, automatic storage allocation and management, provide a rich base of basic data types and structures, and platform independence. Also see Unicon for the unified extended dialect of Icon. |
| Insitux | functional, imperative | No | strong | safe | implicit | dynamic | by value | Yes | Host-driven scripting | Host-extensibility; provide "safe" modding e.g. timeout infinite loops, memory limits; concise code | |
| Io | object-oriented, classless, prototype | No | strong | dynamic | Yes | ||||||
| J | array programming, function-level programming, tacit | No | strong | safe | inferred | structural | dynamic | by value, by name, by address for memory mapped files (and, indirectly, for foreign languages) | Yes | Data processing, expressing concepts algorithms and architectures | Describe computers mathematically and concisely |
| Java | imperative, object-oriented, generic, reflective | Yes, Java SE Specifications | strong | safe | explicit | nominative | static | by value | Yes | Application | Write once run anywhere |
| JavaScript | imperative, object-oriented, classless, functional, reflective | Yes, ECMAScript standard | weak | implicit | dynamic | by value | Yes | Client side web scripting | |||
| Joy | functional, stack-oriented | No | strong | safe | dynamic | functional research | concatenative | ||||
| jq | functional, tacit (point-free), dataflow | No, but a de facto standard exists in the agreement between the C and Go-based versions | weak | safe | implicit | n.a. | dynamic | by value, with limited support for closures | Yes | Processing streams of JSON documents or strings; gojq also supports YAML | Turing-completeness; ease of use and economy of expression within functional/dataflow programming frameworks |
| Kabap | imperative, dynamic, extensible | Yes | weak | unsafe | implicit | duck | dynamic | by value | User scripting, general | Safe sandboxed, easy to learn, easier to implement. Use to avoid eval() & reflection | |
| Keg | imperative, concatenative | No | untyped | unsafe | implicit | nominative | dynamic | by reference | No | Code Golf, general | Be simple, readable, and concise |
| Kotlin | imperative, object-oriented, | No | strong | safe | explicit, optionally inferred | nominative | static, dynamic (JS only) | by value (read-only) | Yes | Application | Pragmatic language for modern multi-platform applications with compilers for JVM, JS and Native code |
| LDPL | imperative | No | strong | safe | explicit | static | No | Portable applications, readable source codes, teaching | Readability | ||
| LFE | functional, concurrent, distributed, declarative - pattern matching, imperative | No | strong | safe | implicit | dynamic | immutable data structures, syntactically by value but safe sharing of compound data types | Yes | Telecom and distributed applications | Fault tolerance, Reliability - Nonstop Running, Hot Code Change, Safety, Concurrency, Distribution, Scalability | |
| Lisp | functional, reflective; others vary by dialect | No | strong | dynamic | Yes | General | Simple notation for Lambda calculus, Homoiconicity | ||||
| Logo | procedural, functional | No | strong | safe | implicit | structural | dynamic | Yes | Education | Simple syntax, Turtle graphics, Interactive programming | |
| Lua | procedural, imperative, classless, reflective | No | strong | safe | implicit | dynamic | Yes | Host-driven Scripting | Small, embedded, configuration. | ||
| Lucid | dataflow, functional | No | strong | safe | dynamic | stream processing | dataflow | ||||
| Luck | imperative, functional | No | weak | unsafe | explicit, partially inferred | nominative | static | by value or by reference | Yes | systems programming | fast, C compatible, high-level language |
| Mathematica | functional, procedural | No | strong | dynamic | Yes | Numeric and symbolic computation, visualization | |||||
| MATLAB | procedural, imperative, array programming | No, however the language is also implemented in Octave and FreeMat | strong | unsafe | dynamic | by value | Yes | Numeric computation and visualization | At the beginning designed as interpreter for easy use of fortran libraries, nowadays high performance numerical analysis and visualization | ||
| MAXScript | imperative, object-oriented, procedural | No | strong | safe | implicit | dynamic | by value, by reference | 3D Art Tools, Scripting | Simplicity, Accessibilty | ||
| Modula-3 | imperative, object-oriented, procedural, generic | No | strong | safe (unsafe allowed) | explicit | structural | static | by value, by reference | Yes | Application, Systems | Simple, Object oriented |
| MUMPS | procedural | Yes, ISO/IEC 11756:1999 | untyped | not applicable | by value, by reference | Yes | Built-in Persistent Storage | ||||
| Nial | functional, array programming | No | strong | dynamic | Data processing | ||||||
| Nim | procedural, functional, generic | No | strong | safe | explicit | nominative, structural | static | by value, by reference (through reference types) | Yes | General, Application, Systems, Games, Scripting, Web | Efficient, Expressive, Elegant in that order. |
| Oberon-2 | procedural, imperative, object-oriented, classless | No | strong | safe | explicit | structural | static | by value, by reference | Yes | Teaching, System | Simplicity |
| Objeck | object-oriented,functional | No | strong | safe | explicit | nominative | static | by value | Yes | General, Education | Minimalist, Cross-Platform, Modular |
| Object Pascal (Delphi) | imperative, object-oriented, generic | No | strong | safe (unsafe allowed) | explicit | nominative | static, dynamic | by reference, by value | some types | Application, System | Readability, Rapid application development, Modularity |
| Objective-C | imperative, object-oriented, reflective, generic (as of Xcode 7) | No | weak | explicit | static | by value | Yes (as of 2.0) | Application | Smalltalk like, Component based code reuse, C/C++ compatibility | ||
| OCaml | object-oriented, functional, imperative, generic | No, the manual includes language specification | strong | safe | inferred, optional explicit annotations | polymorphic structural | static | by value | Yes | Application | Efficiency, Robustness, Correctness |
| Oz | logic programming, functional, imperative, object-oriented, concurrent | No | strong | safe | implicit | structural | dynamic | by reference (though often immutable) | Yes | Application, Education, Distribution | |
| PARI/GP | imperative, procedural | No | weak | unsafe | implicit | nominal | dynamic | by value, by reference | Yes | Mathematics, especially number theory | |
| Pascal | imperative, procedural | ISO 7185:1990 and ISO 10206:1991 | strong | safe | explicit | static (some dialects also dynamic) | by reference, by value | No | General, Application, Education, System | Readability, Discipline, Modularity | |
| Perl | imperative, procedural, reflective, functional, object-oriented, generic | No | weak | implicit | dynamic, static | by reference | Reference counting | Text processing, Scripting | Terseness, Expressiveness | ||
| Phix | imperative, procedural, object-oriented | No | strong | safe | explicit, partially implicit | duck | dynamic, static | copy on write, immutable reference, multiple returns | Reference counting or JavaScript compatible | Application, Educational, General, High-level scripting, Text processing | Simplicity, Readability, Ease of use |
| PHP | imperative, object-oriented, reflective | No | weak | dynamic | by value, by reference | Yes | Web Application, CLI | Robustness and Simplicity | |||
| Pike | imperative, procedural, functional, object-oriented, reflective, event-driven | No | strong | safe | explicit | structural | dynamic, static | by value, by reference | Yes | Application, scripting | optimized execution, efficient networking |
| Pop11 | imperative, object-oriented, functional | No | strong | safe | implicit | dynamic | Yes | Application, Education | |||
| Prolog | logic programming | Yes, ISO | strong | dynamic | Yes | Problem solving, Artificial intelligence | declarative | ||||
| Pure | dynamic, functional | strong | structural | dynamic | Yes | ||||||
| Python | imperative, object-oriented, functional, aspect-oriented, reflective | No, language reference included with each version's documentation | strong | safe | implicit | dynamic | by value (Call by object reference) | Yes | Application, Education, Scripting | Simplicity, Readability, Expressiveness, Modularity | |
| R | functional, imperative, reflective, array | No | strong | safe | implicit | Duck, structural | dynamic | value by need, by name (programmer chosen) | Yes | Statistics, Numerical computation, Visualization, Education | Expressiveness, interactive manipulation and analysis of datasets |
| Ra | object-oriented | No | dynamic or static | safe | implicit or explicit | dynamic or static | Yes | General | Program in native language, clean and clear syntax, extensive standard library, convenience | ||
| Racket | functional, imperative, object-oriented, reflective | No | strong | safe | implicit or explicit (see Typed Racket) | dynamic or static | by value | Yes | General | Extensibility, Simplicity, Modularity | |
| RapidQ | imperative, component-oriented programming, event-driven | No | strong (none for Variant type) | safe | static | by reference, by value | Application | Rapid application development, Simplicity, BASIC compatibility | |||
| Raku (formerly Perl 6) | imperative, procedural, reflective, functional, object-oriented, generic, lazy evaluation, multiple dispatch, metaprogramming | No. The Repository Of All Spec Tests (aka 'roast') defines the language | strong | safe, unsafe | optional explicit | nominal (duck and structural available via constraints, patterns, generics, and gradual typing) | dynamic, static | by value, by reference | Yes | Application, text processing, scripting | Expressiveness, generality |
| REXX (Classic REXX)
|
dynamic, procedural, functional | Yes. There is a ANSI standard (X3.274-1996), but some REXX implementations don't adhere to it. |
strong | safe | inferred | nominal | dynamic (but only when both comparands are numeric and non─strict comparisons are used) | by value | garbage collection is allowed (and in most cases, automatic), but not mandated | general, application, algorithms, calculations with extended precision (big numbers support), scripting, host/sub─system scripting/interfacing, data/text processing, programming as a human activity | designed to make programming easier; to foster high quality programs by making writing them as simple and enjoyable as possible; designing each part of the language for people to use is more important than providing easy implementation; follows the principle of least astonishment (POLA). |
| Ruby | imperative, object-oriented, functional, reflective | Yes, JIS X 3017 (2011), ISO/IEC 30170 (2012) | strong | implicit | dynamic | by value (Call by object reference) | Yes | Application, Scripting | Expressiveness, Readability | ||
| Rust | concurrent, functional, imperative, structured, classless, generic | No | strong | safe | explicit, optionally inferred | nominal | static | by value, by reference | resource acquisition is initialization (RAII), optional reference counting | Application, System | Highly concurrent and highly safe systems |
| Scala | object-oriented, functional, generic | Yes, The Scala Language Specification Version 2.9 | strong | safe | partially implicit | nominative, structural | static | by value, by name | Yes | General, Education, Parallel computing, DSL and scripting. | Concise, Type-safe, Integrate OO and functional paradigms, Scalable and Elegance. Platform independent |
| Scheme | functional | Yes, R5RS, R6RS | strong | safe | implicit | dynamic (latent) | by value | Yes | General, Education | Minimalistic, Lexical Scoping | |
| Seed7 | extensible, object-oriented, imperative, structured, generic, reflective | No | strong | safe | explicit | nominative | static | by value, by reference, by name | Yes (no garbage collection process that stops the world) | General, Application, System | Extensibility, Portability, Reliability, Efficiency, Elegance |
| Sidef | object-oriented, imperative, reflective, dynamic, functional | No | weak | unsafe | optional explicit | duck | dynamic | by value (Call by object reference), by reference | Reference counting | Application, Scripting, PL Research, Education | Expressiveness, Elegance, Readability |
| SkookumScript | concurrent, object-oriented, functional, imperative, generic | No, online syntax includes EBNF language specification | strong | safe | inferred, optional explicit annotations | nominal | static | by reference | Reference counting | Embedded gameplay, AI, automation, scripting | Game concepts, Interactivity, Live workflow, Efficiency, Embedded |
| Slate | object-oriented, imperative, functional, reflective, prototype, multi-dispatch | No | strong | safe | implicit, optional | structural (aka duck) | dynamic | by reference | Yes | Application, Embedded, Scripting | Uniformity, Pure object-oriented, expressiveness, readability |
| Smalltalk | object-oriented, concurrent, event-driven, imperative, declarative | Yes, ANSI | strong | safe | implicit | protocol (aka duck) | dynamic | by value (Call by object reference) | Yes | Application, Education | Uniformity, Pure object oriented |
| SPARK | concurrent, imperative, object-oriented | No, but Language Reference Manual available. | strong | safe | explicit | nominative | static | by value, by reference | Allowed | High integrity applications | Logically sound, simple formal definition, expressive power, security, applications verifiable and have bounded space and time. |
| Standard ML | functional, imperative, generic | Yes, SML '97 | strong | safe | inferred, optional explicit annotations | polymorphic structural | static | by value | Yes | ||
| Swift | imperative, object-oriented, generic | No | strong | inferred, optional explicit annotations | nominative | static | by value | Reference counting | Application | Compatibility with Objective-C runtime | |
| Tcl | imperative, procedural, event-driven, object-oriented (native from Tcl 8.6 or via extensions before that) | No | weak | safe | implicit | duck | dynamic | by value (also by name and by reference through passing of variable names and upvar command)
|
Only of unnamed entities, e.g., values | Embedded, Application, Scripting | Extend, Embed and Integrate |
| TMG | declarative, data-driven, functional, unstructured | No | weak | safe | implicit | by reference | Compiler-compiler | Creating compilers or translators (particularly, from a programming language to assembly) | |||
| Transd | imperative, object-oriented, functional | No | strong | safe | explicit | nominative | static | by reference | Yes | Embedded, Application, Scripting, Education | Simplicity; compact implementation. |
| Trith | functional, stack-oriented, concatenative | No | strong | safe | implicit | duck | dynamic | by value | Yes | Embedded, Application, Scripting, Education | Simplicity, Expressiveness, Terseness, Linked Data |
| Unicon | procedural, structured, goal directed, string scanning, co-expressions, object-oriented | No | strong | Safe | implicit | nominative | dynamic | by value and safe reference depending if the type is mutable or immutable | Yes | Text analysis, text editing, document formatting, artificial intelligence, expert systems, rapid prototyping, symbolic mathematics, text generation, and data laundry. | Facilitates ease of programming, short concise programs, automatic storage allocation and management, provide a rich base of basic data types and structures, and platform independence . Unicon provides additional capabilities over Icon integrating object oriented capabilities, messaging and external communications, event monitoring, and more in a consistent framework. |
| V | functional, stack-oriented, concatenative | No | strong | safe | dynamic | functional research | concatenative | ||||
| V (Vlang) | concurrent, imperative, procedural, structured, classless, functional, generic | No | strong | safe | explicit, optionally inferred | duck, structural | static | by value or by reference | Optional | General, Application, Systems, GUI, Web, CLI, IT | Simplicity, Readability, Usability, Portability, Modularity |
| Visual Basic | component-oriented programming, event-driven | No | strong | safe | nominative | static | by reference, by value (explicit) | Yes | Application | Rapid application development, Simplicity | |
| Visual Basic .NET | imperative, object-oriented, generic, reflective, functional, event-driven | No | strong | safe | implicit | nominative | static, dynamic (for interop) | by value, by reference (through managed pointers [always in-out]) | Yes | Application | Rapid application development |
| Windows PowerShell | imperative, object-oriented, functional, pipeline, reflective | No | strong | safe | implicit | dynamic | Scripting | ||||
| Wren | imperative, object-oriented, functional, concurrent | No | strong | safe | implicit | nominative | dynamic | by value | Yes | Host-driven Scripting | Lightweight, class-based, concurrent, easily embeddable |
| Language | Paradigm(s) | Standardized | Type strength | Type safety | Expression of types | Type compatibility | Type checking | Parameter Passing Methods Available | Garbage collection | Intended use | Design goals |