DjangoCon US 2011 schedule

Monday 5th September 2011

  • Making Interactive Maps for the Web

    by Zain Memon

    This tutorial teaches students how to create beautiful, interactive maps for the web. When asked to display geodata, most developers decide to put some big red markers on an embeddable Google Map and call it a day. If you're interested in creating maps that are more beautiful, more interactive, and more usable, this tutorial is for you.

    By the end of this tutorial, students will be able to build a light version of Trulia's crime maps: http://trulia.com/crime/

    Hour 1: The back-end

    • Storing geodata in PostgreSQL
    • Querying geodata with GeoDjango
    • Ways to customize GeoDjango's admin

    Hour 2: The front-end

    • Displaying geodata on a map with Polymaps
    • Creating and designing map tiles with TileStache

    Hour 3: Dessert

    • Adding interactivity to maps
    • How to make geodata pretty

    At 9:00am to 12:30pm, Monday 5th September

  • Test Anything, Test Everything

    by Dave Dash

    Testing in Django is easy if you're testing models against your database. What happens when you need to test other-systems, like a search engine, or an API? This tutorial will cover how I built SphinxTestCase, ESTestCase and redisutils to allow us to maintain test coverage on our web sites.

    Testing backends other than your database can be tricky. It's entirely necessary, however, otherwise you'll start getting glaring holes in terms of coverage.

    This tutorial will show you how to subclass TestCase and properly setup and teardown external systems.

    It will also show you how to be nice to your other developers who may want to opt-out of testing backend systems (like search).

    At 9:00am to 12:30pm, Monday 5th September

  • Ultimate Django Tutorial Workshop

    by Katharine Jarmul, Audrey Roy, Corey Bertram, Shimon Rura, Jacob Kaplan-Moss, Daniel Greenfeld, James Punteney and Russell Keith-Magee

    All proceeds earned from this tutorial will go to the Pyladies sponsors program.

    This will be a walk-through of the Django Tutorial, where everyone works together with the instructor and lab-assistants to complete the tutorial. If enough time remains, we'll also use one of the new Django hosts (such as http://gondor.io or http://djangozoom.com) to post student projects on-line.

    Students need to already have Python 2.6/2.7 installed on their machine and have already completed an introductory Python course such as http://learnpythonthehardway.org.

    At 9:00am to 12:30pm, Monday 5th September

  • Deploying Django Applications With Amazon Web Services (DA CLOUD!)

    by Corey Bertram

    We all know that Django makes building web apps with python really easy, but few realize that Amazon Web Services makes deploying scalable fault tolerant applications just as easy! This class will focus on taking a provided Django web application and deploying it to AWS through a series of hands on exercises using many of the AWS services and some very easy to use open source Django applications.

    In this class we will start with a demo Django app that they will use for the rest of the exercises. Before getting started there will be a brief intro to Boto, a python project that makes working with AWS a joy.

    At 2:00pm to 5:30pm, Monday 5th September

  • Unbreaking Your Django Application

    by Christophe Pettus

    An application that works great in development and test can be crushed by real-life deployment. Don't let your project be one of them. In a hands-on workshop, fix a (realistically) broken Django example so that it can hold its head high under load.

    Your Django application runs wonderfully in test and in beta, and with great fanfare you launch it, and... it falls over and goes boom. The speed of development that frameworks like Django give you can result in some ugly secrets when the application experiences real load for the first time.

    In this hands-on workshop, we’ll take a (supplied) Django application and fix it up so that it can survive in the wild. Topics will include caching in all its myriad forms, getting the most out of the ORM, database optimization, and deployment environments. We’ll use PostgreSQL as the underlying database, but the techniques here are applicable to any database and, indeed, nearly any application development environment.

    Among the topics we'll cover are:

    • Model design for best performance.
    • Optimal indexing strategy.
    • Effective caching.
    • Transaction management and avoiding lock conflicts.
    • Efficient use of the ORM.
    • When and how to move work into the database.
    • External caches, poolers and load balancers for high-volume sites.
    • How to debug performance at the database level.

    At 2:00pm to 5:30pm, Monday 5th September

