vetinnocentSoftware and s/w Development

Nov 7, 2013 (5 years and 1 month ago)



CSC 415: Programming Languages

Jonathan Huelman


History of Python


By the 1980s, programming had become a distinct technical field. New languages were
being created and implemented to use conventions
defined in the previous decades. Instead of
coming up with new paradigms for imperative languages, developers were designing new and
effective elaborations on the concepts set forth by the earliest languages. C with classes (later
known simply as C++) was
breaking ground in object
orientation, and Modula, Ada, and ML
were developing note
worthy module systems to be used for large
scale organization.

In 1983, a man named Guido van Rossum landed a job at
Centrum voor Wiskunde en

, the nation
al research center for mathematics and computer science in the
Netherlands. Van Rossum was working as an implementer on a team that was creating a
language called ABC. Design and development of the language had started in the late 1970s and
their focus was

clear: they envisioned a programming language that could be taught to any
intelligent computer user who was not necessarily a programmer or a software developer. Their
main audience was the science
minded community, of course. Unfortunately for the ABC te
at CWI, the language never really got off of its feet. Van Rossum himself reasons that “
Maybe it
was too early, before there was an Internet to do efficient distribution.
” (Venners)

After working on ABC, in 1986, van Rossum worked on a distributed oper
ating system
known as Amoeba. In his development of the OS, he discovered that he would need a scripting
language. Based on his experience with ABC, using the parts he liked and discarding the things
he was never comfortable with, van Rossum structured the

scripting language to be easily
extendable, include modules, and to be easy to read and write.

It was in February 1991 that Guido van Rossum published the code as version 0.9.0 of
Python, a new programming language that he had named after the famous Brit
ish sketch comedy
Monty Python’s Flying Circus
. With the creation of a primary discussion forum in 1994
(alongside the release of Python 1.0), Python’s userbase grew exponentially, putting this little
known high
level scripting language on the map
for the first time.

By 1995, when van Rossum earned a job at the Corporation for National Research
Initiatives (CNRI) in Reston, Virginia, there had already been Python 1.1 and 1.2. While at
CNRI, van Rossum released several more versions, adding features

such as keyword arguments
and built
in support for complex numbers. It seemed that his initial goal, to “bridge the gap
between shell and C” (Venners, part II), was being reached tenfold.

With the advent of the Internet, distribution became easier and wr
iting implementations of
all of the protocols available could be done purely in Python. What van Rossum originally
intended to be a short
term, small
writing language began to be used for programs 500
lines and longer, and as people began to write
their own modules, Python set the stage for what
would become a large
scale user
defined platform with thousands upon thousands of resources

From, where the Python development team moved in 2000 and became
PythonLabs, they released V
ersion 2.0, a massive undertaking that included support for list
comprehension, garbage collection, and in 2.2, Python’s types and classes were unified, making
Python an entirely object
oriented language.

December 8, 2008 marked a change in Python

not o
nly in features, but in design and
philosophy. Because Python had accumulated so many redundant ways to do the same thing, the
newly released Python 3.0 focused on getting rid of all the duplicate constructs and modules, all
in an effort to keep its overal
l design philosophy intact. Unlike Perl, the open
source high
language designed by Larry Wall, who propagates that “there is more than one way to do it,”
Python sticks to a rigid idea that “There should be one

and preferably only one

obvious way to

do it.”


Since the release of Version 2.0, Python has quickly become the preferred programming
language of many famous and important companies and development teams. On the official
Python website,, there is a “Quotes” page where
certain industry leaders sound off
about how much they use and enjoy Python.

Cuong Do, a software architect at, says “
Python is fast enough for our site
and allows us to produce maintainable features in record times, with a minimum of develop

