Cal Henderson, Flickr’s Engineering Manager, closed out the first day of DjangoCon with a very funny talk entitled Why I Hate Django. Despite the fact that he claims to be working on “yet another fucking blogging engine” built with Django, Henderson professed, tongue planted firmly in cheek, that he hates Django.
Of course, mind you, Henderson doesn’t hate Django nearly as much as he hates smug Rails developers, but nevertheless, he has some issues with Django:
Django team does not have beards = not serious
Django team = boy band
Verbose template syntax makes people cry (Henderson demonstrated how using the Smarty template system can save you three keystrokes)
Low version numbers are suspicious (Django is only at 1.0)
Django can’t pluralize octopus
Perhaps the funniest criticism was that, unlike Python, a serious programming language would not have a cheese shop where you get eggs.
Henderson did hit on one mildly serious point — that frameworks speed your development time at first, but then you often hit a wall. The framework doesn’t do what you want and you have to dig into its internals to figure out how to do what you want, which is often more difficult than writing your own framework from the ground up.
He also addressed some real shortcomings of Django, like its inability to read and write from multiple database servers (which, incidentally, is something the developers are aware of and will be added in a future version).
Of course, while Henderson’s presentation had some valid points that the Django community is well aware of, it was all in good fun and made for a lighthearted end to the first day of DjangoCon.
Cal’s slides from his talk will be available (soon, he promises) on his site at iamcal.com/talks.
Adrian Holovaty took the stage at DjangoCon shortly after lunch to walk Django users down memory lane, showing the unlikely evolution of a very simplistic tool he and Jacob Kaplan-Moss hacked together in a hurry, to the mature open source framework that is today’s Django.
Suffice to say that Django comes from humble beginnings. Holovaty walked through a series of humorous, self-deprecating slides showing the many mistakes he and the other earlier developers made in Django’s earlier stage.
He also highlighted the many times he assured the community that some feature would be “the last major change before 1.0.” As seasoned Django users know, the 1.0 release was a long time coming and Holovaty freely acknowledged that his early promises often went unfulfilled.
After tracing the evolution of Django to the semi-stable state it reached earlier this year, Jacob Kaplan-Moss offered an overview of the significant changes that have happened in the last several months leading up to the 1.0 release.
Perhaps the most exciting news for Django newcomers is 1.0′s much improved and expanded documentation. Not only have the Django docs been updated to reflect the new features (with some 40,000 new lines of documentation), but there are some new documentation tools like the ability to build the docs locally or even generate very nice PDF versions for offline reading.
As proof of Django’s open source approach and the vibrant community surrounding it, Moss reports that about half of the source code contributions are now coming from the community. The Django author’s page currently lists some 230 authors.
The first annual Django conference kicked off this morning at the Googleplex in Mountain View, California. Speaking to a rapt audience of Django fans (yes, it’s a nerdfest), Python creator Guido van Rossum delivered a keynote talk which focused how Google has used Django in its App Engine service. He also offered some new details about what’s in store for the future of App Engine.
Guido outlined the major goals for the next version of App Engine, which include a new fee structure for apps that are in danger of exceeding the service’s current free quotas. The new options will allow for pay-as-you-go billing, somewhat similar to Amazon’s S3 and E2 services.
Other new features coming to App Engine include support for large file uploads and downloads, more storage capacity, more development languages and some new batch processing tools.
As for when the new features will arrive, van Rossum declined to offer specifics. However, he did say that the pay-as-you-go option should be available by the end of the year.
As for how App Engine and Django work, van Rossum covered both the internals of App Engine, where Django powers the template system, and also how to create your own Django-based apps within the App Engine environment.
It turns out that, according to van Rossum, App Engine has a long history with Django. While App Engine has its own mini app framework — dubbed webapp — when the developers were looking for a good template language they turned to Django.
Unfortunately because the App Engine team adopted Django very early on, the template language is stuck on the .0.96 Django release, which until recently was the latest stable version.
Now that Django 1.0 has arrived, bringing with it some new template features, App Engine is bit behind the curve. While van Rossum says upgrading the internal tools “isn’t an option,” he did say the plan is to eventually bump the App Engine API to support Django 1.0, allowing developers who want to access Django 1.0 template features to do so.
While Django may power the templates behind App Engine, most attendees here at DjangoCon are more interested in potentially running their applications on App Engine. The second half of Rossum’s keynote covered the the specifics of how to do that — unfortunately, it requires a good bit of hacking.
While it is possible to use Django on App Engine, right now you’ll need to use a modified, slimmed down version of Django 1.0 — you’ll lose models, ORM, and database backend tools (there isn’t a real SQL interface in App Engine, which render those tools a moot point).
The real downside to Django running on App Engine is that — without models support — you’ll lose the very nice Django admin interface which is one of the framework’s most attractive features. Van Rossum did say, “there is hope” for getting the Admin interface working in App Engine, but he offered no timeline.
After the keynote, addressing questions from the audience, Rossum encouraged developers at the conference to work on a App Engine specific release of Django, which would help make it easier for Django fans to run the framework under App Engine.
The creators of Django are set to kick off the first-ever conference dedicated entirely to their web-application framework. The inaugural DjangoCon gathering will take place Saturday, Sept. 6 and Sunday, Sept. 7 at Google’s headquarters in Mountain View, California.
Often compared to Ruby on Rails, Django is a web framework written in the Python programming language. It was designed with one purpose in mind: to make building complex websites much easier.
Django began life at one of the web’s first daily news publications, the Lawrence Journal World Online. The fast pace of the online news cycle drove LJ World’s developers to create a framework that was easy to expand and update within the tight deadlines of a newsroom. Today, Django powers popular sites like social sharing service Pownce, news aggregator Everyblock, and photo site Tabblo. It’s also the backbone of Google’s recently launched App Engine platform for building scalable web apps.
With mainstream players like Google adopting it and the project’s recent 1.0 release, Django is well-positioned to take on Web 2.0 darlings like Ruby on Rails in the coming years.
Django is perhaps most lauded for its automatically generated administration system, which eliminates many developer headaches. Although it isn’t a content management system like Drupal, it’s often used to create customized systems similar to Drupal.
Standouts on the DjangoCon schedule include talks from the founders and creators of Django: Jacob Kaplan Moss, Adrian Holovaty and Simon Willison, as well as other contributors who have helped Django on its three year journey to 1.0. Also on hand and speaking is Python creator Guido Van Rossum, who will be talking about Google’s use of Django in App Engine.
Webmonkeys Scott Gilbertson and Michael Calore will be in attendance, so if you were among the lucky 200 Django-heads who grabbed a free ticket to the conference, be sure to seek us out and say hello. We’ll be there both days, bringing you blog posts, photos and interviews. We’ll also be stopping by the Django 1.0 release party on Saturday night. So if you couldn’t make the trip to Mountain View, be sure to tune in here for all the latest news.
“Django 1.0 represents the largest milestone in Django’s development to date: a web framework that a group of perfectionists can truly be proud of,” wrote lead Django programmer Jacob Kaplan-Moss. “Django’s received contributions from hundreds of developers, been translated into fifty languages, and today is used by developers on every continent and in every kind of job.”
Among the many improvements included in 1.0 is a revamped admin application, automatic escaping of templates, better unicode handling and “pluggable” file storage. One caveat: there are a number of backward-incompatibility issues in the final release you may want to read about before upgrading.
The announcement comes just a few days ahead of Djangocon in Mountain View, CA where it is likely to be the talk of the town. The developers conference takes place on September 6 and 7 at Google Headquarters.
Oh, and yes, Django is named after the French jazz musician Django Reinhardt. Besides both being jazzy, there’s little relation.