Computer Language:-computer language includes a wide variety of languages used to communicate with computers. It is broader than the more commonly-used term programming Language. Programming languages are a subset of computer languages. For example, HTML is a markup language and a computer language, but it is not traditionally considered a programming language. machine code is a computer language. It can technically be used for programming, and has been though most would not consider it a programming language.

Types Of Language in details:-

1) Programming Language
2) Scripting Language
3) Specification Language
4) Machine Language
5) Bytecode
6) Query Language
7) Markup Language
8) Transformation Langugae
9) Template Processing Language
10) Fourth Generation Language
11) Visual Programming Language
12) Hardware Description language

Programming Language:-
A programming language is an artificial language that can be used to control the behavior of a machine, particularly a computer. Programming languages, like natural languages, are defined by syntactic and semantic rules which describe their structure and meaning respectively. Many programming languages have some form of written specification of their syntax and semantics; some are defined only by an official implementation.

Defintion
Alan Perlis once said: "A language that doesn't affect the way you think about programming, is not worth knowing".
A programming language is a language used to write computer programs, which involve a computer performing some kind of computation or algorithm and possibly control external devices such as printers, robots, and so on.

Syntax:-

expression ::= atom | list
atom ::= number | symbol
number ::= [+-]?['0'-'9']+
symbol ::= ['A'-'Z''a'-'z'].*
list ::= '(' expression* ')'

This grammar specifies the following:

• expression is either an atom or a list;
• atom is either a number or a symbol;
• number is an unbroken sequence of one or more decimal digits, optionally preceded by a plus or minus sign;
• symbol is a letter followed by zero or more of any characters (excluding whitespace); and
• list is a matched pair of parentheses, with zero or more expressions inside it.

History Of Programming Languages:-
In 1976, at the History of Computing Conference in Los Alamos, Richard Hamming described why we might be interested in the history of computing: "we would know what they thought when they did it".

List of Programming Languages:-
(By Alphabetically)
A

A+
A++
A# .NET
A# (Axiom)
A-0
ABAP
ABC
ABC
ALGOL
ABLE
ABSET
ABSYS
ACC
Accent
Ace DASL
ACT-III
Action!
ACS
ActionScript
Actor
Ada
ADMINS - Automated Data Methods for Information Naming Systems
ADS/Online
AdvPL
Aleph
AIMMS
AION
Alan
ALC Assembly Language Common, IBM acronym for BAL Basic assembly language
Aldor
Alef - concurrent language used in early versions of Plan 9
Algae
ALGO
ALGOL
Alice
Alphard
AmigaE
AMOS
AMPL
ApeScript
APL
AppleScript
Apply - A domain-specific language for image


B

B
BACI
BASIC - Beginners All-purpose Symbollic Instruction Code - See also List of BASIC dialects (by platform)
bc
bcompile
BCPL
BeanShell
BETA
Bigwig
Bistro
BLISS
Blitz Basic
Block And List Manipulation (BALM)
Blue - Rejected prototype for Ada
Blue
Boo
Bourne shell (sh)
Bourne-Again shell (bash)
Boxx
BPEL - Business Process Execution Language
Brainfuck
BUGSYS
BuildProfessional
BYOND

C

C
C--
C-script
C++
C#
C shell (csh)
Caché ObjectScript - See also Caché Basic
Caml
Cayenne
CeeBot
Cecil
Cesil
Cg
Chapel
CHAIN
Charity
Chey
CHILL
Chrome
ChucK
Cilk
CL
Clarion
Clean
Clipper
CLIST - Programming language for online applications in the MVS TSO environment
CLU
CMS-2
COBOL
CobolScript
Cocoa
CODE
ColdFusion
COMAL
Common Intermediate Language (CIL)
Common Lisp
Component Pascal
COMIT - List or string processing language
Concurrent Clean
Constraint Handling Rules
CORAL66
Corn
CorVision
COWSEL
CPL
CSP
Csound
Cue
Curl
Curry
Cyclone

D

D
DASL - Distributed Application Specification Language
DASL - Datapoint's Advanced Systems Language
Dark Basic
Dataflex
Datalog
dBASE
dc
Deesel (formerly G)
Dialect
DCL
Delphi
Dialog Manager
DIBOL
Dream Maker
Dylan


E

E
Ease
Easy PL/I
eC (Ecere C)
eDeveloper
Edinburgh IMP
Eiffel
Elan
elastiC
Elf
Emacs Lisp
Enterprise Generation Language (EGL)
Epigram
Erlang
Escapade - server-side programming
Esterel
Euclid
Euphoria
Euler
EXEC
EXEC2


F

F
F#
Factor
Falcon
Felix
Ferite
FL
FLOW-MATIC
FOCAL
FOCUS
FOIL
FORMAC
Formula language
Forth
Fortran
Fortress
FoxPro
FP
Franz Lisp
Frink
Frontier

G

Gambas
Game Maker Language
G-code
General Algebraic Modeling System
Generic Java
Gibiane
G (LabVIEW)
Gödel
Godiva
GOTRAN (see IBM 1620)
GPSS
Green
Groovy


H

H - Business processing language from NCR.
HAL/S - Real-time aerospace programming language
HAScript
Haskell
High Level Assembly (HLA)
Hoc
Hugo
HyperText Mark-up Language
HTML/OS


I

ICI programming language
Icon
IDL programming language
IMP
Inform
Information Processing Language (IPL)
Informix-4GL
INTERCAL
Io
IPTSCRAE


J

J
J#
J++
JADE
JAG
Jal
Janus
Java
JavaScript
JCL
JoeBASIC
Join Java
JOSS
Joule
JOVIAL
Joy
JScript
J2EE
J2ME

K

K
Kid's Programming Language (KPL)
Kiev
Kite
Kogut
KRC
KRYPTON


L

L
LabVIEW
Lagoona
LANSA
Lasso
Lava
Leda
Lead
Legoscript
Leopard
Lexico
Lfyre
Limbo
Limnor
LINC
Lingo
Lisaac
Lisp
Lite-C
Logo
LPC
LSL
LSE
Lua
Lucid
Lush
Lustre
LYaPAS


M

M4
MAD
MADCAP
MAGIC - See eDeveloper
Magma
MapBasic
Maple
MAPPER (Unisys/Sperry) now part of BIS
M-A-R-E-K (Programming language)
MARK-IV (Sterling/Informatics) now VISION:BUILDER of CA
Mary
Mathematica
Matlab
MATA
Maya
Mercury
Mesa
METAL
Michigan Algorithmic Decoder see MAD programming language
Microcode
MicroScript
MillScript
MIMIC
Mindscript
Miranda
Miva
ML
Moby
MODCAP
Model 204 User Language
Modula
Modula-2
Modula-3
Mondrian
Mortran
Moto
MOUSE
MSIL - Deprecated name for Common Intermediate Language
MUMPS


N

