Scripting language - Wikipedia https://en.wikipedia.

org/wiki/Scripting_language

Scripting language
A scripting language or script language is a programming language for a runtime system that automates the
execution of tasks that would otherwise be performed individually by a human operator.[1] Scripting
languages are usually interpreted at runtime rather than compiled.

A scripting language's primitives are usually elementary tasks or API calls, and the scripting language allows
them to be combined into more programs. Environments that can be automated through scripting include
application softwares, text editors, web pages, operating system shells, embedded systems, and computer
games. A scripting language can be viewed as a domain-specific language for a particular environment; in the
case of scripting an application, it is also known as an extension language. Scripting languages are also
sometimes referred to as very high-level programming languages, as they sometimes operate at a high level of
abstraction, or as control languages, particularly for job control languages on mainframes.

The term "scripting language" is also used loosely to refer to dynamic high-level general-purpose interpreted
languages, such as Perl,[2] PowerShell, Python, and Tcl,[3] with the term "script" often used for small
programs (up to a few thousand lines of code) in such languages, or in domain-specific languages such as the
text-processing languages sed and AWK. Some of these languages were originally developed for use within a
particular environment, and later developed into portable domain-specific or general-purpose languages.
Conversely, many general-purpose languages have dialects that are used as scripting languages. This article
discusses scripting languages in the narrow sense of languages for a specific environment.

The spectrum of scripting languages ranges from very small and highly domain-specific languages to general-
purpose programming languages used for scripting. Standard examples of scripting languages for specific
environments include: Bash, for the Unix or Unix-like operating systems; ECMAScript (JavaScript), for web
browsers; and Visual Basic for Applications, for Microsoft Office applications. Lua is a language designed
and widely used as an extension language. Perl is a general-purpose language that is also commonly used as
an extension language, while ECMAScript is still primarily a scripting language for web browsers, but is also
used as a general-purpose language. The Emacs Lisp dialect of Lisp (for the Emacs editor) and the Visual
Basic for Applications dialect of Visual Basic are examples of scripting language dialects of general-purpose
languages. Some game systems, notably the Second Life virtual world and the Trainz franchise of Railroad
simulators have been extensively extended in functionality by scripting extensions (Linden Scripting
Language and TrainzScript). In other games like Wesnoth, the variety of actual games played by players are
scripts written by other users.

Contents
Characteristics
History
Types
Glue languages
Editor languages
Job control languages and shells
GUI scripting
Application-specific languages
Extension/embeddable languages

1 of 8 7/2/21, 17:35
Scripting language - Wikipedia https://en.wikipedia.org/wiki/Scripting_language

See also
References
Further reading
External links

Characteristics
Typical scripting languages are intended to be very fast to learn and write in, either as short source code files
or interactively in a read–eval–print loop (REPL, language shell).[4] This generally implies relatively simple
syntax and semantics; typically a "script" (code written in the scripting language) is executed from start to
finish, as a "script", with no explicit entry point.

For example, it is uncommon to characterise Java as a scripting language because of its lengthy syntax and
rules about which classes exist in which files, and it is not directly possible to execute Java interactively,
because source files can only contain definitions that must be invoked externally by a host application or
application launcher.

public class HelloWorld {

public void printHelloWorld() {
System.out.println("Hello World");
}
}

This piece of code intended to print "Hello World" does nothing as main() is not declared in HelloWorld
class, although the one below would be useful.

public class HelloWorld {

public void printHelloWorld() {
System.out.println("Hello World");
}
public static void main(String[] args) {
printHelloWorld();
}
}

In the example above, main is defined and so this can be invoked by the launcher, although this still cannot be
executed interactively. In contrast, Python allows the definition of some functions in a single file, or to avoid
functions altogether and use imperative programming style, or even use it interactively.

print("Hello World")
print "Hello World" # Python 2.7 or earlier

This one line of Python code prints "Hello World"; no declarative statement like main() is required here.

A scripting language is usually interpreted from source code or bytecode.[5] By contrast, the software
environment (interpreter) the scripts are written for is typically written in a compiled language and
distributed in machine code form.

Scripting languages may be designed for use by end users of a program—end-user development—or may be
only for internal use by developers, so they can write portions of the program in the scripting language.
Scripting languages typically use abstraction, a form of information hiding, to spare users the details of
internal variable types, data storage, and memory management.

2 of 8 7/2/21, 17:35
Scripting language - Wikipedia https://en.wikipedia.org/wiki/Scripting_language

Scripts are often created or modified by the person executing them,[6] but they are also often distributed, such
as when large portions of games are written in a scripting language, notably the Google Chrome T-rex game.

