Sessions at DjangoCon US 2011 on Thursday 8th September

Your current filters are…

  • Lightning Talks

    At 9:00am to 10:30am, Thursday 8th September

    Coverage slide deck

  • Keynote: Glyph Lefkowitz

    by Glyph Lefkowitz

    At 10:30am to 11:20am, Thursday 8th September

    Coverage video

  • Advanced Django Form Usage

    by Miguel Araujo and Daniel Greenfeld

    Django forms are really powerful but there are edge cases that can cause a bit of anguish. This talk will go over how to handle many common solutions not currently described in the core documentation. It will also cover some useful third-party libraries and will end with clarifications about what the state of form features will be in Django


    Handy tips
    - Turning non-required model fields into required form fields
    - Overriding clean methods
    - Overriding save method
    - Calling forms the easy way in views
    - Custom field definitions
    - Dynamically adding fields
    - Formsets
    - Testing forms

    Third Party Libraries that make your life easier
    - django-uni-form
    - django-floppyforms

    The future
    - Forms refactor in Django 1.4
    - Documentation improvements

    Time will be left for Q&A.

    At 11:20am to 12:00pm, Thursday 8th September

  • Pinax after Three Years: Lessons Learnt and the Way Forward

    by James Tauber

    The Pinax platform has had its ups and downs since it was launched in 2008. People either love it or just don't get it. About the only thing everyone agrees on is that it doesn't seem to be progressing as fast as it once did. This talk will take a fresh look at the goals of Pinax, what we did well, what we didn't do so well and what we're (slowly) doing to fix it.

    The Pinax platform—an integrated collection of tools, apps and starter projects designed to accelerate getting from idea to site launch—has had its ups and downs since it was launched in 2008. It is still widely misunderstood ("isn't it just for social networks?" "how is it different from just reusable apps?") and yet used for an increasing number of sites. People either love it or just don't get it. About the only thing everyone agrees on is that it doesn't seem to be progressing as fast as it once did.

    This talk will take a fresh look at the goals of Pinax, what we did well, what we didn't do so well and what we're (slowly) doing to fix it. It will be of interest to people still not sure what Pinax is all about, existing users of Pinax keen to know where it's headed and people just interested in the challenges running an open source project, especially with both a community and commercial aspect.

    At 11:20am to 12:00pm, Thursday 8th September

    Coverage video

  • Advanced security topics

    by Paul McMillan

    An in-depth look (with demonstrations) at the how and why of several advanced security topics. Discussion of ways to improve security of the framework moving forward.

    This talk will introduce several advanced security topics, and discuss how Django fares. Topics will include timing attacks, man-in-the-middle, hashing issues, brute force attacks, and several topics that can’t currently be discussed (pending fixes in core). Expect practical demonstrations of “theoretical” vulnerabilities.

    The second half of the talk will focus on how we can improve Django’s security in the future. How can we improve response time and transparency for security issues? How can we make it easier to provide security enhancements for new code while retaining backwards compatibility? How can the community work to support security work that is low on the priority list for current core devs?

    At 1:30pm to 2:10pm, Thursday 8th September

    Coverage video

  • Teaching Django to Comrades

    by Issac Kelly

    Inevitably you're going to run into somebody who wants to learn Django, or maybe both Python and Django. This talk will help you make it less painful for them.

    20 months ago, Issac started learning Django and Python on his own. He got miserably stuck and did lots of things poorly. With a load of help from the community, 6 months later he was competent, and confident enough to use Django for his clients.

    Later that year, his company hired it's first employee, who also, didn't previously know Python or Django, and this summer, they hired an intern... who knew some Python, and no Django.

    Come see what we did to accelerate the process of going from 0 to $ in Django.

    At 1:30pm to 2:10pm, Thursday 8th September

  • Deployment, Daemons and Datacenters

    by Andrew Godwin

    A tour through the systems that power ep.io, the Python hosting platform, from the array of daemons powering the system, to how redundancy is set up, and also covering general best practices for hosting Django sites yourself.

    At ep.io, we spend all day finely tweaking and polishing our deployment systems, and this talk will go through some of the parts of our archtecture, show you some of our code, and also advise you on deploying Django sites on your own servers.

    Topics covered include our use of ZeroMQ for redundant communication, the difficulties of running services with transatlantic latency, our extensive use of Eventlet for asynchronous, concurrent I/O, how we've used (and modified) pip and virtualenv, and how we've leveraged class-based views to make our API part of our normal URL structure.

    In addition, there will also be some advice on how to run sites on your own servers, including what programs to use, how to lay things out, and sensible backup strategies.

    At 2:20pm to 3:00pm, Thursday 8th September

  • RTFM -- wRite The Friendly Manual

    by James Bennett

    An introduction to writing great documentation. Not just in the "here's some tools and how to use them" sense, but in the "here's why you should care about documentation" sense and the "how to write things people will read" sense.

    Sections 1-3 are intended to be short but sweet, introducing a few essential topics to set the stage for what comes after. Section 4 is where the real meat begins, covering some basic principles of actual writing. Sections 5-6 return to technical matters, with most of the focus being on overviews rather than in-depth tutorials on specific tools or services.

    - The two kinds of documentation
    1. Documentation for people who will hack on your code
    2. Documentation for people will run your code
    3. Why you need both!
    4. Support mechanisms

    - The other two kinds of documentation
    1. Hand-written explanations
    2. Auto-generated API references
    3. Why you need both!
    4. Support mechanisms

    - The mindset
    1. DDD - Document-Driven Development
    2. Write documentation before code
    3. Documentation as specification

    - The style
    1. "Raise your hand if you have a liberal-arts degree"
    2. A whirlwind tour of good prose
    3. Be friendly!
    4. Writing to your audience
    5. How to write a how-to

    - The tools
    1. reST
    2. Sphinx
    3. pydoc/epydoc/etc.
    4. Django!

    - The rest
    1. What your file layout should look like
    2. Magical distutils incantations
    3. Hosting
    - on your own
    - on packages.python.org
    - on readthedocs
    - other options

    - Feedback
    1. Why "documentation" is a component in your issue tracker
    2. How to handle suggestions gracefully

    - Questions

    At 2:20pm to 3:00pm, Thursday 8th September

    Coverage video

  • Taming dependencies with pip

    by Carl Meyer

    Dependency management sucks. Pip provides some options for making it suck a bit less, but not all of them are immediately obvious. This talk will cover a number of strategies for making your deployments faster and more reliable, and demonstrate how to implement them in practice.

    Areas we'll cover:

    - Easy wins: requirements files, version-pinning, virtualenv, PyPI mirrors.

    - One single point of failure is bad, multiple single points of failure are worse: kick your PyPI addiction with find-links, bundling sdists, "vendoring", or your own package index. We'll go over how each of these looks in a real project, and the tradeoffs with each.

    This talk will assume basic knowledge of pip and requirements files; we'll be covering intermediate and advanced usage.

    At 3:30pm to 4:10pm, Thursday 8th September

  • Y'all Wanna Scrape with Us? Content Ain't a Thing: Web Scraping With Our Favourite Python Libraries

    by Katharine Jarmul

    Love or hate them, the top python scraping libraries have some hidden gems and tricks that you can use to enhance, update and diversify your Django models. This talk will teach you more advanced techniques to aggregate content from RSS feeds, Twitter, Tumblr and normal old web sites for your Django projects.


    • lxml fu: etree vs html
    • lxml faves: iterlinks, prev/next, strip_tags, linepos
    • incorporating xpath
    • building your xml views/templates with lxml (this bullet is optional: may not have time but would love to hear if folks might find this useful)
    • learning how to build a good JSON API handler: what you can learn from some amazing api handlers when you have to build your own
    • feedparser, HTMLParser, re: the quick & dirty ways to parse when LXML isn't fast enough

    At 3:30pm to 4:10pm, Thursday 8th September

  • Cache rules everything around me

    by Noah Silas and Jacob Burch

    This talk aims to briefly introduce the core concepts of caching and covers the best practices of using Django's cache backend.

    "Are you caching?" is a question asked early on in any yarn on web scaling advice. These conversations are much better steered by asking a more open and difficult questions "What is your caching strategy?" and “How are you implementing it?” This talk aims to briefly introduce the core concepts of caching and quickly moves to cover the best practices of using Django’s cache backend. We will let the audience know what the important questions to ask are, give them advice on how to implement the right answers, and when even the built-in core backend isn’t enough, point them to more advanced techniques and the right third party tools.

    Important questions covered:

    • Why am I caching in the first place? Do I have to?
    • What is your caching strategy?
    • What are examples of good caching strategies?
    • Where do I put my cache code?
    • How dynamic is my content? Could I use a published cache?
    • Should I cache Django objects, or raw data?

    At 4:20pm to 5:00pm, Thursday 8th September

  • Making interactive maps for the web

    by Zain Memon

    When tasked with displaying geo-data, 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 talk is for you.

    This talk is a technical deep-dive into the technology behind Trulia's crime maps: a database with 50 million crime incidents, an app layer that generated hundreds of thousands of map tiles, and a front-end to make it interactive.

    Each piece of the talk is instructive, aimed at arming devs who have a casual interest in GIS with the tools they need to make sexy maps. Specifically:

    • Best practices for storing geodata in PostgreSQL
    • Running geo-queries with GeoDjango
    • Creating map tiles with TileStache
    • Styling maps with Polymaps

    No prior experience with GIS is required, though running through the GeoDjango intro tutorial would be helpful.

    At 4:20pm to 5:00pm, Thursday 8th September

    Coverage video

  • Django Core Dev Panel

    by Carl Meyer, Justin Bronn, Idan Gazit, James Bennett, Julien Phalip, Russell Keith-Magee, Jacob Kaplan-Moss, Alex Gaynor, Andrew Godwin and Paul McMillan

    At 5:10pm to 6:00pm, Thursday 8th September

    Coverage video