Napier88
Natural
Nemerle
NESL
Neuralware
NGL
Nial
Nice
Nickle
Nosica
NQC
Nu programming language

O

o:XML
Oberon
Objective Modula-2
Object Lisp
Object Pascal
Objective-C
Objective Caml
Obliq
occam
occam-π
Octave
OmniMark
Opal
Open programming language
OPS5
Organiser Programming Language (OPL) - cf. Psion Organiser
Oz

P

Parser
Pascal
Pawn
PBASIC
PEARL
Perl
Perl Data Language
Phoenix
PHP
Pico
Piet
Pike
Pikt
PILOT
Pizza
PL 11
PL/0
PL/8
PL/B
PL/C
PL/I
PL/M
PLD
PL/SQL
Plankalkül
Pliant
PPL
POP-11
Poplog
PORTRAN
PostScript
POV-Ray
Ppc++
Processing
Prograph
Progress 4GL
Prolog
Turbo Prolog
Promela
Proteus
Python


Q

Q
QuakeC
QPL
Quikcomp (for the Moonrobot XI)


R

R
R++ - Based on C++ and added semanteme description
Rascal
Ratfiv
Ratfor
RBScript
rc
REALbasic
REPL - Really Easy Programming Language
REBOL - Relative Expression Based Object Language
Red - Rejected prototype for Ada
Redcode
REDO
REFAL
Revolution
REXX
Rigal
Rlab
Robot Scripting Language (RSL)
RPG (Report Program Generator)
RPL
Ruby
RuneScript
Russell Programming Language

S

S
S2
S+(S-PLUS or S4)
S-Lang
SAIL
SAKO
SAM76
SAS
Sather
Scala
SCAR
Scheme
Script.NET
Sed
Seed7
Self
SETL
SIGNAL
SiMPLE
SIMPOL
SIMSCRIPT
Simula
SISAL
Slate
SLIP
SMALL Machine Algol Like Language
Small
Smalltalk
Snobol
SPITBOL
Snowball
SPARK
Spice
SPIN
SP/k
SPL/1 aka SPL/I
SPS (1620) see IBM 1620
Squeak
SR
SSL
Standard ML
Subtext
SuperCollider
Suneido
SYMPL
SyncCharts
Synergy/DE


T

T
TACL
TACPOL
TagsMe
TADS
Transaction Application Language
Tcl
Transact SQL
teco
TELCOMP
Telon
Tempo
Titanium
TI-Basic
Today
Tom
TOM
Topspeed see Clarion
TorqueScript
tpu
Trac
TTCN
Turing
TUTOR
Tutorial D
TXL


U

Ubercode
Ultra 32
Unicon
Uniface (programming language)
UnrealScript


V
Vala
Visual DataFlex
Visual DialogScript
Visual FoxPro
Visual Objects
VBScript
Visual Basic Visual Beginners All - purpose Symbolic Instruction Code
Visual Basic .NET

W

Water
WATFOR see WATFIV
WATFIV
WAXHTML
WebQL
Whitespace
Winbatch
WinDev
Windows PowerShell


X

X10
XBL
xbScript - Also xBaseScript
xHarbour
XL
XOTcl
XPL
XPL0
XQuery
XSLT - See XPath


Y

Y
YACC
YAFL
Yellow - Rejected prototype for Ada
Yorick


Z

Z++
Z notation - A program specification language, like UML.
ZPL
ZZT-oop
ZOPL
ZUG



0-9
1C products internal script
2.PAK
20-GATE
473L Query
51-FORTH

Hardware Description Language:-
In electronics, a hardware description language or HDL is any language from a class of computer languages for formal description of electronic circuits. It can describe the circuit's operation, its design and organization, and tests to verify its operation by means of simulation.

A Hardware Description Language (HDL) is a standard text-based expression of the temporal behaviour and/or (spatial) circuit structure of an electronic system. In contrast to a software programming language, an HDL's syntax and semantics include explicit notations for expressing time and concurrency which are the primary attributes of hardware. Languages whose only characteristic is to express circuit connectivity between a hierarchy of blocks are properly classified as netlist languages.

