The Definitive Guide to Django: Web Development Done Right (Paperback)

by Adrian Holovaty (Author), Jacob Kaplan-Moss (Author)
Key Phrases: views urlpatterns, custom template tags, syndication framework, What's Next, Apress Publishing, Returns True (more...)

Editorial Reviews

Product Description

Django, the Python–based equivalent to the Ruby on Rails web development framework, is presently one of the hottest topics in web development today. In The Definitive Guide to Django: Web Development Done Right, Adrian Holovaty, one of Django’s creators, and Django lead developer Jacob Kaplan–Moss show you how they use this framework to create award–winning web sites. Over the course of three parts, they guide you through the creation of a web application reminiscent of chicagocrime.org.

The first part of the book introduces Django fundamentals like installation and configuration. You’ll learn about creating the components that power a Django–driven web site. The second part delves into the more sophisticated features of Django, like outputting non–HTML content (such as RSS feeds and PDFs), plus caching and user management. The third part serves as a detailed reference to Django’s many configuration options and commands. The book even includes seven appendixes for looking up configurations options and commands. In all, this book provides the ultimate tutorial and reference to the popular Django framework.

About the Author
Adrian Holovaty, a web developer/journalist, is one of the creators and core developers of Django. He works at washingtonpost.com, where he builds database web applications and does "journalism as computer programming." Previously, he was lead developer for World Online in Lawrence, Kansas, where Django was created.

When not working on Django improvements, Adrian hacks on side projects for the public good, such as chicagocrime.org, which won the 2005 Batten Award for Innovations in Journalism. He lives in Chicago and maintains a weblog at www.Holovaty.com.

Jacob Kaplan-Moss is one of the lead developers of Django. At his day job, he's the lead developer for the Lawrence Journal-World, a locally owned newspaper in Lawrence, Kansas, where Django was developed. At the Journal-World, Jacob hacks on a number of sites including lawrence.com, LJWorld.com, and KUsports.com, and he is continually embarrassed by the multitude of media awards those sites win. In his spare time&emdash;what little of it there is&emdash;he fancies himself a chef.

Product Details

• Paperback: 447 pages
• Publisher: Apress (December 6, 2007)
• Language: English
• ISBN-10: 1590597257
• ISBN-13: 978-1590597255
• Product Dimensions: 9.1 x 7 x 1 inches
• Shipping Weight: 1.7 pounds (View shipping rates and policies)
• Average Customer Review: 4.2 out of 5 stars See all reviews (23 customer reviews)
• Amazon.com Sales Rank: #180,738 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

19 of 19 people found the following review helpful:

3.0 out of 5 stars A solid introduction, lacking in examples, February 22, 2008

By	James Stewart (Grand Rapids, MI, USA) - See all my reviews (REAL NAME)

Django is a framework I've long (in web years) held in some esteem, despite never having used it before the past few weeks. The framework's creators' many well reasoned contributions on all manner of debates about the web suggested a thoughtful approach, and the range of high quality sites powered by Django has kept growing, with the recent launch of EveryBlock being a prime example of its capabilities. So I was delighted to receive a copy of The Definitive Guide to django: Web Development Done Right for review.

Authored by two of the creators of Django: Adrian Holovaty and Jacob Kaplan-Moss, the book is carefully structured, initially placing django in context by exploring various approaches to web development, and then stepping through initial project creation, templates, models, url configuration, django's famed admin interface, and so on. After eight chapters it changes tack and switches from basic tutorial to more in-depth exploration of areas like the ORM, session handling, caching and deployment. Several appendices provide supplementary material.

The first few chapters do a good job of laying out the foci of the framework's architecture and it's Model Template View (MTV) approach. Its pace is measured and while I wonder if it might be a little too much too soon for those totally new to full stack web frameworks, it would work well for those coming from a background building web apps with PHP, Java, or for those of us who are used to working with Rails. There are new techniques to learn and I found the book particularly useful for grasping the deeply pythonic approach, favouring flexibility over convention.

A clear example of that comes in the use of Context objects for passing values between Views and Templates. The authors initially show us the most verbose and rudimentary way to do it and gradually develop that to show how they've provided for various common cases. By going through those steps there's a good chance the reader will be well equipped to work out ways to simplify their own workflow and/or create new subclasses to promote reuse in their code.

