By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
435,501 Members | 2,805 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 435,501 IT Pros & Developers. It's quick & easy.

Question about Python, more about clarity.

P: n/a
What I do not understand, or not clear to me I should say, is how can some
people regard Python as a scripting language? In particular the JAVA crowd.
Unless my understanding is off, and from what I can gather from googling, is
that Python is compiled implicitly into bytecode then read into the
interpreter, and in JAVA you must compile explicitly before it is
interpreted, both have virtual machines, so why such a label since there is
barely any variance?

I have been using Python for 3 years now, love it, and JAVA just a few
months (for school), and hate it. This is not a rant or anything, I just
want to clarify.

Any insight is greatly appreciated.

Adonis
Jul 18 '05 #1
Share this Question
Share on Google+
11 Replies


P: n/a
Adonis wrote:
What I do not understand, or not clear to me I should say, is how can some
people regard Python as a scripting language? In particular the JAVA crowd.
Unless my understanding is off, and from what I can gather from googling, is
that Python is compiled implicitly into bytecode then read into the
interpreter, and in JAVA you must compile explicitly before it is
interpreted, both have virtual machines, so why such a label since there is
barely any variance?


There have been many past discussions about this, and if you
search the archives you will surely find more than you care
to read about it. Any responses you receive here, including
mine, have been said before and probably more fully at that.

Summary: "scripting" means different things to different people,
and for several definitions of that Python _is_ a scripting
language. It's also a general purpose language, as is Java,
and can be used for a very wide range of purposes (and perhaps
even more widely than Java, but that's another debate). Some
people use "scripting" primarily in a derogatory sense, and
with such people involved it's sort of a pointless waste of
time to attempt to discuss this rational. In other words,
it becomes a matter of religion. ;-)

-Peter
Jul 18 '05 #2

P: n/a
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/Pub..._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.
Jul 18 '05 #3

P: n/a
Stephen Ferg <st***@ferg.org> wrote:
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