Tuesday 6th September 2011

  • Welcome

    by Steve Holden

    At 9:00am to 9:15am, Tuesday 6th September

  • Keynote: The Future of Community Management

    by David Eaves

    At 9:15am to 10:30am, Tuesday 6th September

    Coverage video

  • From Designer to Django'er in Six Weeks: A Story from Solo Founder

    by Tracy Osborn

    Django gives you the tools to start a successful web app even if you're new to development. Learn how to build and launch a web startup whilst avoiding common pitalls and problems.

    You don't have to be an expert programmer to launch a web startup; designers, marketers, and novice developers can all use Django to quickly launch a web app, build a company, and start bringing in revenue. It's a common trap to get caught up in endless development — follow these tips and tricks to get launched even when you're still learning.

    At 10:30am to 11:10am, Tuesday 6th September

  • Testing with Lettuce and Splinter

    by Adam Nelson

    Lettuce, adapted from Ruby's Cucumber, is a behavior driven development (BDD) testing suite that sits on top of Splinter - a web driver for simulating real-world usage of your site. Learn the ins and outs of BDD using Lettuce and Splinter for rapid deployment.

    Yipit uses Lettuce and Splinter to simulate users moving through the actual site under different scenarios. Unlike unit testing, this allows a tester to find problems at various levels (including Javascript and HTML defects) and under various situations specific to a browser environment. This talk will introduce various tools available right now as well as how to write extensible tests for a production environment. Ways to integrate testing into the release process will also be discussed.

    At 10:30am to 11:20am, Tuesday 6th September

  • Confessions of Joe Developer

    by Daniel Greenfeld

    Over the course of 6 years of Python development at NASA, Revsys, and Eldarion; Daniel Greenfeld has picked up a lot of easy tricks stolen from the best and brightest in the Python community that make him look good in front of his peers and clients. And now, at great risk to his career and reputation, he is going to show you how he does it.

    Highlights:

    • Get the most out of the least amount of work.
    • Being forgetful is responsible for open source development.
    • Using commonly available tools to make you look like you know what you are doing.
    • All the sample code is accessible outside the slides

    At 11:20am to 12:00pm, Tuesday 6th September

  • Monkeying Around with Python at New Relic

    by Graham Dumpleton

    This session will cover the challenges of creating a production application performance monitoring system for Python. It includes an overview of the architecture of the system, as well as how it hooks into Django and captures details about web transactions, database transactions, memcache requests, exceptions and much more.

    This session provides a technical review of the challenges associated with instrumenting Python for production monitoring. How do you place monitoring hooks into code that cannot be modified directly in order to collect meaningful performance data? Concepts covered in this session will include:

    • Using context manager objects to time execution of code.
    • Using context manager objects to catch details of exceptions.
    • Applying a context manager to functions using wrappers and decorators.
    • Applying a context manager to WSGI applications and components.
    • How to go about applying the above to existing code using monkey patching.
    • Deriving the name of a wrapped object for identification purposes.
    • Using post import hooks as a means to trigger monkey patching.
    • Driving the process of monkey patching from a configuration file.

    The talk includes real-world examples of how these mechanisms have been used to add instrumentation to the Django web framework in order to collect actionable performance data.

    At 11:20am to 12:00pm, Tuesday 6th September

  • Django Hosting Panel

    by Sean O'Connor

    Over the last year there's a been a whole new crop of specialized hosting platforms for Django applications. In this panel, we speak to a number of the people behind these new platforms to discuss what benefits they offer, what challenges they face, and what the Django project/community can do to encourage their growth.

    This is a moderated discussion among a variety of new, specialized, Django hosting providers. Each participant will be given an opportunity to provide a brief overview of their offering and what benefits it provides over other solutions. After these introductions, the focus of the panel will be to discuss the common issues being faced by these new platforms, what they are doing to address the issues raised, and what the Django community can do to improve the available hosting options.

    At 1:30pm to 2:10pm, Tuesday 6th September

    Coverage video

  • The story and tech of Read the Docs

    by Eric Holscher

    Hosting open source documentation was a mess. The best-of-class solution for the Python world as uploading a tarball of html to packages.python.org or doing similar to upload to github pages.. We set out to solve this problem using the current best of class tools that Django has to offer.

    At 1:30pm to 2:10pm, Tuesday 6th September

  • Real-Time Django

    by Adam Miskiewicz and Ben Slavin

    The web is live. APIs give us access to continuously changing data. We discuss ways to get real-time data into your app, how to handle data processing and what to do when you get thousands of updates per second.

    "Caching is the answer" can't always be the answer. We discuss how to ensure your site is up-to-date when the data behind it is continuously changing.

    We'll discuss three primary areas pertaining to real-time-data.

    WHERE IT COMES FROM – REAL-TIME DATA SOURCES

    • Streaming APIs
    • Polled APIs (and strategies for dealing with rate limits)
    • PubSubHubbub

    DATA PROCESSING

    • Denormalization
    • Workers
    • Incremental and generational MapReduce

    DATA PRESENTATION

    • Partial caching
    • Continuous caching
    • Broadcasting real-time updates
    • Failure models

    At 2:20pm to 3:00pm, Tuesday 6th September

  • Testing: The Developer Strikes Back

    by Sandy Strong

    “Code not tested is broken by design” - Jacob Kaplan-Moss Every programming project has unique testing needs. It’s not always easy to understand what those needs are, or how to write tests that satisfy them. One of our goals as developers is to write tests that minimize failures in production that can cost our companies time, money, resources, and in many cases, hours of sleep!

    Every programming project has unique testing needs. It’s not always easy to understand what those needs are, or how to write tests that satisfy them. One of our goals as developers is to write tests that minimize failures in production that can cost our companies time, money, resources, and in many cases, hours of sleep!

    At 2:20pm to 3:00pm, Tuesday 6th September

  • State of the DSF Keynote

    by Russell Keith-Magee

    At 3:30pm to 4:20pm, Tuesday 6th September

  • A summer in the wild

    by Alex Gaynor

    I've spent this past summer away from Django, working for Quora, venturing into the depths of a foreign codebase, and making it faster by running on PyPy. This talk will feature the lessons I've learned about Django, PyPy, and web development in general.

    This talk is going to cover some pretty eclectic ground. Some of the stuff I'm going to talk about includes:

    • Making stuff run on PyPy
    • Profiling and benchmarking a webapp
    • Stuff I missed when I wasn't using Django
    • Tools every Pythonista must be using
    • Good ideas from Quora that Django should steal
    • Learning a giant codebase on the quick
    • Process is no substitute for good process

    At 4:20pm to 5:10pm, Tuesday 6th September

    Coverage slide deck

  • Secrets of PostgreSQL Performance

    by Frank Wiles

    PostgreSQL is effectively the default RDBMS for Django. Learn the dark arts of optimizing this powerful database to be blazingly fast on your own hardware or in the cloud.

    PostgreSQL has been the default recommended database since Django was initially released. Learn the dark arts of optimizing this powerful database. Both in general use cases and specifically for Django.

    In this talk you'll learn:

    ->Things to avoid
    -double duty servers
    -disk contention
    -unnecessary queries

    ->The "Big 3" configuration options you should always adjust
    - shared_buffers
    - effective_cache_size
    - random_page_cost

    ->Other useful configuration options

    ->Hardware considerations
    - RAM, disks, and CPU
    - Rackspace Cloud vs Amazon EC2
    - tablespaces
    - SSDs

    -> Common Django ORM issues
    - Slow count() operations

    -> Indexing Tips and Tricks
    - Index types
    - Multi-column indexes
    - Partial indexes

    -> Performance Tools you can use

    -> The "Dark Arts"
    - Planner Statistics
    - materialized views
    - crazy replication

    At 4:20pm to 5:00pm, Tuesday 6th September

  • Fireside Chat with a BDFL

    At 5:10pm to 6:00pm, Tuesday 6th September

    Coverage video

  • Lightning Talks

    At 6:00pm to 6:30pm, Tuesday 6th September

    Coverage video

