A great started for an an excellent MVC. I would recommend this book for anyone wanting to quickly assemble a website. If anything it's the python version of Ruby on Rails.

The book makes it easy to take a project from idea to concept to reality quickly.

The only issue that I have with the book is the implementation with existing or legacy web servers. The book seemed to lack procedure beyond "the norm". The procedure for Apache was very cookie cutter and did not meet the needs that I had. It honestly didn't work with any install of Apache, but mine was a specific install. Some research into the area before hand would be more beneficial.

I've dabbled with what I consider to be all the major web frameworks: TurboGears, Pylons, Rails, and Django. Religion and other biases aside, what really made me finally settle on Django was the documentation (though community/all-in-one-ness/robustness aspects are also nice factors). What's notable out about Django documentation? Precision, attention to detail, comprehensiveness, and general emphasis on polish.

To many people, a book is what makes a new technology both accessible and credible. A couple years ago when I thought TurboGears was the framework I wanted, I got the book, and it was crap. Subsequently, other things about the framework started to feel lacking. Then with Pylons, there is no book, which reflects the constant state of flux of the component mix. Cool framework, admirable ideals, but no book. Now with Django, there is *the* book, and it's beautifully done, and you discover that the framework is, too.

I see this book as a true community resource. Its examples directly extend *the* tutorial. Being available in its up-to-date entirety as a living document, anyone can simply answer a question by consulting a link to a book section. I applaud the authors opening this book up to be accessible to everyone, both in ease of reading, and in being free for download. It is always reassuring to find a book about a tool being written by the authors of a tool, and that should contribute to making it the canonical Django resource.

Even though I'm not a real world user of Django (I'm a Grails guy), I thought I'd give this book a try as Django is in the same category of web development frameworks as Grails. After reading this book, I had a solid foundation knowledge about how Django works and principles behind it. And it is well written. I would recommend it for any serious real world user of this framework.

Although you can read this book for free online, I like having it around for easy reference. The first eight or so chapters are good for learning Django; with the subsequent chapters and appendixes good for reference.

I will say that the online document is updated regularly, with sometimes useful comments from readers. That said, I would still buy this good.

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.

This book basically covers all the parts of Django, and will give you a good overview . It misses some details though, such as middleware, which is just skimmed through. There's also not much on customizing Django, i.e not using it's built in authentication but if you try to roll out your own.

This book was a pleasant surprise. I read a lot of computer books and one thing I appreciate is short, clear examples that illustrate a point but also trigger you to reach a wider understanding on your own. If you can get your point across in 10 lines of simple code, do it, rather than using 50 lines of fancy code. The real trick in doing so is avoiding writing multiple "Hello World" level examples.

This books manages that again and again. For example, at some point they used a template example that was a bit longer than their usual but only in order to contrast Django's template inheritance approach to a simple include-subtemplate approach (which Django also allows). They then point out the conceptual difference in a sentence and leave you to work out the implications which any savvy programmer should be able to do.

One advantage of exploring particular problem domains with Python is that the language is simple enough that you can spend a lot of time thinking about the core concepts rather than about coding implementation issues. For the newbie to web programming this book highlights many bits of web knowledge, like caching, html headers, and especially web security. It's almost worth it to buy it and use Django just to 'get' http even if you end up using some other web framework later.

Any drawbacks? A few. It would have been nice to see more Ajax and XHTML examples and most of all, advice on unit testing approaches. Some points were omitted specifically because they are covered by plugins that are still under development. Nothing you can't pick up online though.

One other caveat: though it walks you through web development, this book assumes a basic understanding of Python and HTML. CSS and Javascript aren't covered.

Overall you are left with a solid basis of how to use, and extend, Django in under 300 easy-to-read pages (plus 130 of technical appendix). Is this book useful beyond the online docs? Definitely. The Django online docs were good enough to get me started, but the examples here gave me a number of important insights on Django best practices. If you value your time, get it and give a bit back to the guys who wrote Django in the first place.