HDLs are used to write executable specifications of some piece of hardware. A simulation program, designed to implement the underlying semantics of the language statements, coupled with simulating the progress of time, provides the hardware designer with the ability to model a piece of hardware before it is created physically. It is this executability that gives the illusion of HDLs being a programming language. Simulators capable of supporting discrete event (digital), and continuous time (It is certainly possible to represent hardware semantics using traditional programming languages such as C++ (and augmented with extensive and unwieldy class libraries.) However, the C++ language does not include any capability for expressing time explicitly and consequently is not a proper hardware description language.

Using the proper subset of virtually any (hardware description or software programming) language, a software program called a synthesizer can infer hardware logic operations from the language statements and produce an equivalent netlist of generic hardware primitives to implement the specified behaviour. This typically (as of 2004) requires the synthesizer to ignore the expression of any timing constructs in the text. The ability to have a synthesizable subset of the language does not itself make a hardware description language.

Designing a system in HDL is generally much harder and more time consuming than writing a program that would do the same thing using a programming language like C. Consequently, there has been much work done on automatic conversion of C code into HDL, but this has not reached a high level of commercial success as of 2004.

History
The first hardware description languages have been ISP developed at Carnegie Mellon University, and KARL developed at University of Kaiserslautern, both around 1977. ISP was, however, more like a software programming language used to describe relations between the inputs and the outputs of the design. Therefore, it could be used to simulate the design, but not to synthesize it. But KARL has also included design calculus language features supporting VLSI chip floorplanning and Structured hardware design, also the basis of KARL's interactive graphic sister language ABL, having been implemented in the early 1980ies as the ABLED graphic VLSI design editor, by the telecommunication research center CSELT at Torino, Italy. Around the mid 80ies a VLSI design framework has been implemnted around KARL and ABL by an international consortium funded by the commission of the European Union (chapter in [1]). In 1983 Data-I/O introduced ABEL. It was targeted for describing programmable logical devices and was basically used to design finite state machines.

The first modern HDL, Verilog, was introduced by Gateway Design Automation in 1985. Cadence Design Systems later acquired the rights to Verilog-XL, the HDL-simulator which would become the de-facto standard (of Verilog simulators) for the next decade. In 1987, a request from the U.S. Department of Defense led to the development of VHDL (Very High Speed Integrated Circuit Hardware Description Language.) Initially, Verilog and VHDL were used to document and simulate circuit-designs already captured and described in another form (such as a schematic file.) HDL-simulation enabled engineers to work at a higher level of abstraction than simulation at the schematic-level, and thus increased design capacity from hundreds of transistor to thousands.

Design Using HDL
The vast majority of modern digital circuit-design revolves around an HDL-description of the desired circuit, device, or subsystem.

Most designs begin on traditional pencil and paper, as written set of requirements or a high-level architectural diagram. The process of writing the HDL-description is highly dependent on the designer's background and the circuit's nature. The HDL is merely the 'capture language' -- designers often begin with a high-level algorithmic description (such as MATLAB or a C++ mathematical model.) Control and decision structures are often prototyped in flowchart applications, or entered in a state-diagram editor. Designers even use scripting-languages (such as PERL) to auto-generate repetitive circuit-structures in the HDL language. Advanced text-editors (such as EMACS) offer an editor template to auto-indent, color-highlight syntax keywords, and macro-expand entity/architecture/signal declaration.

As the design's implementation is fleshed out, the HDL-code invariably must undergo code review (i.e. auditing.) In preparation for synthesis, the HDL-description is subject to an array of automated checkers. The checkers enforce standardized-code guidelines (to identify ambiguous code-constructs before they can cause mis-interpretation by downstream synthesis) and check for common logical-coding errors (such as dangling ports or shorted outputs.)

In industry parlance, HDL-design generally ends at the synthesis stage. Once the synthesis-tool has mapped the HDL-description into a gate-netlist, the netlist is passed off to the 'back-end' stage. Depending on the physical technology (FPGA vs ASIC gate-array vs ASIC standard-cell), HDLs may or may not play a significant role in the back-end flow. In general, as the design-flow progresses toward a physically realizeable form, the design-database becomes progressively more laden with technology-specific information, which cannot be stored in a generic HDL-description. The end result is a silicon chip that would be manufactured in a fab.

List Of Languages

* Advanced Boolean Expression Language (ABEL)
* AHDL (Altera HDL, a proprietary language from Altera)
* Atom (behavioral synthesis and high-level HDL based on Haskell)
* Bluespec (high-level HDL originally based on Haskell, now with a SystemVerilog syntax)
* Confluence (a functional HDL; has been discontinued)
* CUPL (a proprietary language from Logical Devices, Inc.)
* HDCaml (based on Objective Caml)
* Hardware Join Java (based on Join Java)
* HML (based on SML)
* Hydra (based on Haskell)
* JHDL (based on Java)
* Lava (based on Haskell)
* Lola (a simple language used for teaching)
* MyHDL (based on Python)
* PALASM (for Programmable Array Logic (PAL) devices)
* Ruby (hardware description language)
* RHDL (based on the Ruby programming language)
* CoWareC, a C-based HDL by CoWare. Now discontinued in favor of SystemC
* SystemVerilog, a superset of Verilog, with enhancements to address system-level design and verification
* SystemC, a standardized class of C++ libraries for high-level behavioral and transaction modeling of digital hardware at a high level of abstraction, i.e. system-level

HDL And Programming Language
An HDL is analogous to a software programming language, but with major differences. Programming languages are inherently procedural (single-threaded), with limited syntactical and semantic support to handle concurrency. HDLs, on the other hand, can model multiple parallel processes (such as flipflops, adders, etc.) that automatically execute independently of one another. Any change to the process's input automatically triggers an update in the simulator's process stack. Both programming languages and HDLs are processed by a compiler (usually called a synthesizer in the HDL case), but with different goals. For HDLs, 'compiler' refers to synthesis, a process of transforming the HDL code-listing into a physically-realizable gate netlist. The netlist-output can take any of many forms: a "simulation" netlist with gate-delay information, a "handoff" netlist for post-synthesis place&route, or a generic industry-standard EDIF format (for subsequent conversion to a JEDEC-format file.)

Design Using HDL
The vast majority of modern digital circuit-design revolves around an HDL-description of the desired circuit, device, or subsystem.

Most designs begin on traditional pencil and paper, as written set of requirements or a high-level architectural diagram. The process of writing the HDL-description is highly dependent on the designer's background and the circuit's nature. The HDL is merely the 'capture language' -- designers often begin with a high-level algorithmic description (such as MATLAB or a C++ mathematical model.) Control and decision structures are often prototyped in flowchart applications, or entered in a state-diagram editor. Designers even use scripting-languages (such as PERL) to auto-generate repetitive circuit-structures in the HDL language. Advanced text-editors (such as EMACS) offer an editor template to auto-indent, color-highlight syntax keywords, and macro-expand entity/architecture/signal declaration.

As the design's implementation is fleshed out, the HDL-code invariably must undergo code review (i.e. auditing.) In preparation for synthesis, the HDL-description is subject to an array of automated checkers. The checkers enforce standardized-code guidelines (to identify ambiguous code-constructs before they can cause mis-interpretation by downstream synthesis) and check for common logical-coding errors (such as dangling ports or shorted outputs.)

In industry parlance, HDL-design generally ends at the synthesis stage. Once the synthesis-tool has mapped the HDL-description into a gate-netlist, the netlist is passed off to the 'back-end' stage. Depending on the physical technology (FPGA vs ASIC gate-array vs ASIC standard-cell), HDLs may or may not play a significant role in the back-end flow. In general, as the design-flow progresses toward a physically realizeable form, the design-database becomes progressively more laden with technology-specific information, which cannot be stored in a generic HDL-description. The end result is a silicon chip that would be manufactured in a fab.

Visual Programming Language:-
A Visual programming language (VPL) is any programming language that lets users specify programs by manipulating program elements graphically rather than by specifying them textually. A VPL allows programming with visual expressions, spatial arrangements of text and graphic symbols. Most VPLs are based on the idea of "boxes and arrows," that is, boxes or circles or bubbles, treated as screen objects, connected by arrows, lines or arcs.

VPLs may be further classified, according to the type and extent of visual expression used, into icon-based languages, form-based languages, and diagram languages. Visual programming environments provide graphical or iconic elements which can be manipulated by users in an interactive way according to some specific spatial grammar for program construction.

A visually transformed language is a non-visual language with a superimposed visual representation. Naturally visual languages have an inherent visual expression for which there is no obvious textual equivalent.

Current developments try to integrate the visual programming approach with dataflow programming languages to either have immediate access to the program state resulting in online debugging or automatic program generation and documentation (i.e. visual paradigm)

List Of Visual Programming Language:-

* AgentSheets, easy to use game authoring and computational science authoring tool
* Alice
* Amiga Vision, multimedia authoring tool released by Commodore with Amiga A3000
* Analytica
* Automator
* Baltie
* CanDO multimedia authoring and application building tool for AmigaOS
* CODE
* DRAKON, a language designed for developing the Soviet Buran (spacecraft)
* Flow
* G, the language used in the LabVIEW development environment
* Hollywood Designer application building tool for AmigaOS, MorphOS and AROS
* jMax, a visual programming environment for building interactive, real-time music and multimedia applications.
* Labview
* Ladder logic, a language that simulates relay logic commonly used in Programmable logic controllers
* Lava
* Limnor
* Max/MSP
* Microsoft Visual Programming Language, dataflow language for Robotics programming that is a component of Microsoft Robotics Studio
* Mindscript, easy to use and understand multiple-purpose visual programming language
* nato.0+55+3d
* OpenMusic, a visual programming language for music composition (based on CLOS)
* Pipeline Pilot
* Prograph
* Pure Data
* Quartz Composer
* SCADE
* Scala Multimedia Authoring suite and complete multimedia system for AmigaOS and Windows
* Simulink
* Built on Squeak
* Etoys scripting
* Scratch
* Stagecast Creator, formerly Apple's Cocoa
* Subtext
* SynthMaker, an audio programming tool using a visual programming language
* Tersus
* ThingLab
* ToonTalk
* Turtle Art, a turtle graphics language for children on the OLPC XO-1
* VEE
* VisSim
* virtools
* WireFusion, a visual programming environment for creating interactive 3D web presentations.
* VVVV

Fourt Generation Language:-
A fourth-generation programming language (1970s-1990) (abbreviated 4GL) is a programming language or programming environment designed with a specific purpose in mind, such as the development of commercial business software. In the evolution of computing, the 4GL followed the 3GL in an upward trend toward higher abstraction and statement power. The 4GL was followed by efforts to define and use a 5GL.
The natural-language, block-structured mode of the third-generation programming languages improved the process of software development. However, 3GL development methods can be slow and error-prone. It became clear that some applications could be developed more rapidly by adding a higher-level programming language and methodology which would generate the equivalent of very complicated 3GL instructions with fewer errors. In some senses, software engineering arose to handle 3GL development. 4GL and 5GL projects are more oriented toward problem solving and systems engineering.
All 4GLs are designed to reduce programming effort, the time it takes to develop software, and the cost of software development. They are not always successful in this task, sometimes resulting in inelegant and unmaintainable code. However, given the right problem, the use of an appropriate 4GL can be spectacularly successful as was seen with MARK-IV and MAPPER (see History Section, Santa Fe real-time tracking of their freight cars - the productivity gains were estimated to be 8 times over COBOL). The usability improvements obtained by some 4GLs (and their environment) allowed better exploration for heuristic solutions than did the 3GL.

History
Though used earlier in papers and discussions, the term 4GL was first used formally by James Martin in his 1982 book Applications Development Without Programmers to refer to non-procedural, high-level specification languages. In some primitive way, IBM's RPG (1960) could be described as the first 4GL followed closely by others, such as the Informatics MARK-IV (1967) product and Sperry's MAPPER (1969 internal use, 1979 release).

The motivations for the '4GL' inception and continued interest are several. The term can apply to a large set of software products. It can also apply to an approach that looks for greater semantic properties and implementation power. Just as the 3GL offered greater power to the programmer, so too did the 4GL open up the development environment to a wider population.

In a sense, the 4GL is an example of 'black box' processing, each generation (in the sense of the page) is further from the machine (see the Computer Science history in regard to data structure improvements and information hiding). It is this latter nature that is directly associated with 4GL having errors that are harder, in many cases, to debug. In terms of applications, a 4GL could be business oriented or it could deal with some technical domain. Being further from the machine implies being closer to domain. Given the wide disparity of concepts and methods across domains, 4GL limitations lead to recognition of the need for the 5GL.

Types

* Report generators take a description of the data format and the report to generate and from that they either generate the required report directly or they generate a program to generate the report.
* Similarly, forms generators manage online interactions with the application system users or generate programs to do so.
* More ambitious 4GLs (sometimes termed fourth generation environments) attempt to automatically generate whole systems from the outputs of CASE tools, specifications of screens and reports, and possibly also the specification of some additional processing logic.
* Data management 4GLs such as SAS, SPSS and Stata provide sophisticated commands for data manipulation, file reshaping,case selection and data documentation in the preparation of data for statistical analysis and reporting.

Some 4GLs have integrated tools which allow for the easy specification of all the required information:

* James Martin's own Information Engineering systems development methodology was automated to allow the input of the results of system analysis and design in the form of data flow diagrams, entity relationship diagrams, entity life history diagrams etc from which hundreds of thousands of lines of COBOL would be generated overnight.
* More recently Oracle Corporation's Oracle Designer and Oracle Developer 4GL products could be integrated to produce database definitions and the forms and reports programs.

Some successful Fourth Generation Language

1) General Use / Versatile
SQLWindows/Team Developer
Forté TOOL (transactional object-oriented language)
SheerPower4GL (Microsoft Windows Only)
PowerBuilder
WinDev
DataFlex
Visual DataFlex (Microsoft Windows Only)