Wednesday 7th September 2011

  • Lightning Talks

    At 9:00am to 10:30am, Wednesday 7th September

    Coverage video

  • Keynote: Itch Scratching, Pros & Cons

    by Brad Fitzpatrick

    At 10:30am to 11:20am, Wednesday 7th September

  • Django Package Thunderdome: Is Your Package Worthy?

    by Audrey Roy and Daniel Greenfeld

    What makes a package useful? What is it about certain packages that makes them must-haves for any project? I’ll go over topics like: purpose, structure, docs, tests, availability on PyPI and Github/Bitbucket, activity, and more. I will visit some of the most useful grids on djangopackages.com and highlight my top package picks, showing examples of what makes these top packages so great.

    What makes a Django package usable? (10 min)

    Purpose
    Structure
    Docs
    Tests
    Community
    Modularity (pluggability)
    Availability on PyPI
    Availability on Github/Bitbucket
    Activity
    Code quality
    Package evaluations (25 min)

    Go to a Django Packages grid
    Drill down into doc/code examples from winning packages to show what makes them so usable
    Making your favorite project get onto my favorites list (5 min)

    Here's a rough outline of what we have in mind:

    POINTS OF COMPARISON:

    Purpose
    1. To paraphrase James Bennett, the smaller the scope and greater the focus of your app, the better it will be. Application logic can be tighter and patching/replacing the app is easier.
    2. The package addresses a real need.

    Structure

    Docs
    1. No docs means your app fails. I won't even look at it.
    2. Doc strings do not suffice as documentation.
    3. Bonus points awarded for using rtfd.org for documentation hosting.
    4. If there are dependencies, you must make the requirements clear.
    5. The installation steps should be bulletproof. I should be able to follow your install docs and have the package just work.

    Tests
    1. No tests means it is hard to do Python/Django/Dependency upgrades
    2. No tests means the the code is unpredictable.

    Community
    1. When was the last contribution?
    2. How many people are contributing?
    3. Who is contributing?
    4. Attribution of authors: every author and contributor should be credited. This shows that you're willing to go the extra mile for your package.

    Modularity (pluggability)
    1. Installation should be minimally invasive to the rest of your project.
    2. Do not confuse pluggability with over-engineering for every generic use case.
    3. Within your app, sub-modularity is great, e.g. different registration backends for django-registration

    Availability on PyPI
    1. Give your package proper version numbers and always have the latest release available on PyPI.

    Version Control Hosting
    1. If you aren't on Github or Bitbucket you don't exist. Nothing else has the visibility for Django developers.
    2. Launchpad and SourceForge are much less popular
    3. Google Project Hosting lacks an API, so no metrics can be gathered.

    Code quality / Best practices
    1. Code follows PEP-8?
    2. Tries not to have too many variables set in settings.py?
    3. Easy to plug in, INSTALLED_APPS = ‘foo’ preferred.
    4. Naming of your app: should be django-something, should be descriptive

    SHOWDOWNS:
    Fundamentals that every project needs
    Registration
    Profiles
    Blogs
    Tagging

    REST
    Database migrations

    TAKE-HOME BONUS:
    A sheet of useful packages recommended by Django developers whose opinions we respect deeply.

    At 11:20am to 12:00pm, Wednesday 7th September

    Coverage video

  • RESTful APIs: Promises & Lies

    by Tareque Hossain

    Over the last few years RESTful APIs have become an integral part of many django projects. But some of the fundamental questions still remain unanswered. How do you decouple resources from models, formatting from definitions, authorization from authentication? How should you define resources? How do you handle pagination? Deliver facets? Prevent abuse? Implement versioning? Let's have a look.

    Implementing RESTful APIs for django applications used to be the talk of the town. Eventually a few API frameworks emerged. Some were designed to provide a quick & easy path to implementation. Some focused on decoupling components as much as possible. At the same time, numerous blog posts were published and emails exchanged seeking/ pitching sound API concepts & best practices. Somehow till this date, there is arguably no single solution that addresses all of the major concepts/practices around designing & securing RESTful APIs. Why? What were the promises? What were the lies?

    In this talk, an attempt is made in identifying these concepts/practices in light of recent experiences with a PBS Education Technology project. In designing a RESTful API, it is important to establish a relatively simple resource definition that is uniform across all resources, yet powerful enough to deliver errors, pagination, facets as well as data from attributes/ methods of various models/ instances. It is also desirable to have serialization formats decoupled from these definitions and delivered to consumers according to their preferences.

    Securing the API is a complex task as well. Not all RESTful APIs are meant for public consumption. Yet it is necessary to make AJAX calls that might leave the API vulnerable and expose security patterns. This talk highlights why it is important to have decoupled authentication backends, why 2-legged-OAuth can be an excellent choice in protecting the API and how adding pre-approved tokens can help differentiate between user/ application specific calls.

    Concepts/ best practices evolve over time. So should the API. Sometimes it is necessary to perform refactoring or optimization that alters the API significantly. In any case, establishing a path to versioning API components is a prudent choice. Here, the fundamentals are explored.

    Rest of the talk presents how PBS Education Technology team enhanced django-piston to incorporate the ideas and suggestions mentioned above. Also consumer side practices and security implementations are demonstrated using code examples.

    At 11:20am to 12:00pm, Wednesday 7th September

  • A Little South Sanity

    by Brian Luft

    South is a useful tool in agile development environments, but learning to use it effectively can take some practice. In this demo-driven talk we'll walk through some common workflow examples, disect a couple pitfalls, and call out the relative strengths and weaknesses of South as a tool at each step. Finding South's sweet spot for your environment will give you the best results.

    The talk is based on observations and lessons learned from a few years of using South on large projects, with different teams and team makeups (mixes of developers, creative staff, etc.), and common questions on IRC / mailing list.

    The demos will move quickly; a working understanding of creating and applying South migrations will be assumed. We'll make changes to a sample project, sometimes get ourselves into trouble, and pull back the curtains to figure out the best approach.

    While going through the demos we'll take opportunities to learn how to consider:

    • Impact on invidual developers
    • Impact on other teammates / staff
    • Impact on development and deployment environments
    • Whether South can represent your desired operation in a sane manner
    • Long-term code maintenance
    • Testing changes and undoing messes

    One thing I've found is that different teams and developers have varying philosophies about managing South migration histories over time. We'll put these ideas into context and audience members should come away with a good feeling about how to best use South for their particular needs.

    At 1:30pm to 2:10pm, Wednesday 7th September

    Coverage video

  • Real World Django Deployment Using Chef

    by Noah Kantrowitz

    Chef, a popular configuration management tool, is gaining momentum in the Django community. Learn how to deploy Django sites using Chef, be they one server or a thousand.

    Chef, a configuration management tool, is increasingly popular in the Django community. Many people have yet to take the plunge, and are still managing production systems exclusively through tools like Fabric or Buildout. In this talk I will quickly show the basics of building Chef recipes, both in general and a tour of the Django-and-Python-specific tools available. I will then walk through a suite of cookbooks built to deploy Packaginator as a production site in the cloud. If suitable wireless is available, I would like to do a live demonstration at the end, bringing up a new site from scratch.

    Outline:

    Introduction
    - Chef basics
    - Resources
    - Actions
    - Recipes
    - Cookbooks
    - Roles
    - Search

    Python cookbook
    - Community site/cookbooks
    - pip provider
    - virtualenv provider

    Django application recipe

    Other misc cookbooks
    - Postgres
    - Redis

    Packaginator cookbooks
    - Application recipe
    - Postgres master/slave
    - Gunicorn
    - Nginx
    - HAProxy
    - Redis
    - Celery

    Demo (pending wireless)

    Q&A

    At 1:30pm to 2:10pm, Wednesday 7th September

  • Building APIs in Django with Tastypie

    by Issac Kelly

    Tastypie is one of a couple of frameworks for building APIs with Django. Isaac will go over some of the reasons you might pick Tastypie, and how to implement a Tastypie on top of an existing Django project.

    Tastypie makes APIs. It is both straightforward, and powerful, once you know the basics of what it expects, and how it's structured.

    This talk will introduce, as well as share a few tricks for less simple APIs.

    At 2:20pm to 3:00pm, Wednesday 7th September

    Coverage video

  • Making the Django ORM Multilingual

    by Jonas Obrist

    Why does Django make it hard to have translated database contents? And what solutions are there to make it easier? And how can Django make multilingual database contents less of a pain?

    Multilingual database contents are not an easy thing to accomplish in Django. While there are many projects out there helping you with this, they all have their good and bad sides. The reason for this is that Django does not really help a lot in this area. There are things though, Django could do to make this easier and for some use cases, the existing solutions are actually good enough. I would like to share my knowledge and experience in this field, having developed almost exclusively multilingual websites and having developed two projects to make this easier in Django.

    At 2:20pm to 3:00pm, Wednesday 7th September

    Coverage video

  • Stop Tilting at Windmills - Spotting Bottlenecks

    by Yann Malet and Brandon Konkle

    Learn the questions to ask and the tools to use to spot performance problems in your application. We won't tell you how to scale your site, but we will show you how to locate the bottlenecks as they pop up.

    Performance optimisation has always been a hot topic among the Django community, and as applications become more mature and larger companies adopt Django for high-traffic projects this issue will heat up even more. This talk will not focus on resolving performance/scalability issues but rather on discovering them. It will try to answer the following questions:

    • How do you know where the worst problems are?
    • When did the problem start, and what parts of your application are affected?
    • How do you tell the difference between the giant performance monsters and the windmills that aren't really big problems at all?

    This talk will not spell out a quick and easy 5-step method to alleviating all of your performance woes. It will, however, show you ways to measure your site’s performance over time and spot the real trouble areas as they occur. It’s vital to know both your application and your user well in order to create an effective test plan. We will discuss the importance of reliable performance measurement and realistic performance tests, and walk you through the tools we use to identify and track problems.

    • Django Debug Toolbar - get internal information about what your application is doing
    • Django Debug Logging - log Debug Toolbar statistics to the database and review details and aggregated summaries.
    • Creating a cron job to run automated performance tests at regular intervals
    • Jmeter for external tool to create load tests with high concurrency
    • Integrating Jmeter with Jenkins using the performance plugin

    To close up, we’ll mention some of our favorite resources on handling the performance problems that you encounter during your testing. We’ll also provide links to other tools that you can use as part of your testing efforts. With this information at your disposal you can charge boldly through the meadow on your faithful Rocinante, attacking the real performance problems and leaving the windmills behind.

    At 3:30pm to 4:10pm, Wednesday 7th September

  • Why the Django Documentation Sucks

    by Steve Holden

    Documentation is normally held to be one of Django's strong points. Steve attempts to point out that even the best can stand improvement.

    As someone who had to learn Django primarily from the documentation, the author was glad that the documentation existed, but it seemed to make assumptions of knowledge that weren't necessarily in his head at the time. It was therefore a frustrating enough experience to result in this talk, which looks at some of the ways that the Django documentation could be made more user-friendly and effective.

    At 3:30pm to 4:10pm, Wednesday 7th September

    Coverage video