*WHOA*! This does REXX a great disservice -- it was an excellent VHLL,
in no way comparable to .BAT, JCL, or sh. I used it extensively for
prototyping general programs, focusing on text-processing, back when I
was in IBM Research -- and often found that I didn't need to rewrite the
prototype in (say) Pascal/VS or PL/I, because it already did the job
(much like APL for prototyping numerical/matrix computations: often I
_didn't_ need to rewrite the program in Fortran when it was done).

I could say that my love for VHLLs, eventually crowned by finding out
about Python, started in the early '80s with REXX -- it hurts to see it
impugned in this way!

((I've sent a copy of this to David by mail, just in case he wants to
enter this debate;-))
Alex
Jul 18 '05 #4

P: n/a
Alex Martelli wrote:
Stephen Ferg <st***@ferg.org> wrote:

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

*WHOA*! This does REXX a great disservice -- it was an excellent VHLL,
in no way comparable to .BAT, JCL, or sh. I used it extensively for
prototyping general programs, focusing on text-processing, back when I
was in IBM Research -- and often found that I didn't need to rewrite the
prototype in (say) Pascal/VS or PL/I, because it already did the job
(much like APL for prototyping numerical/matrix computations: often I
_didn't_ need to rewrite the program in Fortran when it was done).

I could say that my love for VHLLs, eventually crowned by finding out
about Python, started in the early '80s with REXX -- it hurts to see it
impugned in this way!

((I've sent a copy of this to David by mail, just in case he wants to
enter this debate;-))


Right -- just caught up. It took me a while to understand in Steven's
email that the extensive quote he inserts is from _his_ document, not
from mine. In other words, in:

"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."

_that_ refers to Steven's group's document, not to my paper.

FWIW, I am a big fan of REXX -- I used it extensively back in 86-90 on
IBM 3081/3090 mainframes. I learned a lot about programming through
REXX, and I've seen amazing things done with it. In fact I'd say that
REXX has all kinds of similarities with today's modern dynamic languages
-- e.g. while it wasn't open source, the source _was_ actually available
to IBM customers (i.e. the users), and people used to trade patches to
the source all the time, just like they traded patches to the various
layers of the OS (CP, CMS, etc.)

--david
Jul 18 '05 #5

P: n/a
"Adonis" <ad*****@DELETETHISTEXTearthlink.net> wrote in message news:<j8****************@newsread3.news.atl.earthl ink.net>...
What I do not understand, or not clear to me I should say, is how can some
people regard Python as a scripting language? In particular the JAVA crowd.
Unless my understanding is off, and from what I can gather from googling, is
that Python is compiled implicitly into bytecode then read into the
interpreter, and in JAVA you must compile explicitly before it is
interpreted, both have virtual machines, so why such a label since there is
barely any variance?

I have been using Python for 3 years now, love it, and JAVA just a few
months (for school), and hate it. This is not a rant or anything, I just
want to clarify.

Any insight is greatly appreciated.

Adonis


as a historical rule "scripting" languages were not stand-alone
general purpose languages, but languages that were used to "script" or
programatically control another program, they were historically very
specialized for the task at hand and not very useful in general
purpose programming because they were so vertically focused.

In the old ( 80's - 90's ) days each program might have its own
proprietary language. AutoCad, Microstation, all the Unix based 3D
animation packages had their own proprietary pet languages, most of
which were either Lisp or C syntax based and cryptic and extremely
limited in scope and scalablity.

This is what fostered the motivation behind languages such as Python
and Lua, generic general purpose embeddable languages.

Python and Lua both started out as "scripting" languages for scripting
C and then later C++ programs. As the years have passed more and more
"general purpose" additions to the core libraries have evolved Python
into a complete "batteries included" stand-alone general purpose
programming language.

There are efforts to supply the same general purpose core library code
for Lua and others.
Jul 18 '05 #6

P: n/a
al*****@yahoo.com (Alex Martelli) writes:
*WHOA*! This does REXX a great disservice -- it was an excellent VHLL,
in no way comparable to .BAT, JCL, or sh. I used it extensively for
prototyping general programs, focusing on text-processing, back when I
was in IBM Research -- and often found that I didn't need to rewrite the
prototype in (say) Pascal/VS or PL/I, because it already did the job
(much like APL for prototyping numerical/matrix computations: often I
_didn't_ need to rewrite the program in Fortran when it was done).


I totally agree - and in fact, I'd have to say REXX was my favorite
language prior to Python, although I've had far more opportunity to
apply Python to application domains than I did REXX. (Did have a
really cool chat utility XYZZY for anyone out there who remembers the
heydey of BITNET chatting with RELAY, and that was clearly an
application).

-- David
Jul 18 '05 #7

P: n/a
On Thursday 04 November 2004 08:16 am, Stephen Ferg wrote:
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.


"Dynamic" and "agile" to the uninitiated could mean just about
anything. They really smack of market-speak and imprecision.

I like "very-high level language" -- it emphasizes the progression
from assembly to "mid level" languages like C to "high level" languages
like FORTRAN, PASCAL, and perhaps Java to "very high level" languages
like Python, Perl, Ruby, etc. These represent a spectrum of tools
from those for very fine, painstaking work to those for rapid
prototyping -- and it also defuses some of the rivalry. After all,
no one thinks you should use a scalpel to cut down trees, or an
ax for knee-surgery.

Next, if we follow the TV/RF model, we'll need "ultra high level
languages" or UHLLs, and then "extreme high level languages" or
XHLL (in which you type in what your boss tells you and it produces
a whole application -- you know, like Star Trek).

Cheers,
Terry

--
Terry Hancock ( hancock at anansispaceworks.com )
Anansi Spaceworks http://www.anansispaceworks.com

Jul 18 '05 #8

P: n/a
Terry Hancock <ha*****@anansispaceworks.com> wrote:
On Thursday 04 November 2004 08:16 am, Stephen Ferg wrote:
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.
"Dynamic" and "agile" to the uninitiated could mean just about
anything. They really smack of market-speak and imprecision.


It doesn't take an Initiate today to google for a term to check if it's
got some connotation they weren't aware of. Google for agile and the
top hits, right after the firm of that name at agile.com, are
agilemanifesto.org, agilemodeling.com, agilealliance.org, a Martin
Fowler article on "The New Methodology", the Salt Lake City Agile
Development Conference 2004, the page on that great book "Agile database
technique", then after two hits for mobile-phone software, the page for
the Extreme Programming Agile Conference. Great track record even for
google -- 7 excellent directly relevant hits out of 10, and agile.com
might not be totally irrelevant either.

Face it, "Agile" as a term has been established by now, and any of these
7 relevant hits will explain what it means and how it contrasts with
more traditional heavyweight software development methodologies. Even
the uninitiated, admitting for the sake of argument they have a 3-digit
IQ, will get it.

Dynamic is an unfortunately much more popular term, 23 Mhits vs 1+ for
"agile", so there's not one relevant hit out of the top 10. It _is_ a
technically accurate term with a long history behind it, of course.
"Agile language" and "dynamic language" with quotes give results of far
better quality, but maybe it does take some savvy with google to think
of that;-).

I like "very-high level language" -- it emphasizes the progression


I like it too, it also has the advantage of making a typical cs'ish
acronym as "vhll" -- almost as popular as the full phrase on google.
Alex
Jul 18 '05 #9

P: n/a
David Ascher <Da****@ActiveState.com> writes:
Alex Martelli wrote:
FWIW, I am a big fan of REXX -- I used it extensively back in 86-90 on
IBM 3081/3090 mainframes. I learned a lot about programming through
REXX, and I've seen amazing things done with it. In fact I'd say that
REXX has all kinds of similarities with today's modern dynamic
languages -- e.g. while it wasn't open source, the source _was_
actually available to IBM customers (i.e. the users), and people used
to trade patches to the source all the time, just like they traded
patches to the various layers of the OS (CP, CMS, etc.)


Seee <URL: http://regina-rexx.sourceforge.net/ > for your open source
REXX. I quit following REXX when the talk of OO extensions was just
getting underway, so I don't know if the ANSI spec that regina
implements includes OO features or not.

FWIW, the Rexx implementation available for a Palm is much better than
the Python implementation on the same platform.

<mike
--
Mike Meyer <mw*@mired.org> http://www.mired.org/home/mwm/
Independent WWW/Perforce/FreeBSD/Unix consultant, email for more information.
Jul 18 '05 #10

P: n/a
st***@ferg.org (Stephen Ferg) writes:
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.


By this definition of "dynamic language", the first dynamic language
dates from the 60s, and has at least one feature that doesn't exist in
Python, Perl or TCL (though Perl 6 will have them): macros.

But someone sage once observed that all these new languages were
turning into "LISP with moby libraries".

<mike
--
Mike Meyer <mw*@mired.org> http://www.mired.org/home/mwm/
Independent WWW/Perforce/FreeBSD/Unix consultant, email for more information.
Jul 18 '05 #11

P: n/a
On Thu, 04 Nov 2004 21:43:01 -0600, Mike Meyer <mw*@mired.org> declaimed
the following in comp.lang.python:

Seee <URL: http://regina-rexx.sourceforge.net/ > for your open source
REXX. I quit following REXX when the talk of OO extensions was just
getting underway, so I don't know if the ANSI spec that regina
implements includes OO features or not.
No OO in the ANSI REXX that I know of.

However, IBM has recently turned ORexx over to the REXX LA
group, hypothetically making it open-source.

-- ================================================== ============ <
wl*****@ix.netcom.com | Wulfraed Dennis Lee Bieber KD6MOG <
wu******@dm.net | Bestiaria Support Staff <
================================================== ============ <
Home Page: <http://www.dm.net/~wulfraed/> <
Overflow Page: <http://wlfraed.home.netcom.com/> <

Jul 18 '05 #12

This discussion thread is closed

Replies have been disabled for this discussion.