2) Database query languages
FOCUS
NATURAL
Informix-4GL
Genero
Progress 4GL
SQL
SB+/SystemBuilder

3) Report generators
Quest
Report Builder
BuildProfessional
GEMBase
IDL-PV/WAVE
LINC
Metafont
NATURAL
Oracle Reports
PostScript
Progress 4GL Query/Results
RPG-II
Gauss

4) Data manipulation, analysis, and reporting languages
Clarion Programming Language
Ab Initio
ABAP
ADS/Online (plus transaction processing)
Aubit-4GL
Audit Command Language
CorVision
CoSort SortCL
Culprit
DASL
FOCUS
Genero
GraphTalk
Informix-4GL
LANSA
Maple
MAPPER (Unisys/Sperry) now part of BIS
MARK-IV (Sterling/Informatics) now VISION:BUILDER of CA
Mathematica
MATLAB
NATURAL
Nomad
PL/SQL
Progress 4GL
PROIV
Ramis
S
SAS
SPSS
Stata
Synon
Xbase++
5) Data-stream languages
APE
AVS
Iris Explorer

6) Database driven GUI Application Development
Genexus
Progress Dynamics
UNIFACE
SB+/SystemBuilder

7) Screen painters and generators
FOURGEN CASE Tools for Rapid Application Development by Gillani
Genero Studio
Oracle Forms
Progress 4GL ProVision
Unify Accell
SB+/SystemBuilder

8) GUI creators
4th Dimension (Software)
eDeveloper
MATLAB's GUIDE
Omnis Studio
OpenROAD
Progress 4GL AppBuilder
Revolution programming language

9) Web development languagues
ColdFusion

Template Processor Language:-
A template processor (also known as a template engine or a template parser) is software or a software component that is designed to combine one or more templates with a data model to produce one or more result documents.For purposes of this article, a result document is any kind of formatted output, including documents, web pages, or source code, either in whole or in fragments.

System elements
All template processing systems consist of at least these primary elements:

* an associated data model;
* one or more source templates;
* a processor or template engine;
* generated output in the form of result documents.

Data model
This may be a relational database, a source file such as XML, an alternate format of flat file database, a spreadsheet or any of other various sources of preformatted data. Some template processing systems are limited in the types of data that can be used. Others are designed for maximum flexibility and allow many different types of data.

Source template
Source templates are traditionally specified:

* according to a pre-existing programming language;
* according to a specially-defined template language;
* according to the features of a hosting software application; or
* according to a hybrid combination of some or all of the above.