This book was an extremely pleasant surprise. I read a lot of computer books and one thing I appreciate is short, clear examples that illustrate a point but also trigger you to reach a wider understanding on your own. If you can get your point across in 10 lines of simple code, do so, rather than using 50 lines of fancy code. The real trick in doing so is avoiding writing multiple "Hello World" level examples.

This books manages that again and again. For example, at some point they used a template example that was a bit longer than their usual but only in order to contrast Django's template inheritance approach to a simple include-subtemplate approach (which Django also allows). They point out the conceptual difference in a sentence and leave you to work out the implications which any savvy programmer should be able to do.

One advantage of discovering particular problem domains with Python is that the language is simple enough that you can spend a lot of time thinking about the core concepts rather than about the coding implementation issues. For the newbie to web programming this book hilights many bits of web knowledge, like caching, html headers, and especially web security. It's almost worth it to buy it and use Django just to 'get' http even if you end up using some other web framework later.

Any drawbacks? A few. It would have been nice to see more Ajax and XHTML examples and most of all, advice on unit testing approaches. Some points were omitted specifically because they are covered by plugins that are still under development. Nothing you can't pick up online though.

One other caveat: though it walks you through web development, this book assumes a basic understanding of Python and HTML, and, to a lesser extent, CSS and Javascript.

Overall you are left with a solid basis of how to use, and extend, Django in under 300 easy-to-read pages (plus 130 of technical appendix). Does this book deliver value beyond the online docs? Definitely. The Django online docs are good. Good enough to get me started, but the examples here gave me a number of important insights on Django best practices. If you value your time, get it and give a bit back to the guys who coded Django in the first place.

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.

I buy books like these because I don't like reading documentation on a computer screen, 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.

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 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 work for a 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 little 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. Why not put this information right at the front of the book the way most others do? Apache configuration is, according to them, "beyond the scope of this book." It took a Google search to show that any and all bugs related to this matter are immediately closed and marked "will not fix" by Django maintainers. It would seem that the 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.

I buy books like these because I don't like reading documentation on a computer screen, 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.

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 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 work for a 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 little 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. Why not put this information right at the front of the book the way most others do? Apache configuration is, according to them, "beyond the scope of this book." It took a Google search to show that any and all bugs related to this matter are immediately closed and marked "will not fix" by Django maintainers. It would seem that the 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.

I buy books like these because I don't like reading documentation on a computer screen, 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.

Forgetting for a moment the various reasons why Django itself fails to live up to its own 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 hurry to finish the rest of it as quickly as posible. Those few examples that are given in latter, more advanced, sections are full of typos that never should have made it to publication.

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. Apache configuration is, according to them, "beyond the scope of this book." It took a Google search to show that any and all bugs related to this matter are immediately closed and marked "will not fix" by Django maintainers. It would seem that the arrogance is the one feature of Rails they understood well enough to mimic correctly.

Read the online version for free. They at least implemented a comments system that will let other people point out where all the various typos are before you get stuck.

This book is a great resource. I highly recommend buying it and coverting all of your webistes to django. Only if you like doing about a 1/3 of the work as compared to other languages/frameworks out there.

I've been messing with Django for some time, and I've long awaited the release of this book. This is one of the few times I've painstakingly gone through all the code samples and replicated as many of the examples as I could. The book's chapters are laid out logically and the material is presented intelligently by the creators of the framework.

The authors don't waste time and energy exhaustingly spewing rhetoric about how Django came to be, how they developed it and what their mindset is/was/will be. They just let you get to work, quickly be productive, and have fun developing cool stuff for the web. Which is the whole point of Django to begin with.

It's not written with a total newbie audience in mind, so some experience with web work, databases and Python programming is helpful, maybe even necessary. But, with some elbow grease, an open mind and a little persistence, you'll catch on. Although the authors are partial to Linux and Mac environments, the book gives more path and settings examples in those OSes, as well as Windows.

