List of programming languages by type

From Wikipedia, the free encyclopedia

1Array language

2Assembly languages
3Authoring languages
4Constraint programming
5Command line interface languages
6Compiled languages
7Concurrent languages
8Curly-bracket languages
9Dataflow languages
10Data-oriented languages
11Data-structured languages
12Decision table languages
13Declarative languages
14Embeddable languages
14.1In source code
14.1.1Server side
14.1.2Client side
14.2In object code
15Educational languages
16Esoteric languages
17Extension languages
18Fourth-generation languages
19Functional languages
19.1Pure
19.2Impure
20Hardware description languages
20.1HDLs for analog circuit design
20.2HDLs for digital circuit design
21Imperative languages
22Interactive mode languages

23Interpreted languages
24Iterative languages
25List-based languages LISPs
26Little languages
27Logic-based languages
28Machine languages
29Macro languages
29.1Textual substitution macro languages
29.2Application macro languages
30Metaprogramming languages
31Multiparadigm languages
32Numerical analysis
33Non-English-based languages
34Object-oriented class-based languages
34.1Multiple dispatch
34.2Single dispatch
35Object-oriented prototype-based languages
36Off-side rule languages
37Procedural languages
38Reflective languages
39Rule-based languages
40Scripting languages
41Stack-based languages
42Synchronous languages
43Syntax handling languages
44Transformation languages
45Visual languages
46Wirth languages
47XML-based languages
48See also
49References
50External links

Array language
Array programming (also known as vector or multidimensional languages) generalize operations on scalars to apply
transparently to vectors, matrices, and higher-dimensional arrays.

A+

GAUSS

Analytica

APL

Julia

Chapel

Fortran

MATLAB

Freemat

Octave

X10

ZPL

S-Lang

IDL

SequenceL

Wolfram Language

Assembly languages
Assembly languages directly correspond to a machine language (see below) so machine code instructions appear
in a form understandable by humans. Assembly languages lets programmers use symbolic addresses, which
the assembler converts to absolute addresses. Most assemblers also support macros and symbolic constants.

Authoring languages

Bigwig (web design and development

language)
PILOT

TUTOR

Lasso

Constraint programming
Further information: List of constraint programming languages

Command line interface languages

Command-line interface (CLI) languages are also called batch languages, or job control languages. Examples:

4DOS (extended command-line shell for IBM PCs)

bash (the Bourne-Again shell from GNU/FSF)

CHAIN (Datapoint)

CLIST (MVS Command List)

CMS EXEC

csh and tcsh (C-like shell from Bill Joy at UC Berkeley)

DCL DIGITAL Command Language standard CLI language for VMS (DEC, Compaq, HP)

DOS batch language (standard CLI/batch language for the IBM PC running DOS operating systems, popular
before Windows)

EXEC 2

Expect (a Unix automation and test tool)

fish (a Unix shell)

Hamilton C shell (a C shell for Windows)

JCL (punch card-oriented batch control language for IBM System/360 family mainframes)

ksh (a standard Unix shell, written by David Korn)

Rc (command-line shell for Plan 9)

REXX

sh (the standard Unix shell, written by Stephen R. Bourne)

TACL (Tandem Advanced Command Language)

Windows batch language (Windows batch file language as understood by COMMAND.COM and CMD.EXE)

Windows PowerShell (Microsoft .NET-based CLI)

zsh (a Unix shell)

Compiled languages[edit]
These are languages typically processed by compilers, though theoretically any language can be compiled or
interpreted. See also compiled language.

ActionScript

Ada (multi-purpose language)

ALGOL (extremely influential language design the second high level language compiler)

SMALL Machine Algol Like Language

Ateji PX, an extension of the Java language for parallelism

BASIC (some dialects, including the first version of Dartmouth BASIC)

BCPL

Blue

C (one of the most widely used procedural programming languages)

C++ (One of the most widely used object-oriented (OO) languages specially used in large scale, highly
complex, high performance software systems)

C# (compiled into Intermediate Language, which generates a native image at runtime)

Ceylon (compiled into JVM bytecode)

CLIPPER 5.3 (programming Language for DOS-based software)

CLEO (Clear Language for Expressing Orders) used the compiler for the British Leo computers

COBOL

Cobra

Common Lisp

Curl

D (Attempts a "C++ done right" philosophy)

DASL compiles into Java, JavaScript, JSP, Flex, etc., which are further compiled into a .war file

