Foundations of Python Network Programming 978-1-4302-3004-5

CHAPTER 11 ■ WEB APPLICATIONS
the sake of JavaScript routines running in each web page. If your application will require these, then
check each framework that interests you for its degree of support for XML-RPC, JSON, and a RESTful
approach to data documents in general.
Obviously, user authentication is an enormous issue for many programmers. Some web frameworks
remember usernames and passwords and feature support for login screens and session cookies out-ofthe-box;
others make you build these components yourself or plug in a third-party approach to solve
these issues. Still others have such complex systems of extensions and plug-ins that some developers
can never get user configuration working in the desired manner.
If you need specific advanced features such as a Comet-like approach to serving events back to the
browser, then you should obviously look for a framework that implements those required features well.
Note that some quite successful web applications are produced by combining two or more frameworks
that are loosely coupled through a common database. For example, you might combine a Django
application serving HTML pages with a restish application that provides RESTful CRUD operations that
can be invoked from JavaScript. Choosing the best tool for the job sometimes involves combining
several tools, instead of demanding everything from a single monolithic application.
Finally, understand that experience is often the best guide to choosing a web framework. This
means that, after all of the window shopping, you are going to have to sit down and try actually writing
in some of the various frameworks available before you really know whether a given framework will
prove a good fit for either yourself or your problem. We all like to think that we know ourselves well
enough to predict such things without doing any actual coding. For example, we may feel we know
intuitively which web framework is really “our style” and will let us be productive. However, trying a
range of approaches may reveal that your initial guess about how your mind works did not actually do
justice to what you can accomplish with an ostensibly “ugly” framework, once you understand its
benefits.
Remember that, whatever framework you choose, you are writing Python code. This means that
your application's quality is going to depend at least as much upon your ability to write good, clean,
Pythonic code as it will upon any magical features of the framework itself. The framework might even
feel rather awkward to you, or it might be selected by a senior team member with whom you disagree;
but always remember that this is Python, and that its flexibility and elegance will generally let you write a
good web application, whatever framework you ultimately end up using.
Pure-Python Web Servers
A fun way to demonstrate that Python comes with “batteries included” is to enter a directory on your
system and run the SimpleHTTPServer Standard Library module as a stand-alone program:
$ python -m SimpleHTTPServer
Serving HTTP on 0.0.0.0 port 8000 ...
If you direct your browser to localhost:8000, you will see the contents of this script's current
directory displayed for browsing, such as the listings provided by Apache when a site leaves a directory
browsable. Documents and images will load in your web browser when selected, based on the content
types chosen through the best guesses of the mimetypes Standard Library module.
The SimpleHTTPServer is a subclass of BaseHTTPServer, which is also the foundation of the
wsgiref.simple_server that we looked at earlier. Before the WSGI standard was invented, small Python
programs could subclass BaseHTTPServer if they needed to answer raw HTTP requests. This is actually a
common difference between the old mechanisms by which Python programs provided extensibility, and
the more modern and Pythonic mechanisms. It used to be popular to write a class with stub methods
inside, and then tell programmers to extend it by subclassing and defining those methods; today, we use
namespaces, callables, and duck-typed objects to provide much cleaner forms of extensibility. For
example, today an object like start_response is provided as an argument (dependency injection), and
192