Template engine
The template engine is responsible for:

* connecting to the data model;
* processing the code specified in the source templates; and
* directing the output to a specific pipeline, text file, or stream

Uses
Template processing is used in various contexts for different purposes. The specific purpose is ordinarily contingent upon the software application or template engine in use. However, the flexibility of template processing systems often enables unconventional uses for purposes not originally intended by the original designer

Template engine
A template engine is a specific kind of template processing module that exhibits all of the major features of a modern programming language. The term template engine evolved as a generalized description of programming languages whose primary or exclusive purpose was to process templates and data to output text. The use of this term is most notably applied to web development using a web template system, and it is also applied to other contexts as well.

Document generation
Document generation frameworks typically use template processing as the central model for generating documents.

Source code generation
Source code generation tools support generation of source code (as the result documents) from abstract data models (e.g., UML, relational data, domain-specific enterprise data stores) for particular application domains, particular organizations, or in simplifying the production process for computer programmers.

Software functionality
A web template engine processes web templates and source data (typically from a relational database) to produce one or more output web pages or page fragments. It is ordinarily included as a part of a web template system or application framework. Currently, template processing software is most frequently used in the context of development for the web.

Comparison
XSLT is a template processing model designed by W3C. It is designed primarily for transformations on XML data (into web documents or other output).

Programming languages such as Perl, Python, Ruby, C, and Java support template processing either natively, or through add-on libraries and modules. JavaServer Pages,[5] and Active Server Pages[6] are examples of template engines designed specifically for web application development.

Moreover, template processing is sometimes included as a sub-feature of software packages like text editors, IDEs and relational database management systems

Benefits of using template engines

* encourages organization of source code into operationally-distinct layers (see e.g., MVC)
* enhances productivity by reducing unnecessary reproduction of effort
* enhances teamwork by allowing separation of work based on skill-set (e.g., artistic vs. technical)

Transformation Language:-
A transformation language is a computer language designed to transform some input text in a certain formal language into a modified output text that meets some specific goal.

Macro languages are a kind of transformation languages to transform a meta language into specific higher programming language like Java, C++, Fortran

In the Model Driven Engineering Technical Space, there are model transformation languages (MTLs), that take as input models conforming to a given metamodel and produce as output models conforming to a different metamodel. An example of such a language is the QVT OMG standard. There are also low-level languages such as the Lx family implemented by the bootstrapping method.
LX Transfprmation Language
The Lx transformation language set is a transformation language sequence currently consisting of five languages:
* L0 – the base language. This language is very simple, though functionally complete and practically usable.
* L0+ – L0 language supplemented with commands for metamodel processing.
Every next language is obtained by adding known constructs to the previous one
* L1 – L0 language supplemented with pattern definition facility
* L2 – L1 language supplemented with a foreach command
* L3 – L2 language supplemented with the traditional if-then-else statement
The L0 language may be considered as assembler for transformation languages. There is also a high-level graphical language built on upon Lx called MOLA .

There are a number of XML transformation languages. These include
XSLT,
XQuery,
STX, FXT,
XDuce,
CDuce,
HaXml,
XMLambda, and
FleXML.

Types Of Transformation language:-

1)XSLT transforms Language (Extensible Stylesheet Language Transformations):-
XSLT transforms an XML input document into a hierarchical result tree, which often is serialised as an XML instance (see figure).A transformation in the XSLT language is expressed as a well-formed XML document [XML] conforming to the Namespaces in XML Recommendation [XML Names], which may include both elements that are defined by XSLT and elements that are not defined by XSLT. XSLT-defined elements are distinguished by belonging to a specific XML namespace,which is referred to in this specification as the XSLT namespace.



2) XQuery Language
XQuery is a query language (with some programming language features) that is designed to query collections of XML data. It is semantically similar to SQL.
XQuery 1.0 was developed by the XML Query working group of the W3C. The work was closely coordinated with the development of XSLT 2.0 by the XSL Working Group; the two groups shared responsibility for XPath 2.0, which is a subset of XQuery 1.0. XQuery 1.0 became a W3C Recommendation on January 23, 2007.

3) STX
Streaming Transformations for XML (STX) is an XML transformation language intended as a high-speed, low memory consumption alternative to XSLT. STX is an XML standard for efficient processing of stream-based XML. As we will discover, XSLT is not well suited to stream based processing, and STX fills this niche.

4)FXT
FXT (Functional XML Transformation Tool) is an XML transformation language.

5) XDuce
XDuceis an XML transformation language.

6) CDuce
CDuce is an XML-oriented functional language, which extends XDuce in a few directions. It features XML regular expression types, XML regular expression patterns, XML iterators. CDuce is not strictly speaking an XML transformation language since it can be used for general-purpose programming.
CDuce conforms to basic standards: Unicode, XML, DTD, Namespaces are fully supported, XML Schema is partially supported.

7) HaXml
HaXml is a collection of utilities for parsing, filtering, transforming, and generating XML documents using Haskell. Its basic facilities include:

* a parser for XML,
* a separate error-correcting parser for HTML,
* an XML validator,
* pretty-printers for XML and HTML.

8) XML
An XML transformation language is a computer language designed specifically to transform an input XML document into an output XML document which satisfies some specific goal.

There are two special cases of transformation:

* XML to XML : the output document is an XML document.
* XML to Data : the output document is a byte stream.

9)FleXML
FleXML is an XML transformation language originally developed by Kristofer Rose. It allows a programmer to specify actions in C programming language or C++, and associate those actions with element definitions in an XML DTD. It is similar in philosophy to Yacc and the Lex programming tool in that it is a syntax-directed driver; one could establish the analogies Yacc:LR(1) grammar::Lex:Regular grammar::FleXML::XML.

The implementation is in Perl. A programmer supplied action file is input to FleXML; the output is a file suitable for input to Flex lexical analyser.

TYPES Of Mark Up Langugae:-

Tex
Another major publishing standard is TeX, created and continuously refined by Donald Knuth in the 1970s and 80s. TeX concentrated on detailed layout of text and font descriptions in order to typeset mathematical books in professional quality. This required Knuth to spend considerable time investigating the art of typesetting.
Scribe
The first language to make a clear and clean distinction between structure and presentation was certainly Scribe, developed by Brian Reid and described in his doctoral thesis in 1980. Scribe was revolutionary in a number of ways, not least that it introduced the idea of styles separated from the marked up document, and of a grammar controlling the usage of descriptive elements. Scribe influenced the development of Generalized Markup Language (later SGML) and is a direct ancestor to HTML and LaTeX.

GML
In the early 1980s, the idea that markup should be focused on the structural aspects of a document and leave the visual presentation of that structure to the interpreter led to the creation of SGML. The language was developed by a committee chaired by Goldfarb. It incorporated ideas from many different sources, including Tunnicliffe's project, GenCode. Sharon Adler, Anders Berglund, and James A. Marke were also key members of the SGML committee.