Where the book is lacking is in the examples. The introductory material, and much of the reference content is excellent, but as a newcomer to the framework I felt a little lost in how I should structure my code and how different components relate; it's clear how models relate to the database, but how do I pass them around when building associations?

I recognise that django deliberately avoids the strong conventions of the Rails community (though even there you frequently find newcomers unsure where in the directory structure to place certain components) and there's no need for lengthy tutorials on building a shop or how a magazine cms could work, but when I come to a book like this I'm looking for a guide to best practices at the project architecture level, not just the component level, and I was sorry not to find it. The authors clearly have a lot of experience of structuring django sites of all shapes and sizes and it would be good to learn more about how they keep those sites organised.

That said, this is a solid introduction to django for web developers; a solid contribution in a so-far underserved market and it's likely to come in handy for a number of people. Just be prepared to supplement it with a fair amount of time in search engines working out good strategies for connecting the pieces.

Disclaimer: I was sent a copy of this book for review by the publisher.

59 of 74 people found the following review helpful:

3.0 out of 5 stars Another Definitive Flop from Apress, January 29, 2008

By	orangekay (San Francisco, CA United States) - See all my reviews

I buy books like these because I don't like reading documentation on a computer screen where I can't dog-ear or highlight anything, but after several bad experiences I'll probably avoid these black and yellow striped titles the same way I avoid black and yellow striped insects in the future. O'Reilly books are frequently hit-or-miss affairs, but everything I've seen come out of Apress looks like it was typeset by a 12 year old and simply isn't worth the money. It seems as though anyone who's ever written a single line of code and given it away for free can get a publishing deal these days.

Forgetting for a moment the various reasons why Django itself fails to live up to its own "perfectionist" hype, this book is just not very good. The first couple of chapters do a decent job covering introductory topics, but it quickly becomes apparent that the authors were in a big hurry to finish the rest of it as quickly as possible. There's even a "guest author" brought in at one point for no apparent reason, and his chapter is one of the worst. Those few examples that are given in latter, more advanced, sections are nothing but code that is so full of typos it never should have made it to publication. This is why developers are seldom allowed to pen their own public documentation whether they fetch coffee at a podunk newspaper or not--you spend enough time staring at your own code that you lose all sense of perspective and can no longer approach it as a newcomer would. You know what works best for you and your rapidly balding twenty-nothing IRC clique, and you figure that's good enough for everyone else. It ain't.

Another problem with letting the creators write their own "definitive" books is the way they tend to glance over the framework's shortcomings. The chapter on session management fails to mention the fact that Django expects YOU to clean up stale session data yourself, and the one on deployment makes little mention of the fact that there's not really any good way to get Django running smoothly without root access to the server--something a lot of people do not have--and they actually expect their users to run TWO servers--one for Django and one for everything else, like image files. There are ways around this, but why not put this kind of information right at the front of the book the way most others do so people can make an informed decision as to whether or not they should bother with your product right off the bat? Apache configuration is, according to them, "beyond the scope of this book." A quick Google search showed that any and all bugs related to this matter are immediately closed and marked "will not fix" by Django maintainers. It would seem that arrogance is the one feature of Rails they understood well enough to mimic correctly.

Even if you hate online books, you should stick to the free version. They at least implemented a comments system that will let other people point out where all the various typos are before you get stuck trying to figure out why this perfectionist's code isn't running very perfectly.

12 of 14 people found the following review helpful:

3.0 out of 5 stars Sufficient, but written on drool-proof paper, January 31, 2008

By	DavidInBerkeley (Berkeley, CA) - See all my reviews

This book is a decent survey of Django's capabilities as well as an introduction to MVC-based web dev. Unfortunately it suffers from a very simple problem: too much explanation getting in the way of information. For example: no one cares how "pure" the MVC-ness of Django is. Another example: excellent documentation on regular expressions already exists at the Python module index. I suspect that the authors mistakenly believe this extra information is "helpful" in some sense, but it isn't. It gets in the way!

In short: sufficient to the need, but the authors have SEVERELY compromised its usability with excessive padding and pointless discussion. Unfortunately this seems to be common practice in the web world.