However, in criticism a scant few of the examples rely on a slightly older build of the framework, so some of the namespaces might be inconsistent with the book, and code snafus are spotty. I found myself hungry for more screenshots, which is a minor, but still desired shortcoming of the text.

Nonetheless, the book is chock full of little tidbits and tricks to help you write less code that's more reusable. Best practices are enforced as far as maintaining the "MTV" application architecture, including heavy doses of refactoring. As far as topics, Simon Willison's demo of building an intra-site search utility was what I found to be the book's coolest example. Other great chapters are working with non-HTML content, internationalization and working with Django's templates. The appendices are also phenomenal, making for an excellent books-within-a-book as a reference guide.

In future editions of the book I'd hope to see more pragmatic app examples, more APIs and their capabilities cited, more "one-off" utilities built, and perhaps even an app developed consistently across chapters to bring the whole thing together and reinforce the concepts.

This book is without doubt essential reading for getting down with Django.

This is THE book to get for learning the Django framework. (written by the creators of Django) I am reviewing this from a beginner's perspective..
I loved the structure of the book. The beginning parts give you the basics of all the parts of the framework, without talking about syntactic sugar right away. (IMO a good thing, unlike parts of the Rails book)
Later on, it gives you the more advanced features of Django, the generic views, the helper stuff, which abstract away the repetitive things that you might have to do if you only knew the things in the first few chapters.
If you read this book sequentially, it's good because the earlier stuff shows you what the later chapters are abstracting away.

My expectations coming in were pretty high, given that one of the authors was a journalism major, and I still thought that the writing exceeded my expectations
I also liked putting the miscellaneous API details in the back, it's a handy reference.

Overall, a great book to learn Django from. Django's online docs are one of the best, but deadtree versions give you a different feel, and this one is definitely worth the money.

I've been using Python since the late 90s and have been using Django since it was first released to the public. I thought I knew how everything fit together in Django, but I was wrong. This book filled in the gaps and gave me a deeper understanding of the Django framework itself as well as the philosophy behind it.

The writing style is great and the examples walk you through the framework in a way that gives you a good understanding of how Django works. I wish I would have had this book when I first started looking at Django.

I highly recommend this book to Django beginners and experts alike.

A good web site framework makes you more productive, and if you're a geek (admit it, you wouldn't be reading this if you weren't one), more productive == more fun. A good idea without good documentation is nothing more than a hobby project. Django is, most emphatically, *not* a hobby project.

Adrian and Jacob's writing is technically accurate while remaining clean and readable. They do far more than simply regurgitate the online docs (which they were major contributors to), they get into the 'why.' They are of that rare breed that can first write the code (and do it well) and then write the docs, and do that well also.

One of the criteria I judge technical books on is their examples -- good examples don't simply repeat in code what was given in the previous paragraph, they expand and illuminate the concepts and, at their best, they cause the reader to have small (or large) epiphanies about the subject at hand. In particular, "Chapter 10: Extending the Template Engine" and "Chapter 15: Middleware" caused me to rethink how to handle several knotty problems. The copious examples in the book expertly walk the line between being too simple to be instructive and too complex to digest. Although this is not intended as a book for Python beginners, beginners can learn an lot about good Python programming from it.

As a programmer, every few years something comes along that makes you want to redo everything you've recently been working on--because it's easier, it makes sense, and it's actually fun.

Using Django for web development is the difference between using a rusty screwdriver or having five people with new Makita cordless drills.

Similar to the www.djangoproject.com site, the book is clearly written with excellent examples.

Although I'm glad the book is out, the selfish side of me wishes another year passed before more people were exposed to this framework. This sentiment is echoed by a friend who started a job at a cancer research center 6 months ago. Since his first project finished (done in Django), three departments have now dumped Java frameworks for Django. The productivity difference is incredible--and logical--no hidden "magic"

I just finished reading this book and it's great. I have been using Django since early 2006 and this book really helped fill in the gaps.