SGML
SGML specified a syntax for including the markup in documents, as well as one for separately describing what tags were allowed, and where (the Document Type Definition (DTD) or schema). This allowed authors to create and use any markup they wished, selecting tags that made the most sense to them and were named in their own natural languages. Thus, SGML is properly a meta-language, and many particular markup languages are derived from it. From the late 80s on, most substantial new markup languages have been based on SGML system, including for example TEI and DocBook. SGML was promulgated as an International Standard by International Organization for Standardization, ISO 8879, in 1986.

HTML
By 1991, it appeared to many that SGML would be limited to commercial and data-based applications while WYSIWYG tools (which stored documents in proprietary binary formats) would suffice for other document processing applications.

The situation changed when Sir Tim Berners-Lee, learning of SGML from co-worker Anders Berglund and others at CERN, used SGML syntax to create HTML. HTML resembles other SGML-based tag languages, although it began as simpler than most and a formal DTD was not developed until later. DeRose argues that HTML's use of descriptive markup (and SGML in particular) was a major factor in the success of the Web, because of the flexibility and extensibility that it enabled (other factors include the notion of URLs and the free distribution of browsers). HTML is quite likely the most used markup language in the world today.

XML
Another, newer, markup language that is now widely used is XML (Extensible Markup Language). XML was developed by the World Wide Web Consortium, in a committee created and chaired by Jon Bosak. The main purpose of XML was to simplify SGML by focusing on a particular problem — documents on the Internet. XML remains a meta-language like SGML, allowing users to create any tags needed (hence "extensible") and then describing those tags and their permitted uses.

XML adoption was helped because every XML document can also be written in such a way that it is also an SGML document, and existing SGML users and software could switch to XML fairly easily. However, XML eliminated many of the more complex and human-oriented features of SGML to simplify implementation (while increasing markup size and reducing readability and editability). Other improvements rectified some SGML problems in international settings, and made it possible to parse and interpret document hierarchy even if no DTC is available.

XHTML
Since January 2000 all W3C Recommendations for HTML have been based on XML rather than SGML, using the abbreviation XHTML (Extensible HyperText Markup Language). The language specification requires that XHTML Web documents must be well-formed XML documents – this allows for more rigorous and robust documents while using tags familiar from HTML.

Difference Between HTML and XHTML
One of the most noticeable differences between HTML and XHTML is the rule that all tags must be closed: empty HTML tags such as
must either be closed with a regular end-tag, or replaced by a special form:
(the space before the '/' on the end tag is optional, but frequently used because it enables some pre-XML Web browsers, and SGML parsers, to accept the tag). Another is that all attribute values in tags must be quoted. Finally, all tag and attribute names must be lowercase in order to be valid; HTML, on the other hand, was case-insensitive.

Feartures
A common feature of many markup languages is that they intermix the text of a document with markup instructions in the same data stream or file. This is not necessary; it is possible to isolate markup from text content, using pointers, offsets, IDs, or other methods to co-ordinate the two. Such "standoff markup" is typical for the internal representations programs use to work with marked-up documents. However, embedded or "inline" markup is much more common elsewhere. Here, for example, is a small section of text marked up in HTML:

Uses And Applications
While the idea of markup language originated with text documents, there is an increasing usage of markup languages in areas like
1) vector graphics
2) web services
3) content syndication 4)
user interfaces.
Most of these are XML applications because it is a well-defined and extensible language. The use of XML has also led to the possibility of combining multiple markup languages into a single profile, like XHTML+SMIL and XHTML+MathML+SVG

Markup Language:-
A markup language provides a way to combine a text and extra information about it. The extra information, including structure, layout, or other information, is expressed using markup, which is typically intermingled with the primary text. The best-known markup language in modern use is HTML (HyperText Markup Language), one of the foundations of the World Wide Web. Originally markup was used in the publishing industry in the communication of printed work between authors, editors, and printers.
The term markup is derived from the traditional publishing practice of "marking up" a manuscript, that is, adding symbolic printer's instructions in the margins of a paper manuscript. For centuries, this task was done by proofreaders who marked up text to indicate what typeface, style, and size should be applied to each part, and then handed off the manuscript to someone else for the tedious task of typesetting by hand. A familiar example of manual markup symbols still in use is proofreader's marks, which are a subset of larger vocabularies of handwritten markup symbols.

GenCode
The idea of markup languages was apparently first presented by publishing executive William W. Tunnicliffe at a conference in 1967, although he preferred to call it "generic coding." Tunnicliffe would later lead the development of a standard called GenCode for the publishing industry. Book designer Stanley Fish also published speculation along similar lines in the late 1960s. Brian Reid, in his 1980 dissertation at Carnegie Mellon University, developed the theory and a working implementation of descriptive markup in actual use. However, IBM researcher Charles Goldfarb is more commonly seen today as the "father" of markup languages, because of his work on IBM GML, and then as chair of the International Organization for Standardization committee that developed SGML, the first widely used descriptive markup system. Goldfarb hit upon the basic idea while working on an early project to help a newspaper computerize its work flow, although the published record does not clarify when. He later became familiar with the work of Tunnicliffe and Fish, and heard an early talk by Reid which further sparked his interest.

History
It must be noted that the details of the early history of descriptive markup languages are hotly debated. However, it is clear that the notion was independently discovered several times throughout the 70s (and possibly the late 60s), and became an important practice in the late 80s.

Query Language
Query languages are computer languages used to make queries into databases and information systems.
Broadly, query languages can be classified according to whether they are database query languages or information retrieval query languages.

Examples include:

* .QL is a proprietary object-oriented query language for querying relational databases;
* Common Query Language (CQL) a formal language for representing queries to information retrieval systems such as as web indexes or bibliographic catalogues.
* CODASYL;
* D is a query language for truly relational database management systems (TRDBMS);
* DMX is a query language for Data Mining models;
* Datalog is a query language for deductive databases;
* ERROL is a query language over the Entity-relationship model (ERM), especially tailored for relational databases;
* FQL Facebook query language: SQL-like;
* Gellish English is a language that can be used for queries in Gellish English Databases [1], for dialogues (requests and responses) as well as for information modeling and knowledge modeling;
* ISBL is a query language for PRTV, one of the earliest relational database management systems;
* MQL is a cheminformatics query language for a substructure search allowing beside nominal properties also numerical properties;
* MDX is a query language for OLAP databases;
* OQL is Object Query Language;
* OPath, intended for use in querying WinFS Stores;
* Poliqarp Query Language is a special query language designed to analyze annotated text. Used in the Poliqarp search engine;
* QUEL is a relational database access language, similar in most ways to SQL;
* SMARTS is the cheminformatics standard for a substructure search;
* SPARQL is a query language for RDF graphs;
* SQL is a well known query language for relational databases;
* SuprTool is a proprietary query language for SuprTool, a database access program used for accessing data in Image/SQL (TurboIMAGE) and Oracle databases;
* XQuery is a query language for XML data sources;

