Navigation

In the past decade the Python community has seen a wealth of riches
spring up in the area of web development. Frameworks and tools have
made it easier than ever to use Python for web applications, with some
focused on particular domains, others on particular footprints, and
still others on particular deployment strategies. Most of these
frameworks have built upon WSGI, the Web Server Gateway Interface,
which became part of the Python standard library in version TK. WSGI
provides some conventions for applications and servers to communicate
with one another, much as it’s spiritual predecessor, CGI, provided
conventions for executing scripts via a web server.

With the inclusion of WSGI, it’s possible to begin developing a web
application by simply picking and choosing pieces that seem best for
the task at hand. Indeed, some projects do just that. So why use a
larger framework like Django, Pylons, or Blue Bream? Frameworks
build upon WSGI to provide a reasonable set of defaults, a set of
conventions, for getting started with development and focusing on the
specific problem at hand. It’s possible to spend time evaluating
libraries that map a URL to a view, but a framework’s developers have
already (presumably) done such an evaluation, and chosen one that they
feel will work well with the other parts of the framework. TK:Community

A framework is general purpose by definition, but that doesn’t mean
your use of it must be. Put another way, most frameworks support a
variety of databases, platforms, and deployment infrastructures. But
just because you use that framework doesn’t mean you need to, as well.
A good framework will help you get up to speed more quickly, and will
let you target things for your environment when needed.

Django is a popular, powerful web framework for Python. It has lots of
“batteries” included, and makes it easy to get up and going. But all
of the power means you can write low quality code that still seems to
work. Effective Django development means building applications that
are testable, maintainable, and scalable – not only in terms of
traffic or load, but in terms of being able to add developers to
projects. When we’re talking about Effective Django, we’re really
talking about software engineering for web applications. The examples
and the details we’re going to talk about are Django specific, but the
ideas and principles are not.

So what does Effective Django mean? It means using Django in a way
that emphasizes writing code that’s cohesive, testable, and scalable.
What do each of those words mean? Well “cohesive” code is code that is
focused on doing one thing, and one thing alone. It means that when
you write a function or a method, that it does one thing and does it
well. This is directly related to writing testable code: code that’s
doing too much is often difficult to write tests for. When I find
myself thinking, “Well, this piece of code is just too complex to
write a test for, it’s not really worth all the effort,” that’s a
signal that I need to step back and focus on simplifying it. Testable
code is code that makes it straight-forward to write tests for, and
that’s easy to diagnose problems with. Finally, we want to write
scalable code. That doesn’t just mean it scales in terms of
performance, but that it also scales in terms of your team and your
team’s understanding. Applications that are well tested are easier for
others to understand (and easier for them to modify), which means
you’re more able to improve your application by adding engineers.

Part of being able to effectively use Django is understanding
what’s available to you, and what the restrictions are. Frameworks
are necessarily general purpose tools, which is great: the
abstractions and tools they provide allow us to begin working
immediately, without delving into the details. At some point,
however, it’s useful to understand what the framework is doing for
you. Whether you’re trying to stretch in a way the framework didn’t
imagine, or you’re just trying to diagnose a mysterious bug, you
have to look inside the black box and gain a deeper
understanding. After reading Effective Django you should have an
understanding of how Django’s pieces fit together, how to use them to
engineer web applications, and where to look to dig deeper.

My goal is to convince you of the importance of these principles, and
provide examples of how to follow them to build more robust Django
applications. I’m going to walk through building a contact management
application iteratively, building tests as I go.