Your current filters are…
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
- 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
- Testing forms
Third Party Libraries that make your life easier
- Forms refactor in Django 1.4
- Documentation improvements
Time will be left for Q&A.
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.
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?
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.
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.
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
- The rest
1. What your file layout should look like
2. Magical distutils incantations
- on your own
- on packages.python.org
- on readthedocs
- other options
1. Why "documentation" is a component in your issue tracker
2. How to handle suggestions gracefully
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.
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.
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:
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:
No prior experience with GIS is required, though running through the GeoDjango intro tutorial would be helpful.
5th–8th September 2011