History Of query Language:-

Byte Code:-
Bytecode is a binary representation of an executable program designed to be executed by a virtual machine rather than by dedicated hardware. Since it is processed by software, it is usually more abstract than machine code. Different parts of a program are often stored in separate files, similar to object modules.
Bytecode is called so because, historically, most instruction sets had one-byte opcodes, followed by zero or more parameters such as registers or memory address. It is a form of output code used by programming language implementations to reduce dependence on specific hardware (the same binary code can be executed across different platforms) and ease interpretation. After compiling to bytecode, the resulting output may be used as the input of a compiler targeting machine code, or executed directly on a virtual machine.
Compared to source code (intended to be human-readable), bytecodes are less abstract, more compact, and more computer-centric. For example, bytecodes encode the results of semantic analysis such as the scope of each variable access (that is, whether the variable is global or local). Thus, performance is usually better than interpretation of source code.

Execution:-
A bytecode program is normally executed by parsing the instructions one at a time. This kind of bytecode interpreter is very portable. Some systems, called dynamic translators, or "just-in-time" (JIT) compilers, translate bytecode into machine language as necessary at runtime: this makes the virtual machine unportable, but doesn't lose the portability of the bytecode itself. For example, Java and Smalltalk code is typically stored in bytecoded format, which is typically then JIT compiled to translate the bytecode to machine code before execution. This introduces a delay before a program is run, when bytecode is compiled to native machine code, but improves execution speed considerably compared to interpretation - normally by several times.

Because of its performance advantage, today many language implementations execute a program in two phases, first compiling the source code into bytecode, and then passing them to the virtual machine. Therefore, there are virtual machines for Java, Python, PHP[1], Forth, and Tcl. The current reference implementation of Perl and Ruby programming language instead resembles more that of an interpreter, since it works by walking the abstract syntax tree derived from the source code.

Examples

* O-code of the BCPL programming language
* p-code of UCSD Pascal implementation of the Pascal programming language
* Bytecodes of many implementations of the Smalltalk programming language
* Java bytecode, which is executed by the Java virtual machine
* ASM
* BCEL
* Javassist
* JMangler
* EiffelStudio for the Eiffel programming language
* Managed code such as Microsoft .NET Common Intermediate Language, executed by the .NET Common Language Runtime (CLR)
* Byte Code Engineering Library
* Scheme 48 implementation of Scheme using bytecode interpreter
* CLISP implementation of Common Lisp compiles only to bytecode
* CMUCL implementation of Common Lisp can compile either to bytecode or to native code; bytecode is much more compact
* Icon programming language
* Ocaml programming language optionally compiles to a compact bytecode form
* Parrot virtual machine
* YARV and Rubinius for Ruby.
* Infocom used the Z-machine to make its software applications more portable.
* C to Java Virtual Machine compilers
* SWEET16
* The SPIN interpreter built into the Parallax Propeller Microcontroller
* Adobe Flash objects

Machine Language:-
Machine code or machine language is a system of instructions and data directly executed by a computer's central processing unit. Machine code is the lowest-level of abstraction for representing a computer program.Instructions are patterns of bits with different patterns corresponding to different commands to the machine.

Machine Code Instructions:-
Every CPU model has its own machine code, or instruction set. Successor or derivative processor designs may completely include all the instructions of a predecessor and may add additional instructions. Some nearly completely compatible processor designs may have slightly different effects after similar instructions. Occasionally a successor processor design will discontinue or alter the meaning of a predecessor's instruction code, making migration of machine code between the two processors more difficult. Even if the same model of processor is used, two different systems may not run the same example of machine code if they differ in memory arrangement, operating system, or peripheral devices; the machine code has no embedded information about the configuration of the system.A machine code instruction set may have all instructions of the same length, or may have variable-length instructions.

Program:-
A program is a sequence of instructions that are executed by a CPU. While simple processors execute instructions one after the other, superscalar processors are capable of executing several instructions at once.
Program flow may be influenced by special 'jump' instructions that transfer execution to an instruction other than the following one. Conditional jumps are taken (execution continues at another address) or not (execution continues at the next instruction) depending on some condition.

Assembly Language:-
A much more readable rendition of machine language, called assembly language, uses mnemonic codes to refer to machine code instructions, rather than simply using the instructions' numeric values. For example, on the Zilog Z80 processor, the machine code 00000101, which causes the CPU to decrement the B processor register, would be represented in assembly language as DEC B.

Example
The MIPS architecture provides a specific example for a machine code whose instructions are always 32 bits long. The general type of instruction is given by the op (operation) field, the highest 6 bits. J-type (jump) and I-type (immediate) instructions are fully specified by op. R-type (register) instructions include an additional field funct to determine the exact operation. The fields used in these types are:

6 5 5 5 5 6 bits
[ op | rs | rt | rd |shamt| funct] R-type
[ op | rs | rt | address/immediate] I-type
[ op | target address ] J-type

rs, rt, and rd indicate register operands; shamt gives a shift amount; and the address or immediate fields contain an operand directly.

For example adding the registers 1 and 2 and placing the result in register 6 is encoded:

[ op | rs | rt | rd |shamt| funct]
0 1 2 6 0 32 decimal
000000 00001 00010 00110 00000 100000 binary

Load a value into register 8, taken from the memory cell 68 cells after the location listed in register 3:

[ op | rs | rt | address/immediate]
35 3 8 68 decimal
100011 00011 01000 00000 00001 000100 binary

Jumping to the address 1024:

[ op | target address ]
2 1024 decimal
000010 00000 00000 00000 00100 000000 binary

Specification Language:-
A specification language is a formal language used in computer science. Unlike most programming languages, which are directly executable formal languages used to implement a system, specification languages are used during system analysis, requirements analysis and design.
An example of a specification language is the Unified Modelling Language.

Specification languages are generally not directly executed. They describe the system at a much higher level than a programming language. Indeed, it is considered as an error if a requirement specification is cluttered with unnecessary implementation detail, because the specification is meant to describe the what, not the how.

A common fundamental assumption of many specification approaches is that programs are modelled as algebraic or model-theoretic structures that include a collection of sets of data values together with functions over those sets. This level of abstraction is commensurate with the view that the correctness of the input/output behaviour of a program takes precedence over all its other properties. In the property-oriented approach to specification (taken e.g. by CASL), specifications of programs consist mainly of logical axioms, usually in a logical system in which equality has a prominent role, describing the properties that the functions are required to satisfy - often just by their interrelationship. This is in contrast to so-called model-oriented specifications in frameworks like VDM and Z, which consist of a simple realization of the required behaviour.

Specifications must be subject to a process of refinement (the filling-in of implementation detail) before they can actually be implemented. The result of such a refinement process is an executable algorithm, which is either formulated in a programming language, or in an executable subset of the specification language at hand. For example, Hartmann pipelines, when properly applied, may be considered a dataflow specification which is directly executable. Another example is the Actor model which has no specific application content and must be specialized to be executable.