History
Early mainframe computers (in the 1950s) were non-interactive, instead using batch processing. IBM's Job
Control Language (JCL) is the archetype of languages used to control batch processing.[7]

The first interactive shells were developed in the 1960s to enable remote operation of the first time-sharing
systems, and these used shell scripts, which controlled running computer programs within a computer
program, the shell. Calvin Mooers in his TRAC language is generally credited with inventing command
substitution, the ability to embed commands in scripts that when interpreted insert a character string into the
script.[8] Multics calls these active functions.[9] Louis Pouzin wrote an early processor for command scripts
called RUNCOM for CTSS around 1964. Stuart Madnick at MIT wrote a scripting language for IBM's
CP/CMS in 1966. He originally called this processor COMMAND, later named EXEC.[10] Multics included
an offshoot of CTSS RUNCOM, also called RUNCOM.[11] EXEC was eventually replaced by EXEC 2 and
REXX.

Languages such as Tcl and Lua were specifically designed as general-purpose scripting languages that could
be embedded in any application. Other languages such as Visual Basic for Applications (VBA) provided
strong integration with the automation facilities of an underlying system. Embedding of such general-purpose
scripting languages instead of developing a new language for each application also had obvious benefits,
relieving the application developer of the need to code a language translator from scratch and allowing the
user to apply skills learned elsewhere.

Some software incorporates several different scripting languages. Modern web browsers typically provide a
language for writing extensions to the browser itself, and several standard embedded languages for
controlling the browser, including JavaScript (a dialect of ECMAScript) or XUL.

Types
Scripting languages can be categorized into several different types, with a considerable degree of overlap
among the types.

Glue languages
Scripting is often contrasted with system programming, as in Ousterhout's dichotomy or "programming in the
large and programming in the small". In this view, scripting is glue code, connecting software components,
and a language specialized for this purpose is a glue language. Pipelines and shell scripting are archetypal
examples of glue languages, and Perl was initially developed to fill this same role. Web development can be
considered a use of glue languages, interfacing between a database and web server. But if a substantial
amount of logic is written in script, it is better characterized as simply another software component, not
"glue".

Glue languages are especially useful for writing and maintaining:

custom commands for a command shell;

smaller programs than those that are better implemented in a compiled language;
"wrapper" programs for executables, like a batch file that moves or manipulates
files and does other things with the operating system before or after running an
application like a word processor, spreadsheet, data base, assembler, compiler,

3 of 8 7/2/21, 17:35
Scripting language - Wikipedia https://en.wikipedia.org/wiki/Scripting_language

etc.;
scripts that may change;
Rapid application development of a solution eventually implemented in another,
usually compiled, language.

Glue language examples:

AppleScript Perl (5 and Raku)

ColdFusion PHP
DCL PowerShell
Embeddable Common Lisp Pure
ecl Python
Erlang Rebol
EXEC Red
EXEC2 Rexx
JCL Ruby
CoffeeScript Scheme
Julia Tcl
JScript and JavaScript Unix Shell scripts (ksh, csh, bash, sh
Lua and others)
m4 VBScript
Modern Pascal Work Flow Language
XSLT

Macro languages exposed to operating system or application components can serve as glue languages. These
include Visual Basic for Applications, WordBasic, LotusScript, CorelScript (https://www.oberonplace.com/t
utor/page1.htm), Hummingbird Basic, QuickScript, Rexx, SaxBasic (https://msdn.microsoft.com/en-us/librar
y/ms994312.aspx), and WinWrap Basic. Other tools like AWK can also be considered glue languages, as can
any language implemented by a Windows Script Host engine (VBScript, JScript and VBA by default in
Windows and third-party engines including implementations of Rexx, Perl, Tcl, Python, XSLT, Ruby,
Modern Pascal, Delphi, and C). A majority of applications can access and use operating system components
via the object models or its own functions.

Other devices like programmable calculators may also have glue languages; the operating systems of PDAs
such as Windows CE may have available native or third-party macro tools that glue applications together, in
addition to implementations of common glue languages—including Windows NT, DOS, and some Unix
shells, Rexx, Modern Pascal, PHP, and Perl. Depending upon the OS version, WSH and the default script
engines (VBScript and JScript) are available.