Delphi (Borland's Object Pascal development system)

DIBOL (Digital Interactive Business Oriented Language)

Dylan

eC

Eiffel (object-oriented language developed by Bertrand Meyer)

Sather

Ubercode

Emacs Lisp

Erlang

Factor

Forth (professional systems, like VFX and SwiftForth)

Fortran (the first high-level, compiled language, from IBM, John Backus, et al.)

GAUSS

Go

Gosu (compiled into JVM bytecode)

Groovy (compiled into JVM bytecode)

Haskell

Harbour

Java (usually compiled into JVM bytecode although ahead-of-time (AOT) compilers exist that compile
to machine code)
JOVIAL

LabVIEW

Mercury

Nemerle (compiled into Intermediate Language bytecode)

Objective-C

Pascal (most implementations)

Plus

Python (compiled into intermediate Virtual Machine bytecode)

RPG (Report Program Generator)

Rust

Scala (compiled into JVM bytecode)

Scheme (some implementations, e.g. Gambit)

SequenceL purely functional, automatically parallelizing and race-free

Simula (the first object-oriented language, developed by Ole-Johan Dahl and Kristen Nygaard)

Smalltalk generally compiled to platform independent bytecode that runs on a Virtual Machine

Swift

ML

Standard ML (SML)

Alice
OCaml

Turing

Vala (Compiler for the GObject type system)

Visual Basic (Earlier versions compiled directly to a native runtime. Recent .NET versions compile into
Intermediate Language that is Just-In-Time compiled into a native image at runtime.)

Visual FoxPro

Visual Prolog

X++

X#

XL

Z++

Concurrent languages
See also: List of concurrent and parallel programming languages and Category:Concurrent programming languages
Message passing languages provide language constructs for concurrency. The predominant paradigm for
concurrency in mainstream languages such as Java is shared memoryconcurrency based on monitors. Concurrent
languages that make use of message passing have generally been inspired by CSP or the -calculus, but have had
little commercial success, except for Ada and Erlang. Ada is a multipurpose language and concurrent programming
is only one option available.

Ada (multi-purpose language)

Alef concurrent language with threads and message passing, used for systems programming in early
versions of Plan 9 from Bell Labs

Ateji PX an extension of the Java language for parallelism

ChucK domain specific programming language for audio, precise control over concurrency and timing

Cilk a concurrent C

C C Omega, a research language extending C#, uses asynchronous communication

Clojure a dialect of Lisp for the Java Virtual Machine

Chapel

Co-array Fortran

Concurrent Pascal (by Brinch-Hansen)

Curry

E uses promises, ensures deadlocks cannot occur

Eiffel (through the SCOOP mechanism, Simple Concurrent Object-Oriented Computation)

Erlang uses asynchronous message passing with nothing shared

Go

Java

Join Java concurrent language based on Java

X10
Julia

Join-calculus

Joule dataflow language, communicates by message passing

Limbo relative of Alef, used for systems programming in Inferno (operating system)

MultiLisp Scheme variant extended to support parallelism

occam influenced heavily by Communicating Sequential Processes (CSP)

occam- a modern variant of occam, which incorporates ideas from Milner's -calculus

Orc

Oz multiparadigm language, supports shared-state and message-passing concurrency, and futures

Mozart Programming System multiplatform Oz

Pict essentially an executable implementation of Milner's -calculus

Rust actor-based

SALSA actor language with token-passing, join, and first-class continuations for distributed computing over
the Internet

Scala implements Erlang-style actors on the JVM

SequenceL purely functional, automatically parallelizing and race-free

SR research language

Unified Parallel C

XProc XML processing language, enabling concurrency

Curly-bracket languages
The curly-bracket or curly-brace programming languages have a syntax that defines statement blocks using
the curly bracket or brace characters { and } . This syntax originated with BCPL (1966), and was popularized
by C (1972). Many curly-bracket languages descend from or are strongly influenced by C. Examples of curly-bracket
languages include:

ABCL/c+

AWK

Alef

bc

BCPL

C developed circa 1970 at Bell Labs

Limbo

AutoHotkey

Go

C++

Join Java

C#

Kotlin

Ceylon

Tea

ChucK audio programming language

X10

Cilk concurrent C for multithreaded parallel

programming

LPC

MSL

MEL

Cyclone a safer C variant

Dart

DASL based on Java

PCASTL

Perl

eC

PHP

ECMAScript

Pico

Nemerle combines C# and ML features,

provides syntax extension abilities

ActionScript

Pike

ECMAScript for XML

JavaScript

Rust

JScript

S-Lang

TypeScript

Scala

GML (Game Maker Language)

sed

GLSL

SuperCollider

ICI

Swift

Java

UnrealScript

Processing

Groovy

Dataflow languages

Windows PowerShell (Microsoft .NET-based

CLI)
Yorick

Dataflow programming languages rely on a (usually visual) representation of the flow of data to specify the program.
Frequently used for reacting to discrete events or for processing streams of data. Examples of dataflow languages
include:

Hartmann pipelines

Reaktor

G (used in LabVIEW)

StreamBase StreamSQL EventFlow

Lucid

VEE

Max

VHDL

Oz

VisSim

Prograph

WebMethods Flow

Pure Data

Data-oriented languages
Data-oriented languages provide powerful ways of searching and manipulating the relations that have been
described as entity relationship tables which map one set of things into other sets. Examples of data-oriented
languages include:

Clarion

SQL

Clipper

Tutorial D see also The Third Manifesto

dBase a relational database access language

Visual FoxPro a native RDBMS engine,

object-oriented, RAD

MUMPS (an ANSI standard general purpose

language with specializations for database work)

WebDNA

Cach (similar to MUMPS)

WebQL

RDQL

Wolfram Language

SPARQL

Data-structured languages
Data-structured languages are those where logic is structured in ways similar to their data. Such languages are
generally well suited to reflection and introspection. There are three main types:

Array-based

List-based

Stack-based

Assembly languages that statically link data inline with instructions can also be considered data-structured, in the
most primitive way.

Decision table languages

Decision tables can be used as an aid to clarifying the logic before writing a program in any language, but in the
1960s a number of languages were developed where the main logic is expressed directly in the form of a decision
table, including:

Filetab

Declarative languages
Declarative languages describe a problem rather than defining a solution. Declarative programming stands in
contrast to imperative programming via imperative programming languages, where serial orders (imperatives) are
given to a computer. In addition to the examples given just below, all (pure) functional and logic-based programming
languages are also declarative. In fact, "functional" and "logical" constitute the usual subcategories of the
declarative category.

Analytica
Ant (partially declarative languages, partially imperative
programming)

DASL (partially declarative languages, partially imperative

Oz

RDQL

programming)

SequenceL purely functional, automatically

parallelizing and race-free

Lustre

SPARQL

MetaPost

SQL

Modelica

Wolfram Language

Prolog

xBase

XSL Transformations

Embeddable languages
In source code
Source embeddable languages embed small pieces of executable code inside a piece of free-form text, often a web
page.
Client-side embedded languages are limited by the abilities of the browser or intended client. They aim to provide
dynamism to web pages without the need to recontact the server.
Server-side embedded languages are much more flexible, since almost any language can be built into a server. The
aim of having fragments of server-side code embedded in a web page is to generate additional markup dynamically;
the code itself disappears when the page is served, to be replaced by its output.
Server side

PHP

VBScript

SMX dedicated to web pages

WebDNA dedicated to database-driven
websites

The above examples are particularly dedicated to this purpose. A large number of other languages, such
as Erlang, Scala, Perl and Ruby can be adapted (for instance, by being made into Apache modules).

Client side

ActionScript

ECMAScript

Java

JScript

JavaScript

VBScript (Windows only)

In object code
A wide variety of dynamic or scripting languages can be embedded in compiled executable code. Basically, object
code for the language's interpreter needs to be linked into the executable. Source code fragments for the embedded
language can then be passed to an evaluation function as strings. Application control languages can be
implemented this way, if the source code is input by the user. Languages with small interpreters are preferred.

AngelScript

MiniD

Ch

Python

EEL

Ruby (via mruby)

Io

Squirrel

Julia

Tcl

Lua

Educational languages
Languages developed primarily for the purpose of teaching and learning of programming.

Alice

Modula-2

Blue

Pascal

COMAL

Scheme

Elan

Scratch

Logo

Turing

KTurtle

Wolfram Language

Esoteric languages
An esoteric programming language is a programming language designed as a test of the boundaries of computer
programming language design, as a proof of concept, or as a joke.

Befunge

INTERCAL

Brainfuck

LOLCODE

Chef

Malbolge

Piet

Shakespeare

Whitespace

Extension languages[edit]
Extension programming languages are languages embedded into another program and used to harness its features
in extension scripts.

writing optimization models and powerful

abstractions for bulk data processing

Ateji PX an extension of the Java language

for parallelism

AutoLISP (specific to AutoCAD)

CAL

C/AL(C/SIDE)

Guile

Emacs Lisp

JavaScript and some dialects (e.g. JScript)

Lua e.g. embedded in many games

OpenCL an extension of C and C++ to use

the GPU and parallel extensions of the CPU

OptimJ an extension of the Java

programming language with language support for

Python (embedded in Maya, Blender and

other 3-D animation packages)

REXX

Ruby (Google SketchUp)

S-Lang

SQL

Squirrel

Tcl

Vim script

VBA

Windows PowerShell

Fourth-generation languages[edit]
Fourth-generation programming languages are high-level languages built around database systems. They are
generally used in commercial environments.

ABAP

CorVision

CSC's GraphTalk

Easytrieve report generator (now CAEasytrieve Plus)

FOCUS

IBM Informix-4GL / Aubit-4GL

LINC 4GL

MAPPER (Unisys/Sperry) now part of BIS

MARK-IV (Sterling/Informatics) now
VISION:BUILDER of CA

NATURAL

Progress 4GL

Revolution (not based on a database; still, the

goal is to work at a higher level of abstraction
than 3GLs)
SAS

Ubercode (VHLL, or Very High Level

Language)

Uniface

Visual DataFlex

Visual FoxPro

xBase

Functional languages
Functional programming languages define programs and subroutines as mathematical functions. Many so-called
functional languages are "impure", containing imperative features. Many functional languages are tied to
mathematical calculation tools. Functional languages include:

Pure

Charity

Haskell

Clean

Hope

Coq (Gallina)

Mercury

Curry

Miranda

Elm

Idris

Frege

SequenceL

Impure

APL

ATS

CAL

Elixir

C++ (since C++11)

LFE

C#

F#

Ceylon

FPr

Groovy

Dart

Hop

Curl

ECMAScript

Java (since version 8)

JScript
Erlang

ActionScript

Joy

ECMAScript for XML

Julia

JavaScript

Lisp

Clojure

Nemerle

Common Lisp

Opal

Dylan

OPS5

Emacs Lisp

Poplog

LFE

Python

Little b

Q (equational programming language)

Logo

Q (programming language from Kx Systems)

Scheme

Ruby

REFAL

Racket (formerly PLT Scheme)

Tea

Mathematica

Rust

ML

Scala

Standard ML (SML)

Spreadsheets

Alice

Wolfram Language

OCaml

Hardware description languages

In electronics, a Hardware description language or HDL is a specialized computer language used to describe the
structure, design and operation of electronic circuits, and most commonly, digital logic circuits. The two most widely
used and well-supported HDL varieties used in industry are Verilog and VHDL. Hardware description languages
include:

HDLs for analog circuit design

Verilog-AMS (Verilog for Analog and Mixed-Signal)

VHDL-AMS (VHDL with Analog/Mixed-Signal extension)

HDLs for digital circuit design

Advanced Boolean Expression

Language(ABEL)

Altera Hardware Description

Language(AHDL)

Bluespec

Confluence

ELLA

ESys.net

Handel-C

HHDL

Impulse C

PALASM

JHDL

Ruby (hardware description language)

Lava

SystemC

Lola

SystemVerilog

Verilog

MyHDL

VHDL (VHSIC HDL)

Imperative languages
Imperative programming languages may be multi-paradigm and appear in other classifications. Here is a list of
programming languages that follow the imperative paradigm:

Ada

Lua

ALGOL

MATLAB

BASIC

Machine language

Blue

Modula-2, Modula-3

MUMPS

C++

Oberon

C#

Object Pascal

Ceylon

OCaml

COBOL

Pascal

Perl

eC

PHP

FORTRAN

PROSE

GAUSS

Python

Go

Ruby

Groovy

Rust

Java

Wolfram Language

Julia

 Interactive mode languages

Interactive mode languages act as a kind of shell: expressions or statements can be entered one at a time, and the
result of their evaluation is seen immediately.

APL

Maple

BASIC (some dialects)

Mathematica (Wolfram language)

Clojure

MATLAB

Common Lisp

ML

Perl

Pike

PostScript

Python

PROSE

REXX

Ruby (with IRB)

Scala

Scheme

Dart (with Observatory or Dartium's developer

tools)

Erlang

F#

Forth

FPr

Fril

GAUSS

Groovy

Haskell (with the GHCi or Hugs interpreter)

IDL

JavaScript (via Node.js at the command line

or Chrome's developer tools)

Julia

Lua

MUMPS (an ANSI standard general purpose

language)

Smalltalk (anywhere in a Smalltalk

environment)

S-Lang (with the S-Lang shell, slsh)

Tcl (with the Tcl shell, tclsh)

Windows PowerShell (Microsoft .NET-based

CLI)
Visual FoxPro (Microsoft)

Interpreted languages
Interpreted languages are programming languages in which programs may be executed from source code form, by
an interpreter. Theoretically, any language can be compiled or interpreted, so the term *interpreted language*
generally refers to languages that are commonly interpreted rather than compiled.

Ant

APL

AutoHotkey scripting language

MATLAB

AutoIt scripting language

Oriel

BASIC (some dialects)

Pascal (early implementations)

PCASTL

Perl

PHP

Pikt

PostScript

PROSE

Python

REXX

Ruby

S-Lang

Standard ML (SML)

Spin

Tcl

TI-BASIC

TorqueScript

thinBasic scripting language

VBScript

DATABUS (later versions added optional

compiling)

DM
Eiffel (via "Melting Ice Technology"
in EiffelStudio)

Forth (interactive shell only; otherwise

compiled to native or threaded code)

FPr (Virtual machine: Text is compiled to

linked lists; linked lists are interpreted)

Game Maker Language

Groovy

Haskell (GHCi, Hugs, NHC, YHC etc.)

Julia (Compiled on the fly to machine code,

but a transpiler Julia2C is also available.)

JavaScript
Lisp (Early versions, pre-1962, and some
experimental ones; production Lisp systems are
compilers, but many of them still provide an
interpreter if needed.)

Tea

LPC

Lua

MUMPS (an ANSI standard general purpose

language)

Windows PowerShell (Microsoft .NET-based

CLI)

Wolfram Language

Some scripting languages (below)

Maple
Mathematica

Iterative languages

Iterative languages are built around or offering generators.

Aldor

IPL-v

Alphard

Julia

C#

Lua

CLU

PHP

Cobra

Python

Eiffel, through "agents"

Sather

Icon

XL ("iterator" construct)

List-based languages LISPs

List-based languages are a type of data-structured language that are based upon the list data structure.

FPr

Racket

Joy

Scheme

Lisp

Logo

Arc

Clojure

Tcl

Common Lisp

Dylan

Emacs Lisp

Tea
TRAC

Little languages
Little languages serve a specialized problem domain.

awk can serve as a prototyping language for C (shares similar syntax)

Comet used to solve complex combinatorial optimization problems in areas such as resource
allocation and scheduling

SQL has only a few keywords, and not all the constructs needed for a full programming language [1] many
database management systems extend SQL with additional constructs as a stored procedure language

Logic-based languages
Logic-based languages specify a set of attributes that a solution must have, rather than a set of steps to obtain a
solution. Examples:

ALF

Alma-0

CLACL (CLAC-Language)

Curry

Fril

Janus

Leda

Oz

Poplog
Prolog (formulates data and the program
evaluation mechanism as a special form of
mathematical logic called Horn logic and a
general proving mechanism called logical
resolution)

Prolog (a logic programming language

featuring polymorphic typing, modular
programming, and higher-order programming)

Mozart Programming System

a multiplatform Oz

Mercury (based on Prolog)

Strawberry Prolog (standard Prolog

with some extensions)

Visual Prolog (object-oriented Prolog

extension)

ROOP

Machine languages
Machine languages are directly executable by a computer's CPU. They are typically formulated as bit patterns,
usually represented in octal or hexadecimal. Each bit pattern causes the circuits in the CPU to execute one of the
fundamental operations of the hardware. The activation of specific electrical inputs (e.g., CPU package pins for
microprocessors), and logical settings for CPU state values, control the processor's computation. Individual machine
languages are specific to a family of processors; machine-language code for one family of processors cannot run
directly on processors in another family unless the processors in question have additional hardware to support it (for
example, DEC VAX processors included a PDP-11 compatibility mode). They are (essentially) always defined by the
CPU developer, not by 3rd parties. The symbolic version, the processor's assembly language, is also defined by the
developer, in most cases. Some commonly-used machine code instruction sets are:

ARM

Original 32-bit

x86:

16-bit x86, first used in the Intel 8086

16-bit Thumb instructions (subset or

registers used)

64-bit (major architecture change,

more registers)

DEC PDP-6/PDP-10/DECSYSTEM-20

DEC PDP-11 (influenced VAX and M68000)

DEC VAX

DEC Alpha

Intel 8008, 8080 and 8085

Zilog Z80

Intel 8086 and 8088 (the latter

was used in the first and early IBM PC)
Intel 80186
Intel 80286 (the first x86
processor with protected mode, used in
the IBM AT)

IA-32, introduced in the 80386

x86-64 The original specification was

created by AMD. There are vendor variants,
but they're essentially the same:

AMD's AMD64

Intel's Intel 64

IBM System/360 and successors,

including z/Architecture

Western Design
Center 65816/65802 (CPU for Apple IIGS and
(variant) Super Nintendo Entertainment
System)

MIPS

National NS320xx

Motorola 6800

Power Architecture

Motorola 68000 family (CPUs used in

early Apple Macintosh and early Sun computers)

MOS Technology 65xx

6502 (CPU for VIC-20, Apple II,

and Atari 800)

POWER, first used in the IBM

RS/6000

PowerPC used in Power

Macintosh and the technology is used in
many older gneration game consoles)
Sun SPARC

6510 (CPU for Commodore 64)

Macro languages
Textual substitution macro languages
Macro languages transform one source code file into another. A "macro" is essentially a short piece of text that
expands into a longer one (not too be confused with hygienic macros), possibly with parameter substitution. They
are often used to preprocess source code. Preprocessors can also supply facilities like file inclusion.
Macro languages may be restricted to acting on specially labeled code regions (pre-fixed with a # in the case of the
C preprocessor. Alternatively, they may not, but in this case it is still often undesirable to (for instance) expand a
macro embedded in a string literal, so they still need a rudimentary awareness of syntax. That being the case, they
are often still applicable to more than one language. Contrast with source-embeddable languages like PHP, which
are fully featured.

cpp (the C preprocessor)

m4 (originally from AT&T, bundled with Unix)

Application macro languages

Scripting languages such as Tcl and ECMAScript (ActionScript, ECMAScript for XML, JavaScript, JScript) have
been embedded into applications. These are sometimes called "macro languages", although in a somewhat different
sense to textual-substitution macros like m4.

Metaprogramming languages
Metaprogramming is writing of programs that write or manipulate other programs (or themselves) as their data or
that do part of the work that is otherwise done at run timeduring compile time. In many cases, this allows
programmers to get more done in the same amount of time as they would take to write all the code manually.

C++

Elixir

Curl

Forth

Groovy

eC

Haskell

Julia

Python

Lisp

Ruby

Lua

Rust

Maude system

Scheme

Mathematica

SequenceL

MetaOCaml

Smalltalk

Nemerle

Wolfram Language

Perl

XL (concept programming)

Multiparadigm languages
Multiparadigm languages support more than one programming paradigm. They allow a program to use more than
one programming style. The goal is to allow programmers to use the best tool for a job, admitting that no one
paradigm solves all problems in the easiest or most efficient way.

Ada (concurrent, distributed, generic (template metaprogramming), imperative, object-oriented (classbased))

ALF (functional, logic)

Alma-0 (constraint, imperative, logic)

APL (functional, imperative)

BETA (functional, imperative, object-oriented (class-based))

C++ (generic, imperative, object-oriented (class-based), functional)

C# (generic, imperative, object-oriented (class-based), functional, declarative)

Ceylon (generic, imperative, object-oriented (class-based), functional, declarative)

ChucK (imperative, object-oriented, time-based, concurrent, on-the-fly)

Cobra (generic, imperative, object-oriented (class-based), functional, contractual)

Common Lisp (functional, imperative, object-oriented (class-based), aspect-oriented (user may add further
paradigms, e.g., logic))

Curl (functional, imperative, object-oriented (class-based), metaprogramming)

Curry (concurrent, functional, logic)

D (generic, imperative, functional, object-oriented (class-based), metaprogramming)

Delphi (generic, imperative, object-oriented (class-based), metaprogramming)

Dylan (functional, object-oriented (class-based))

eC (generic, imperative, object-oriented (class-based))

ECMAScript (functional, imperative, object-oriented (prototype-based))

ActionScript

ECMAScript for XML

JavaScript

JScript

Eiffel (imperative, object-oriented (class-based), generic, functional (agents), concurrent (SCOOP))

F# (functional, generic, object-oriented (class-based), language-oriented)

Fantom (functional, object-oriented (class-based))

FPr (function-level, object-oriented (class-based))

Go (functional, object-oriented (class-based), imperative, procedural),

Groovy (functional, object-oriented (class-based),imperative,procedural)

Harbour

Hop

J (functional, imperative, object-oriented (class-based))

Julia (imperative, multiple dispatch ("object-oriented"), functional, metaprogramming)

LabVIEW (dataflow, visual)

Lava (object-oriented (class-based), visual)

Leda (functional, imperative, logic, object-oriented (class-based))

Lua (functional, imperative, object-oriented (prototype-based))

Mercury (functional, logical, object-oriented)

Metaobject protocols (object-oriented (class-based, prototype-based))

Nemerle (functional, object-oriented (class-based), imperative, metaprogramming)

Objective-C (imperative, object-oriented (class-based), reflective)

OCaml (functional, imperative, object-oriented (class-based))

Oz (functional (evaluation: eager, lazy), logic, constraint, imperative, object-oriented (class-based),
concurrent, distributed)

Mozart Programming System (multiplatform Oz)

Object Pascal (imperative, object-oriented (class-based))

Perl (imperative, functional (can't be purely functional), object-oriented, class-oriented, aspect-oriented

(through modules))

PHP (imperative, object-oriented)

Pike

Poplog (functional, imperative, logic)

Prograph (dataflow, object-oriented (class-based), visual)

Python (functional, object-oriented (class-based), imperative, metaprogramming)

Racket (functional, imperative, object-oriented (class-based) and can be extended by the user)

REBOL (functional, imperative, object-oriented (prototype-based), metaprogramming (dialected))

ROOP (imperative, logic, object-oriented (class-based), rule-based)

Ruby (imperative, functional, object-oriented (class-based), metaprogramming)

Rust (concurrent, functional, imperative, object-oriented)

Scala (functional, object-oriented)

Seed7 (imperative, object-oriented, generic)

SISAL (concurrent, dataflow, functional)

Spreadsheets (functional, visual)

Tcl (functional, imperative, object-oriented (class-based))

Tea (functional, imperative, object-oriented (class-based))

Windows PowerShell (functional, imperative, pipeline, object-oriented (class-based))

Wolfram Language

XL (concept programming approach)

Numerical analysis

AIMMS

Klerer-May System

AMPL

Mathematica

Analytica

MATLAB

GAUSS

PROSE

GAMS

Seneca an Oberon variant

Julia

Wolfram Language

Non-English-based languages
Main article: non-English-based programming languages

ARLOGO Arabic

Chinese BASIC Chinese

Fjlnir Icelandic

Language Symbolique d'Enseignement French

Lexico Spanish

Rapira Russian

Object-oriented class-based languages

Class-based Object-oriented programming languages support objects defined by their class. Class definitions
include member data. Message passing is a key concept (if not thekey concept) in Object-oriented languages.
Polymorphic functions parameterized by the class of some of their arguments are typically called methods. In
languages with single dispatch, classes typically also include method definitions. In languages with multiple
dispatch, methods are defined by generic functions. There are exceptions where single dispatch methods
are generic functions(e.g. Bigloo's object system).

Multiple dispatch

Common Lisp

Goo

Cecil

Julia

Dylan

Single dispatch

ActionScript 3.0

Actor

Ada 95 and Ada 2005 (multi-purpose

language)
BETA

Blue

C++

Processing

C#

Groovy

Ceylon

Join Java

Oxygene (formerly known as Chrome)

Tea

ChucK

X10

Cobra

LabVIEW

ColdFusion

Lava

Curl

Lua

DASL

Delphi

Nemerle

GNU E

IBM NetRexx

eC

Eiffel

Java

Modula-2 (data abstraction, information

hiding, strong typing, full modularity)

Sather

Ubercode

Modula-3 (added more object-oriented

features to Modula-2)

Oberon-2 (full object-orientation equivalence

in an original, strongly typed, Wirthian manner)

Object Pascal

Object REXX

Objective-C (a superset of C adding

a Smalltalk derived object model and message
passing syntax)

F-Script

Fortran 2003

OCaml

Fortress

Oz

FPr

Gambas

Perl 5

Game Maker Language

PHP

Harbour

Pike

Prograph

Mozart Programming System

Python (interpretive language, optionally

object-oriented)

Squeak

Realbasic
Revolution (programmer does not get to pick
the objects)

Scratch

IBM VisualAge

VisualWorks

Ruby

SPIN

Scala

SuperCollider

Simula (the first object-oriented language,

developed by Ole-Johan Dahl and Kristen
Nygaard)

Smalltalk (pure object-orientation, developed

at Xerox PARC)

Bistro

F-Script

Little Smalltalk

VBScript (Microsoft Office 'macro scripting'

language)

Visual DataFlex

Visual FoxPro

Visual Prolog

X++

XOTcl

Object-oriented prototype-based languages[edit]

Prototype-based languages are object-oriented languages where the distinction between classes and instances has
been removed:

ABCL/1

Etoys in Squeak

ABCL/R

Io

ABCL/R2

Lisaac

ABCL/c plus

Lua

Agora

MOO

Cecil

NewtonScript

ECMAScript

Obliq

ActionScript

ECMAScript for XML

REBOL

JavaScript (first named Mocha,

then LiveScript)
JScript

Self (the first prototype-based language,

derived from Smalltalk)
TADS

 Off-side rule languages[edit]

Off-side rule languages are those where blocks are formed, indicated, by their indentation.

ISWIM, the abstract language that introduced

the rule

ABC, Python's parent

Orwell

Haskell

Python

Cobra

Boo

Genie

Miranda, Haskell's parent

F#

Nim

Occam

SPIN

XL

Curry

Procedural languages
Procedural programming languages are based on the concept of the unit and scope (the data viewing range of an
executable code statement). A procedural program is composed of one or more units or modules, either user coded
or provided in a code library; each module is composed of one or more procedures, also called a function, routine,
subroutine, or method, depending on the language. Examples of procedural languages include:

Ada (multi-purpose language)

Ceylon

ALGOL (extremely influential language design

the second high level language compiler)

COBOL

Cobra

ColdFusion

Combined Programming Language (CPL)

SMALL Machine Algol Like Language

Alma-0

BASIC (BASICs are innocent of most

modularity in (especially) versions before about
1990)

ChucK (C/Java-like syntax, with new syntax

elements for time and parallelism)

BCPL

Curl

BLISS

Blue

DASL (partly declarative, partly imperative)

eC

ECMAScript

C++ (C with objects plus much else, such as,

generics through STL)
C# (similar to Java/C++)

ActionScript

ECMAScript for XML

JavaScript (first named Mocha,
then LiveScript)

JScript

Eiffel

Fortran (better modularity in later Standards)

Lagoona

Seneca

Occam

Oriel

Pascal (successor to ALGOL 60, predecessor

of Modula-2)

Free Pascal (FPC)

Object Pascal (Delphi)

GAUSS

Go

PCASTL

Harbour

Perl

HyperTalk

Pike

Java

PL/C

Groovy

Join Java

Tea

JOVIAL

Julia

Lasso

Modula-2 (fundamentally based on modules)

Mathematica

MATLAB

MUMPS (More modular in its first release than

a language of the time should have been; The
standard has become still more modular since
then.)

Nemerle
Oberon and Oberon-2 (improved, smaller,
faster, safer follow-ons for Modula-2)

Component Pascal

PL/I (large general purpose language,

originally for IBM mainframes)

Plus

PROSE

Python

Rapira

RPG (available only in IBM's System

i midrange computers)

Rust

S-Lang

VBScript

Visual Basic

Visual FoxPro

Wolfram Language

X++

X#

XL

Reflective languages
Main article: List of reflective programming languages
Reflective languages let programs examine and possibly modify their high level structure at runtime. This is most
common in high-level virtual machine programming languages like Smalltalk, and less common in lower-level
programming languages like C. Languages and platforms supporting reflection:
See also: Aspect-oriented programming

Befunge

Join Java

C#

X10

Ceylon

Julia

Charm

Lisp

ChucK

Clojure

Cobra

Common Lisp

Dylan

Logo

Scheme

Component Pascal BlackBox Component

Builder

Curl

Delphi

eC

ECMAScript

Lua

Maude system

.NET Framework Common Language

Runtime

ECMAScript for XML

Oberon-2 ETH Oberon System

JavaScript

Objective-C

JScript

PCASTL

ActionScript

Eiffel

Perl

Forth

PHP

Harbour

Pico

Java

Poplog

Java Virtual Machine

Groovy

POP-11
Prolog

Python

Squeak

REBOL

IBM VisualAge

Ruby

VisualWorks

Smalltalk (pure object-orientation, originally

from Xerox PARC)

Bistro

F-Script

Little Smalltalk

Self

Snobol

Tcl

Wolfram Language

XOTcl

X++

XL

Rule-based languages
Rule-based languages instantiate rules when activated by conditions in a set of data. Of all possible activations,
some set is selected and the statements belonging to those rules execute. Rule-based languages include: [citation needed]

awk

OPS5

CLIPS

Prolog

Constraint Handling Rules

ToonTalk robots are rules

Drools

Mathematica

GOAL agent programming language

XSLT [citation needed]

Jess

Wolfram Language

Scripting languages
"Scripting language" has two apparently different, but in fact similar meanings. In a traditional sense, scripting
languages are designed to automate frequently used tasks that usually involve calling or passing commands to
external programs. Many complex application programs provide built-in languages that let users automate tasks.
Those that areinterpretive are often called scripting languages.
Recently, many applications have built-in traditional scripting languages, such as Perl or Visual Basic, but there are
quite a few "native" scripting languages still in use. Many scripting languages are compiled to bytecode and then this
(usually) platform-independent bytecode is run through a virtual machine (compare to Java).

AppleScript

Ch (Embeddable C/C++ interpreter)

AWK

CLIST

BeanShell

ColdFusion

Bash

ECMAScript

ActionScript

Perl

ECMAScript for XML

PHP (intended for Web servers)

Pikt

Python

REBOL

REXX

Revolution

Ruby

Smalltalk

S-Lang

sed

Tea

Tcl

TorqueScript

VBScript

JavaScript (first named Mocha,

then LiveScript)

JScript

CMS EXEC

EXEC 2

F-Script

Falcon

Game Maker Language (GML)

ICI

Io

JASS

Groovy

Join Java

Julia (still, compiled on the fly to machine

code)

Lasso

Lua

MAXScript

MEL

Oriel

WebDNA, dedicated to database-driven

websites

Windows PowerShell (Microsoft .NET-based

CLI)
Winbatch
Many shell command languages such as
the Unix shell or DCL on VMS have powerful
scripting abilities.

Stack-based languages
Stack-based languages are a type of data-structured language that are based upon the stack data structure.

colorForth

Factor

Forth
Joy (all functions work on parameter stacks
instead of named parameters)

Piet

PostScript

Poplog via its implementation language POP-

RPL

11

Synchronous languages
Synchronous programming languages are optimized for programming reactive systems, systems that are often
interrupted and must respond quickly. Many such systems are also called realtime systems, and are used often
in embedded systems. Examples:

Argus

Lustre

Averest

SyncCharts

Esterel

Syntax handling languages

These languages assist with generating lexical analyzers and parsers for Context-free grammars.

ANTLR

lex (Lexical Analysis, from Bell Labs)

Coco/R (EBNF with semantics)

M4

GNU bison (FSF's version of Yacc)

GNU Flex (FSF's version of Lex)

yacc (yet another compiler compiler, from Bell

Labs)
JavaCC

glex/gyacc (GoboSoft compiler compiler to

Eiffel)

Transformation languages
Main article: Transformation language

Visual languages[edit]
See also: Category:Visual programming languages
Visual programming languages let users specify programs in a two-(or more)-dimensional way, instead of as onedimensional text strings, via graphic layouts of various types.

Analytica

Limnor

CODE

Max

DRAKON

NXT-G

Fabrik

Pict programming language

G (used in LabVIEW)

Prograph

Lava

Pure Data

Quartz Composer
Scratch (written in and based on Squeak, a
version of Smalltalk)

Simulink

Spreadsheets

Subtext

ToonTalk

VEE

VisSim

vvvv

EICASLAB

Some dataflow programming languages are also visual languages.

Wirth languages

Computer scientist Niklaus Wirth designed and implemented several influential languages.

ALGOL W

Euler

Modula

Modula-2 (and Modula 3, etc. variants)

Obliq Modula 3 variant

Oberon (Oberon, Oberon-07, and Oberon-2)

Component Pascal

Lagoona

Oberon-2

Pascal

Object Pascal ("umbrella" name for Delphi, Free Pascal, Oxygene and others)

XML-based languages

These are languages based on or that operate on XML.

Ant

ECMAScript ECMAScript for XML

MXML

LZX

XAML

XPath

XQuery

XProc

XSLT

 References
1.

Jump up^ The objects of SQL are collections of records, called tables. A full programming language can
specify algorithms, irrespective of runtime. Thus an algorithm can be considered to generate usable results. In contrast,
SQL can only select records which are limited to the current collection, the data at hand in the system, rather than
produce a statement of the correctness of the result.