An important use of specification languages is enabling the creation of proofs of program correctness (see theorem prover)

Types Of Specification Language:-
1) Formal Specification
2) Language independent Specification

1) Formal Specification:-
A formal specification is a mathematical description of software or hardware that may be used to develop an implementation. It describes what the system should do, not (necessarily) how the system should do it. Given such a specification, it is possible to use formal verification techniques to demonstrate that a candidate system design is correct with respect to the specification. This has the advantage that incorrect candidate system designs can be revised before a major investment has been made in actually implementing the design. An alternative approach is to use provably correct refinement steps to transform a specification into a design, and ultimately into an actual implementation, that is correct by construction.
It is important to note that a design (or implementation) cannot ever be declared “correct” in isolation, but only “correct with respect to a given specification”. Whether the formal specification correctly describes the problem to be solved is a separate issue. It is also a difficult issue to address, since it ultimately concerns the problem constructing abstracted formal representations of an informal concrete problem domain, and such an abstraction step is not amenable to formal proof. However, it is possible to validate a specification by proving “challenge” theorems concerning properties that the specification is expected to exhibit. If correct, these theorems reinforce the specifiers understanding of the specification and its relationship with the underlying problem domain. If not, the specification probably needs to be changed to better reflect the domain understanding of those involved with producing (and implementing) the specification.

Example
The Z notation is an example of a leading formal specification language. Others include the Specification Language(VDM-SL) of the Vienna Development Method and the Abstract Machine Notation (AMN) of the B-Method.

2) Language Independent Specification
A language-independent specification (LIS) is a programming language specification providing a common interface usable for defining semantics applicable toward arbitrary language bindings; in other words, LISs are language-agnostic. LISs also mitigate the risk that a certain language binding might reduce compatibility with other languages; an ideal LIS allows the language bindings to take advantage of features of a programming language uncompromisingly.

Scripting Languages:-
Scripting languages, also called script languages, are programming languages that control applications. Scripts are executed directly from their source code, which are generally text files containing language specific markup. Thus, "scripts" are often treated as distinct from "programs", which execute independently from any other application.
The name "script" is derived from the written script of the performing arts, in which dialogue is set down to be spoken by human actors. Early script languages were often called batch languages or job control languages. Such early scripting languages were created to shorten the traditional edit-compile-link-run.
Types of scripting languages

1) Job control languages and shells

2) GUI Scripting

3) Application-specific languages

4) Web browser

5) Text processing languages

6) General-purpose dynamic languages

7) Extension/embeddable languages

In Detail Explanation:-

1) Job control languages and shells

A major class of scripting languages has grown out of the automation of job control, which relates to starting and controlling the behavior of system programs. Many of these languages' interpreters double as command line interfaces such as the Unix shell or the MS-DOS COMMAND.COM. Others, such as AppleScript, add scripting capability to computing environments lacking a command-line interface. Following are the examples

* 4NT
* AppleScript
* ARexx (Amiga Rexx)
* bash
* csh
* Ch (C Compatible shell)
* DCL (on OpenVMS)
* JCL
* JScript via Windows Script Host
* ksh
* cmd.exe (Windows NT, Windows CE, OS/2)
* COMMAND.COM (DOS, Windows 9x)
* REXX
* Macro Scheduler
* tcsh
* thinBasic
* sh
* VBScript via Windows Script Host
* Winbatch
* Windows PowerShell
* Windows Script Host
* zsh
* Jake

2) GUI Scripting

With the advent of Graphical user interfaces came a specialized kind of scripting language for controlling a computer. These languages interact with the same graphic windows, menus, buttons, and so on that a system generates. These languages are typically used to automate repetitive actions or configure a standard state. In principle, they could be used to control any application running on a GUI-based computer; but, in practice, the support for such languages depend on the application and operating system. Such languages are also called "macro languages" when control is through keyboard interaction

* AutoHotkey
* AutoIt
* Eggplant
* Expect
* thinBasic
* Automator

3) Application-specific languages

Many large application programs include an idiomatic scripting language tailored to the needs of the application user. Likewise, many computer game systems use a custom scripting language to express the programmed actions of non-player characters and the game environment. Languages of this sort are designed for a single application; and, while they may superficially resemble a specific general-purpose language (e.g. QuakeC, modeled after C), they have custom features that distinguish them.

* Action Code Script
* ActionScript
* AutoLISP
* BlobbieScript[1]
* Emacs Lisp
* Game Maker Language
* Hscript
* HyperTalk
* iMacros Web Browser Macro Language
* IPTSCRAE
* Linden Scripting Language
* Lingo
* LotusScript
* MATLAB
* MAXScript
* Maya Embedded Language
* mIRC Scripting Language
* NWscript
* Rhinoscript
* QuakeC
* UnrealScript
* Vim Scripting Language
* Visual Basic for Applications
* ZZT-oop

4) Web browser

An important type of application-specific scripting language is one used to provide custom functionality to web pages.

* JavaScript
* JScript
* VBScript
* Tcl

5) Text processing languages

The processing of text-based records is one of the oldest uses of scripting languages. Many, such as Unix's awk and, later, Perl, were originally designed to aid system administrators in automating tasks that involved Unix text-based configuration and log files. Perl is a special case -- originally intended as a report-generation language, it has grown into a full-fledged applications language in its own right.

* AWK
* Perl
* sed
* XSLT

6) General-purpose dynamic languages

Some languages, such as Perl, began as scripting languages but were developed into programming languages suitable for broader purposes. Other similar languages -- frequently interpreted, memory-managed, or dynamic -- have been described as "scripting languages" for these similarities, even if they are more commonly used for applications programming. They are usually not called "scripting languages" by their own users.

* APL
* Boo
* Dylan
* Ferite
* Groovy
* Io
* Lisp
* Lua
* MUMPS (M)
* newLISP
* Nuva
* Perl
* PHP
* Python
* Ruby
* S-Lang
* Script.NET
* Scheme
* Smalltalk
* SuperCard
* Tcl (Tool command language)
* thinBasic
* Revolution

7) Extension/embeddable languages

A number of languages have been designed for the purpose of replacing application-specific scripting languages by being embeddable in application programs. The application programmer (working in C or another systems language) includes "hooks" where the scripting language can control the application. These languages serve the same purpose as application-specific extension languages but with the advantage of allowing some transfer of skills from application to application.

* Ch (C/C++ interpreter)
* ECMAScript a.k.a. DMDScript, JavaScript, JScript
* EOS Scripting Language
* Falcon
* Ferite
* GameMonkeyScript
* Guile
* ICI
* Lua
* Pawn
* Python
* RBScript (REALbasic Script)
* S-Lang
* Squirrel
* Tcl
* Windows PowerShell
* Z-Script