Programmable calculators can be programmed in glue languages in three ways. For example, the Texas
Instruments TI-92, by factory default can be programmed with a command script language. Inclusion of the
scripting and glue language Lua in the TI-NSpire series of calculators could be seen as a successor to this.
The primary on-board high-level programming languages of most graphing calculators (most often Basic
variants, sometimes Lisp derivatives, and more uncommonly, C derivatives) in many cases can glue together
calculator functions—such as graphs, lists, matrices, etc. Third-party implementations of more
comprehensive Basic version that may be closer to variants listed as glue languages in this article are
available—and attempts to implement Perl, Rexx, or various operating system shells on the TI and HP
graphing calculators are also mentioned. PC-based C cross-compilers for some of the TI and HP machines
used with tools that convert between C and Perl, Rexx, AWK, and shell scripts to Perl, Modern Pascal,
VBScript to and from Perl make it possible to write a program in a glue language for eventual

4 of 8 7/2/21, 17:35
Scripting language - Wikipedia https://en.wikipedia.org/wiki/Scripting_language

implementation (as a compiled program) on the calculator.

Editor languages
A number of text editors support macros written either using a macro language built into the editor, e.g., The
SemWare Editor (TSE), vi improved (VIM), or using an external implementation, e.g., XEDIT, or both, e.g.,
KEDIT. Sometimes text editors and edit macros are used under the covers to provide other applications, e.g.,
FILELIST and RDRLIST in CMS .

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. (In this sense, one might think of shells as being
descendants of IBM's JCL, or Job Control Language, which was used for exactly this purpose.) Many of
these languages' interpreters double as command-line interpreters such as the Unix shell or the MS-DOS
COMMAND.COM. Others, such as AppleScript offer the use of English-like commands to build scripts.

GUI scripting
With the advent of graphical user interfaces, a specialized kind of scripting language emerged for controlling
a computer. These languages interact with the same graphic windows, menus, buttons, and so on, that a
human user would. They do this by simulating the actions of a user. These languages are typically used to
automate user actions. Such languages are also called "macros" when control is through simulated key
presses or mouse clicks, as well as tapping or pressing on a touch-activated screen.

These languages could in principle be used to control any GUI application; but, in practice their use is
limited because their use needs support from the application and from the operating system. There are a few
exceptions to this limitation. Some GUI scripting languages are based on recognizing graphical objects from
their display screen pixels. These GUI scripting languages do not depend on support from the operating
system or application.

When the GUI provides the appropriate interfaces, as in the IBM Workplace Shell, a generic scripting
language, e.g. OREXX, can be used for writing GUI scripts.

Application-specific languages
Application specific languages can be split in many different categories, i.e. standalone based app languages
(executable) or internal application specific languages (postscript, xml, gscript as some of the widely
distributed scripts, respectively implemented by Adobe, MS and Google) among others 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. Emacs Lisp, while a fully formed and capable dialect of Lisp, contains many special
features that make it most useful for extending the editing functions of Emacs. An application-specific
scripting language can be viewed as a domain-specific programming language specialized to a single
application.

Extension/embeddable languages

5 of 8 7/2/21, 17:35
Scripting language - Wikipedia https://en.wikipedia.org/wiki/Scripting_language

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 may be technically equivalent to an application-specific extension language but when an
application embeds a "common" language, the user gets the advantage of being able to transfer skills from
application to application. A more generic alternative is simply to provide a library (often a C library) that a
general-purpose language can use to control the application, without modifying the language for the specific
domain.

JavaScript began as and primarily still is a language for scripting inside web browsers; however, the
standardisation of the language as ECMAScript has made it popular as a general-purpose embeddable
language. In particular, the Mozilla implementation SpiderMonkey is embedded in several environments
such as the Yahoo! Widget Engine. Other applications embedding ECMAScript implementations include the
Adobe products Adobe Flash (ActionScript) and Adobe Acrobat (for scripting PDF files).

Tcl was created as an extension language but has come to be used more frequently as a general-purpose
language in roles similar to Python, Perl, and Ruby. On the other hand, Rexx was originally created as a job
control language, but is widely used as an extension language as well as a general-purpose language. Perl is a
general-purpose language, but had the Oraperl (1990) dialect, consisting of a Perl 4 binary with Oracle Call
Interface compiled in. This has however since been replaced by a library (Perl Module), DBD::Oracle (http
s://metacpan.org/module/DBD::Oracle).[12][13]

Other complex and task-oriented applications may incorporate and expose an embedded programming
language to allow their users more control and give them more functionality than can be available through a
user interface, no matter how sophisticated. For example, Autodesk Maya 3D authoring tools embed the
Maya Embedded Language, or Blender which uses Python to fill this role.

Some other types of applications that need faster feature addition or tweak-and-run cycles (e.g. game engines)
also use an embedded language. During the development, this allows them to prototype features faster and
tweak more freely, without the need for the user to have intimate knowledge of the inner workings of the
application or to rebuild it after each tweak (which can take a significant amount of time). The scripting
languages used for this purpose range from the more common and more famous Lua and Python to lesser-
known ones such as AngelScript and Squirrel.

Ch is another C compatible scripting option for the industry to embed into C/C++ application programs.

See also
List of scripting languages
Architecture description language
Authoring language
Build automation[14]
Configuration file
Interpreter directive / Shebang (Unix)
Templating language

References
1. "ECMAScript 2019 Language Specification" (https://tc39.github.io/ecma262/#sec-o
verview). www.ecma-international.org. Retrieved 2018-04-02.

6 of 8 7/2/21, 17:35
Scripting language - Wikipedia https://en.wikipedia.org/wiki/Scripting_language

2. Sheppard, Doug (2000-10-16). "Beginner's Introduction to Perl" (http://www.perl.co

m/pub/2000/10/begperl1.html). dev.perl.org. Retrieved 2011-01-08.
3. Programming is Hard, Let's Go Scripting… (http://www.perl.com/pub/2007/12/06/sot
o-11.html), Larry Wall, December 6, 2007
4. Hey, Tony; Pápay, Gyuri (2014). The Computing Universe: A Journey through a
Revolution. Cambridge University Press. p. 76 (https://books.google.com/books?id=
q4FIBQAAQBAJ&pg=PA76). ISBN 978-1-31612322-5, "A major characteristic of
modern scripting languages is their interactivity, sometimes referred to as a REPL
programming environment. […] The characteristics of ease of use and immediate
execution with a REPL environment are sometimes taken as the definition of a
scripting language."
5. Brown, Vicki. "Scripting Languages" (http://www.mactech.com/articles/mactech/Vol.
15/15.09/ScriptingLanguages/index.html). Retrieved 2009-07-22.
6. Loui, Ronald (2008). "In praise of scripting" (https://web.archive.org/web/20150923
211452/http://www.cse.wustl.edu/~loui/praiseieee.html#). IEEE Computer.
Archived from the original (http://www.cse.wustl.edu/~loui/praiseieee.html) on
2015-09-23. Retrieved 2013-08-27.
7. IBM Corporation (1967). IBM System/360 Operating System Job Control Language
(C28-6529-4) (http://www.bitsavers.org/pdf/ibm/360/os/R01-08/C28-6539-4_OS_JCL
_Mar67.pdf) (PDF).
8. Mooers, Calvin. "TRAC, A Procedure-Describing Language for the Reactive
Typewriter" (https://web.archive.org/web/20010425014914/http://tracfoundation.or
g/trac64/procedure.htm). Archived from the original (http://tracfoundation.org/trac6
4/procedure.htm) on 2001-04-25. Retrieved March 9, 2012.
9. Van Vleck, Thomas (ed.). "Multics Glossary – A — (active function)" (http://www.mul
ticians.org/mga.html). Retrieved March 9, 2012.
10. Varian, Melinda. "VM AND THE VM COMMUNITY: Past, Present, and Future" (http://w
eb.me.com/melinda.varian/Site/Melinda_Varians_Home_Page_files/neuvm.pdf)
(PDF). Retrieved March 9, 2012.
11. Van Vleck, Thomas (ed.). "Multics Glossary – R — (RUNCOM)" (http://www.multician
s.org/mgr.html#runcom). Retrieved March 9, 2012.
12. Oraperl (https://metacpan.org/module/Oraperl), CPAN]
13. Perl (http://www.orafaq.com/wiki/Perl), Underground Oracle FAQ
14. van Rossum, Guido (January 6–8, 1998). "Glue it all together" (https://www.python.
org/doc/essays/omg-darpa-mcc-position/). Glue It All Together With Python.
python.org.

Further reading
Barron, David William (2001). The World of Scripting Languages.
ISBN 0-471-99886-9.

External links
Patterns for Scripted Applications (https://web.archive.org/web/20041010125419/ht
tp://www.doc.ic.ac.uk/~np2/patterns/scripting/) at the Wayback Machine (archived
October 10, 2004)
Script (https://mihanscript.com)
Common Development Scenarios (http://www.modulusfe.com/products/trading-syst

7 of 8 7/2/21, 17:35
Scripting language - Wikipedia https://en.wikipedia.org/wiki/Scripting_language

em-developer-components/tradescript/)

Retrieved from "https://en.wikipedia.org/w/index.php?title=Scripting_language&oldid=1029590496"

This page was last edited on 20 June 2021, at 22:38 (UTC).

Text is available under the Creative Commons Attribution-ShareAlike License; additional terms may
apply. By using this site, you agree to the Terms of Use and Privacy Policy. Wikipedia® is a registered
trademark of the Wikimedia Foundation, Inc., a non-profit organization.

8 of 8 7/2/21, 17:35