and Peter Norvig, the director of search quality at Google, Inc., explains that “
Python has been
an important part of Google since the beginning, and remains so as the system grows and
evolves. Today dozens of Google engineers use Python, and we're l
ooking for more people with
skills in this language.
” (

To say that Python has surpassed its original design is beyond understatement. What began
as a simple scripting language for use in an operating system aimed at people who were
with the ins and outs of programming has become a multifaceted, user
ingeniously basic programming language all its own, with users projected to number in the tens
of thousands ( Python has stepped forward as one of the most useful,
flexible, and
broad technical tools of this century, which is not to say that it is alone. In the world of computer
science today, with over 1,300 free
use specific languages available over the Internet, Python
certainly has a lot of competition, but th
e whole focus of the language, which is to make
programming as simple and non
specific as possible, seems to be diverting away from the notion
of competition between languages in favor of cooperation and interdependence.

Overview of Design, Syntax, and S

Influences of Other Languages

Because he was creating Python amidst a large boom of other programming languages,
Guido van Rossum’s approach to developing Python was to take the things he liked and to leave
behind the things that he did not like.

There were, of course, many similarities to ABC, but the
differences were notable: “
Python's lists, dictionaries, basic statements and use of indenta
differed from what ABC had,” van Rossum comments, and also in much simpler cases such as
deciding syn
tax: “
ABC used uppercase for keywords. I never got comfortable with the
uppercase, neither reading nor typing it, so in

Python keywords were lowercase.” (Venners, part

Python’s syntax was originally designed to be high

all keyword, data, and con
statement constructs would be as easy to distinguish and learn as possible. Again, Guido van
Rossum wanted to improve on ABC’s design. “
ABC had no concept of a standard library. It had
in commands, but the parser knew about them. It had built

functions that were very
much integrated in the runtime. Adding to the language's standard f
unctionality was very
difficult,” he explained to Bill Venners.

It is important to know two things about Python. First, it is strictly an interpreted language,
d second, there are thousands of components in its standard library that allow it to do
everything a scripting language should do in the one way that has been deemed best. This makes
it very powerful and very quick to learn. Eric Raymond writes in his Apri
l 2000 article, “Why
Python?”: “
My second
came a couple of hours into the project, when I noticed
(allowing for pauses needed to look up new features in
Programming Python
) I was generating

code nearly as fast as I could type. When I realized this, I was quite startled.
” He then
explains that sometimes programmers get a little ahead of themselves in coding, only to realize
later that what they are asking is impossible, and when this does not

happen to you a lot when
you first start with a language, it feels like you’ve mastered it immediately.

The fact that Python is interpreted makes it possible to have a simple command
window open up (called “python”) where one can type commands in a
nd have the interpreter put
them together as you type, instead of having to type a whole program, compile it, and run it. For
example, typing in

>>> the_world_is_flat = 1

>>> if the_world_is_flat:

... print "Be careful not to fall off!"


Produces th
e output

Be careful not to fall off!

Showing that control statements can even be evaluated using the “...” continuation line indicator
(which you can produce by pressing Shift + Enter).

Names, Bindings, and Scope

Names (or
) in Python follow
a pretty general schema: It must start with a letter
or an underscore (

) and the rest can have any combination of letters, digits, or underscores,
with unlimited length and the case being significant, so that
sum, Sum, SUM,


three different v
ariables. Keywords are also reserved words, and they cannot be used anywhere
in Python except for the context for which they were intended. Some examples are
, and

Names actually refer to objects, as every defined f
unction or procedure in Python is an
object. Names are introduced by binding operations in blocks. Blocks are the pieces of Python
code that are executed as a unit. Each interactive command, script file, and script command is a
block by itself.

The scope of Python is very basic. If a local variable is defined, its scope is the block in
which it was defined. If the definition is within a function block, the scope is any other block
inside the one that defined it (unless of course a new binding is
given for it somewhere in there),
and all variables bound at the module level are global. Variables used in code blocks where they
were not defined are called free variables.

Names are bound in many ways. Formal parameters, import statements, class and fu
definitions, and targets that are identifiers in assignments,
loops, and more.


Data Types

Python has been defined as duck
typed, which means that variables have types based on the
data that is assigned to them. It is also strong
ly typed, meaning there is no chance for interaction
between clashing types without casting and converting, and it is dynamically typed, because
majority of its type

checking is performed at run time, not compile time.

Guido van Rossum has expressed
his dismay at having to choose between making Python
statically typed or dynamically typed, because, he says, it is not always as simple as “static
typing bad, dynamic
typing good.” He expects that the future holds a sort of mix between the
two, allowing t
he GUI and I/O that works so well with dynamic typing to work in static as well.

“A hybrid language with functional and dynamic aspects might be interesting,”
van Rossum says, “I should add that despite Python’s support for some functional tools like
p() and lambda, Python does not have a functional
language subset: there is no type
inferencing, and no opportunity for parallelization.” (Biancuzzi and Warden)

Variables can be declared anywhere, anytime, and altered however the programmer sees fit.
If n
eeded as a certain data type, Python will likely know what you mean and make it fit.
Variables can also be declared all at once, for example

>>> x = y = z = 0

>>> x


>>> y


>>> z


Python has support for all the regular numeric data types, including
integers, floating
decimals, and even complex numbers. There are plain integers, (
in the range
through 2147483647
), long integers (in unlimited range, subject only to available memory), and
Booleans, which can only be 0 (
) or 1 (

However, Python sees no need for single
precision floating
point numbers, because the
overhead of using objects in Python greatly outweighs the savings in memory single
gives. There is only one floating
point type available, float, and it is


Each complex number that is defined is done so with two floats as arguments, the first is
the real part, and the second is the imaginary part, called later with


Python also includes a library of
sequence types
, that is
, all the data types that represent
finite ordered sets with indices. All sequences have a built

function which returns the
length, and each individual item is selected with square brackets. Sequences are further divided
into groups according to t
heir mutability; their ability to be changed or not.

The immutable sequences, which cannot be changed once created, are strings, unicode
objects, and tuples. The mutable sequences are lists and byte arrays. A list is like a record in Ada
(any number of an
y types can be put in), and a tuple is like a list, only once it has been declared
it cannot be changed.

One exciting feature of Python is that all the sequence types support slicing. This means
that a colon can be used in the subscript to denote which el
ements of the sequence are to be
selected. For example, if you have a list called


will select
all items with index

such that


. When used as an expression, a slice is a
sequence of the same type. This implies that the index set is re
numbered so that it starts at 0.

Also included in Python are
set types
, which represent finite, unordered sets of unique
objects. They are not indexed by subscripts, but can be iterated over, as the

function still
returns the number of items. Sets a
re mutable, but frozen sets are immutable. Frozen sets,
however, are also hashable, meaning they can be re
used as elements of other sets or as
dictionary keys.

The last type in Python that is worth mentioning (besides, of course, callable types (types
defined by the user)) is the dictionary. Described as a
mapping type

on the Python website,
dictionaries are very powerful tools that are very much like associative

arrays in other languages
and hashes in Perl. It is easy to think of them as a set of
key: value

pairs wherein when the key is
referenced, the value is returned, and vice


Expressions and Assignment Statements

In terms of expressions and assignment, Python is actually very basic. All of the logical and
arithmetic operators of C++ are present, in addition to the

operator, which does
exponentiation on
fly. All of the other numeric arithmetic operators
, *, /, %,
) are there, plus the Python
exclusive “
”, which returns the floor division of the
operands. At first glance, this might seem a little extraneous, even silly, but in his blog “The
History of Python,” Guido van Rossum himself explains his
reasoning behind this operator:

The integer division operation (//) and its sibling, the modulo operation (%), go
together and satisfy a nice mathematical relationship (all variables are integers):

a/b = q with remainder r

such that

b*q + r = a and
0 <= r < b

(assuming a and b are >= 0).
” (van Rossum)

The most satisfying thing about Python as a scripting language is its support for dealing
with regular expressions, with syntax very close to Perl and Linux shell commands. As an
example, consider

rt re

for test_string in ['555
1212', 'ILL

if re.match(r'^
d{4}$', test_string):

print test_string, 'is a valid US local phone number'


print test_string, 'rejected'

This code demonstrates how easy it is to use regular expressions in Py
thon. It is a simple
loop that
ines whether or no
t two test strings are

in the format XXX
XXXX, where the
X’s are digits.

Level Control Structures

Python has the conventional
if, while, for,


statements, but the syntax
is a littl
e different. In Python, after putting in the condition, the user must put a colon and have
all the following statements indented to be included in the statement.

Python’s for
statement is also a little different, and more comparable to the foreach
nt of Perl. The general form of Python’s






loop body

: or


else clause]

and is generally used to iterate over an object, but one can also use the

function to
iterate over a series of numbers, as in traditional programming languages. (Sebesta)


Technically, all of Python’s procedures and functions are subprograms. Any of the wide
variety of built
in classes in the Standard Library can b
e used anywhere else, as well as any user
defined or third
party classes. The simplicity of Python is inherent in this design, as there is no
need for a main function or even separate “driver” programs, because everything can be fed
through the interpreter

and then used as it is needed.

Support for Object
Oriented Programming

Part of the genius of Python is that, in effect, everything is an object. Python is structured

oriented language, so it

provides built
in constructs that make it simpl
e for
developers to structure code for maximum reusability.

The number of Python’s constructs
number very high, and there is a system of forums and programs like PEP for deciding what to
add to Python over the various version releases. In order to understa
nd the way Python works
with object
orientation, one must realize that the basic function definition,
, is defining
whatever you code in as a class: something that can be used and re
used as many times as you


Python is a language des
igned with the problem of concurrency in mind. With packages for
both multiprocessing and threading (, and even a package called

in Python 3.2 that handles asynchronous callables. As with any
system trying to employ concurrenc
y, Python is limited by the hardware it is being used on.

Exception Handling and Event Handling

Like most programming languages, Python deals with exceptions by way of a


block in Python works as follows (

First, the

try clause (the statement(s) between the try and except
keywords) is executed.

If no exception occurs, the except clause is skipped and execution of the
try statement is finished.

If an exception occurs during execution of the try clause, the rest of the
clause is skipped. Then if its type matches the exception named after the
except keyword, the except clause is executed, and then execution
continues after the try statement.

If an exception occurs which does not match the exception named in the
except cla
use, it is passed on to outer try statements; if no handler is
found, it is an unhandled exception and execution stops with a message as
shown above.

Event handling in Python can be done by the user in any way they see fit.

Other Issues of Python


is huge, almost overwhelmingly so. There are so many modules and extra things;
hundreds of functions are listed in the Standard Library, it can be dizzying.
Depending on what you want to do and how you want to do it, Python most likely has supp
for it.

Want to use random numbers? No problem. Want to serialize your objects? Try
Python has packages for five different compression types, twelve for file and directory access,
seventeen for generic operating system services, and tons more.

It feels almost infinite.

Evaluation of Python


of t
his report will be an

evaluation of Python as a programming language
overall. Based

on Sebesta’s four criteria of prog
ram language evaluation (
readability, wri
and cost), this evaluation will try to determine the pros and cons of Python.


At first glance, Python seems a little weird. The syntax is all okay; everything is either C++
or English understandable, but there is something missing: braces. Fo
r block comments, Python
uses a strict whitespace with indents and dedents. In his article titled “Why Python?” on how he
came to choose Python over Perl, Eric Raymond writes “
I immediately tripped over the first odd
feature of Python that everyone notices
: the fact that whitespace (indentation) is actually
significant in the language syntax. The language has no analog of the C and Perl brace syntax;
instead, changes in indentation delimit statement groups. And, like most hackers on first
realizing this fac
t, I recoiled in reflexive disgust.

It certainly struck this evaluator at the beginning. But, as Raymond later concedes, after
about twenty minutes with it, using indentation in block comments seems natural, making
everything smooth and pretty. It is, in

fact, very easy to read and understand, unless you have to
nest a bunch of loops and ifs. Even then, however, simple, pragmatic line
line scrutiny makes
everything clear.


Python is certainly readable only to the degree that it is writable
. One cannot hope to
understand or be able to write anything more complex than standard programming without
thorough study of the documentation of the Python website. That being said, the documentation
is superb, showing concrete examples and proving the l
asting epithet that “there should be one

and preferably only one

way to do it.” Without room to try and find different ways to mess with
your program only to have it do the same thing, programmers get their work done more quickly
and do not have to spend

time worrying about strange, unintelligible errors coming out of


Judging by the gleaming reviews all over the Internet, one could say that Python surpasses
all expectations in terms of reliability. Being as intensely reusable as all

of the code you write is,
Python is certainly designed to last. With every new version, only a few things ever get replaced;
the developers opt to keep old things as long as they can while plugging the new features as
better and easier to use. One example

is the “not equal to” operator, which, in version 1.0, was
simply “<>” like in other languages at the time. Nowadays, Python recommends the use of the
“!=” syntax, noting that the “<>” still works, but is obsolete.

The lifespan of Python is seemingly inf
inite. Barely thirty years old, the language has taken
off splendidly and remains in use by tens of thousands of people today. Instead of replacing Perl
or any other of the advanced scripting languages, Python has taken a seat as a very important
language, with more and more companies and employers demanding at least basic
knowledge of it from their employees.


The cost of any programming language is not determined solely by the cost to use it
(Python is Open Source

free to use

but some o
f the more advanced IDEs and other
development environments do come at a fee), but by the costs of training and / or finding
experienced personnel, and the costs of supplying hardware to support the language.
Being so
reliable, Python is naturally very cos
effective. It is easy to teach, and easy to learn.

As long as companies are not interested in “Python masters

“ people who know every in
and out of the syntax and libraries

the cost of training could be very low. Companies can
decide for themselves whi
ch features of this extendable, ever
expanding language are going to be
used, and train their employees to these specific designs.

Finding people who already know Python is rapidly becoming easier and easier. As many
academic institutions transfer over t
o Python as their first language learned, and even more
people are learning it on their own or with the help of any of the numerous aids, Python is
quickly becoming a
lingua franca

of programming. Soon everyone will know Python as well as
C or Java, and th
is element of cost will be a moot point.


The most important criterion of those mentioned is up to employers, obviously, but with all
of them being in such good form, Python certainly seems like a top choice. It is, all at once,
conventional yet c
reative, modern yet rooted in history, and fun
use yet very seriously
integrated into every system imaginable.

The age of Python has begun, and we as programmers would do well to learn it and love it
as quickly as possible.


, Federico and Warden, Shane, ed. Masterminds of Programming. Sebastopol,
California: O’Reilly. 2009

Python Software Foundation. Python Programming Language. <>

Venners, Bill. “The Making of Python, Parts I, II, and III” Jan
uary, 2003.
September, October 2011. <>

Raymond, Eric. “Why Python?” 30 April 2000. October 2011.

Van Rossum, Guido. “Why Python's Integer Divisi
on Floors”. The History of Python. python
- 24 August 2010. October 2011. <http://python

Sebesta, Robert W. Conc
epts of Programming Languages. Ninth Edition.

g, MA: