Over the last couple of years, people have become progressively
unhappy with the term "scripting" language. For a while "agile"
language seemed like a comer, but I think that "dynamic" language is
now turning out to be the preferred term. See David Asher's really
excellent paper on dynamic languages at
http://activestate.com/Corporate/Publications/ActiveState_Dynamic_Languages.pdf
Recently, my group needed to write a document containing
recommendations for standard "scripting" languages. But we changed
that to recommendations for "dynamic" languages.
This is from the "Background" section of that document.
===============================================
Dynamic languages have existed (under a variety of labels: command
language, scripting language, glue language, macro language) as long
as there have been computer operating systems and programming
languages. Every operating system needs a way to tell it to perform
basic operations such as running application programs, copying and
deleting files, and so on. This was the function of the first
generation of dynamic languages, usually called command languages.
The category of "command languages" includes JCL, cmd files, CLISTS,
and REXX on IBM systems; batch files on MS-DOS; and shell scripting
languages on UNIX. These languages had very limited feature sets, and
developers quickly found that they needed more powerful languages.
Command languages evolved into a second generation of languages,
generally called scripting languages or glue languages (because they
were typically used to "script" or "glue" application programs
together to perform business functions). Scripting languages added
support for variables, control-flow constructs, and parameterized
functions. Although scripting languages were an improvement over the
earlier command languages, they still had significant limitations.
Most lacked object-oriented and modularization features, and
capabilities for accessing databases and managing graphical user
interfaces (GUIs). They were typically proprietary and restricted to a
particular operating system, which limited portability and
shareability.
Scripting languages continued to evolve, producing a third generation
of extremely powerful languages that incorporated a number of
important technical advances: support for modularization,
object-orientation, GUIs, and database access. With these advances,
these languages became powerful enough for application development as
well as scripting, and developers began to use them to build mid-sized
and even large-scale applications. The term "scripting language" –
which no longer describes the paradigmatic use for these languages –
is gradually being superceded by the term dynamic language. The
technical definition of a dynamic language is a language that uses
dynamic typing rather than static typing. In a statically-typed
language, the type of a variable (e.g. string, integer) must be
declared before the variable can be used. In a dynamically-typed
language, variables do not need to be declared; a variable acquires
its type via an assignment statement, and its type may change during
the execution of the program.