Add an eventSessions at DjangoCon Europe 2012 with slides
Your current filters are…
- Coverage: Slides
Monday 4th June 2012
-
Keynote
-
PostgreSQL when it is not your job.
In this DevOps world, Django programmers are increasingly being asked to manage the database as well. In 45 brisk minutes, we will talk about (nearly) everything you need to know to bring up, tune, and keep a PostgreSQL database health. We'll go over installation, basic tuning, backups, disaster recovery, and helpful tools and techniques.
-
Round Pegs and Square Holes: Django and MongoDB
by Daniel Greenfeld and Audrey Roy
The common approach for getting MongoDB to work with Django has been to replace Django ORM based pieces with MongoDB based alternatives. This is usually accomplished by forcing MongoDB to behave like a relational database and is done with extremely sophisticated code. The result is something that doesn’t behave quite as nicely as a relational database, and negates many of the advantages MongoDB (and other NoSQL databases) possess, hence the title of this talk. This talk will not only go over the existing heroic but flawed approaches, but will also propose a simpler, more direct path for getting Django to play well with MongoDB. Simpler is important, because it makes possible the creation of a developer-accepted bridge between MongoDB powered efforts and the hundreds of Django ORM powered efforts available on Django Packages.
Co-presented with Audrey Roy, this highly technical talk will include theory and a lot of code examples.
-
Class-based Generic Views: patterns and anti-patterns
by Bruno Renié
Django's class-based views API — landed in Django 1.3 — offers a very powerful yet complex way to build Django views. This talks aims at explaining the internals of the API and giving practical advices for building class-based views. Crowd-sourced examples of patterns and anti-patterns will be shown and explained.
- The view contract in Django
- Other class-based stuff in Django
- API internals
- Mixins and the MRO
- Interesting uses of CBVs
- How to shoot yourself in the foot :)
-
Django and the Real-time Web
by Zack Voase
The modern Web—indeed, the modern user—demands that we write applications that work faster than the traditional request/response cycle. But how relevant is Django in the age of pjax, node.js and WebSockets? I believe Django remains a powerful utility in the new Web, and in this talk I'll share some techniques and tools for reducing the complexity of real-time applications. I'll explain how I manage code duplication when key business logic is split between the client and the server, and demonstrate ways to preserve a RESTful and accessible design whilst providing a more responsive experience to clients who support it. Technologies I'll touch upon include ZeroMQ, gevent and WebSockets, and I hope to leave everyone from beginner to veteran with some valuable insights.
-
Building secure Django websites
by Erik Romijn
Django helps web developers in many ways, security included. But, it can't and won't handle everything - there's still security issues left that you need to take care of yourself.
This talk explores some of the most common security issues Django developers can face, with a specific focus on using the features Django already provides to help out. We'll look at how vulnerabilities can be exploited, how exactly Django tries to help and what you still need to take care of yourself.
If you always enable CSRF in your apps, but don't really know what it does or why, this is the session for you. If you always disable CSRF in your apps, this session may be just in time to save you.
-
Healthy Webapps Through Continuous Introspection
Every application has its hotspots -- small portions of code that consume considerably more resources than all of the other code combined.
Django apps are no different. Some pages, invoked with the just the right, or wrong input, can bring a server to its knees, hogging the CPU and taking many seconds, or in extreme cases even minutes to render. By keeping workers tied up, the whole system can then become slow to respond, or collapse altogether.
Many webservers have a crude built-in failsafe to prevent this. They automatically kill workers that fail to complete their requests in time. As a result, you may not fully appreciate, or indeed realize at all that you are routinely serving 500 pages, denying users access to your service, or leaving uncommitted database transactions -- possibly even slowly corrupting data.
Workers killed by force leave virtually no forensic traces and so even when issues are suspected, it's hard to pin them down.The cause behind these hotspots can be poorly generated SQL queries from the ORM, an algorithm with non-linear complexity, excessive disk or network IO, or lock contention in the database -- to name just a few.
Oftentimes these problems escape a developer's attention, as dev and test environments simply don't have the dataset, level of concurrency or sheer size of the real thing.
In this talk we'll address the challenges of tuning your Django app with continuous automatic runtime inspection tools, including homegrown Dogslow. We'll uncover the pages that consume disproportionate amounts of time and cycles to complete and the pages that get killed altogether.
We'll discuss several ways to help you identify and eliminate the hotspots, both passively through monitoring exclusively, as well as actively by selectively interrupting workers before they get killed and examine how to effectively interpret the automatically collected forensic evidence.
-
I Hate Your Database
After years of working with all sorts of databases and wrangling with South to support just five of them, Andrew takes a look at databases (relational, document, key-value and more) and at some of the problems that Django programmers often come across with them.
The talk will cover (among other things) the disadvantages of relational databases, why "NoSQL" isn't always the answer, the pains of storing geographic data, a small amount of database theory, and the very small number of good things about MySQL.
-
Lightning talks
by tom christie, Tomasz Paczkowski and Marc Egli
Tuesday 5th June 2012
-
Lightning Talks
-
LFS - Lightning Fast Shop
LFS is a online shop based on Python, Django und jQuery.
LFS enjoys growing popularity amongst users and developers. According to
djangopackages.com, LFS is the most downloaded Shop for Django (~60.000 download on PyPI).
The source code is watched by ~210 developers and the Google Group has ~165 members.In this talk Kai Diefenbach, founder and core developer, gives an overview to LFS.
- Introducing the most important features, like the catalog, payment and shipping methods, checkout, etc.
- Introducing some big live shops - numbers and facts
- How to setup LFS. Installation and first steps
- How to develop for LFS? Core and add-ons
- Outlook into the future of LFS
-
Using CSS Preprocessors Effectively
by Jonas Wagner
Whether it's SCSS, LESS or STYLUS, css preprocessors have become
a part of the modern web development tool chain.
The main objective of this talk is to give you an overview of the common features of css processors and how they can be used to drastically improve the fronted development workflow by increasing both development speed and maintainability.
It will also give you an overview of the existing options to help you choose the right tool for your needs.
Finally you will learn how to incorporate css preprocessors efficiently into a django project. -
It's about time!
Time zone support is a major new feature in Django 1.4, but empirical evidence shows it's often overlooked or misunderstood.
In this talk, I'll explore how dates and times are represented in Python, why their handling was overhauled in Django, and what it means for developers.
-
Lightning Talks
Wednesday 6th June 2012
-
Adding Tests to an Uncovered Application
by Zach Smith
Ideally, all code would have test coverage, but this is not a reality.
When you start a new project, you want to move as quickly as possible. This often comes at the expense of test coverage. Besides, you don't even know if anyone will even use your application, so tests might never be necessary.
As your userbase and your team grow, however, testing becomes a necessity.
This talk will go over tools and strategies employed by Yipit in transitioning from a 3 person development team working on an application with no tests, to an organization of 14 engineers with a highly covered codebase.
-
Implementing real time web applications with Django
-
Lightning talks
- Sync-models
- VIM introduction
- CBV based tab navigation
-
How Heroku Uses Heroku To Build Heroku
Within Heroku you'll find many languages (Ruby, Python, Go, Erlang, Clojure), many tools (Pivotal Tracker, Github, Github Issues, Trello), and many forms of communication (Campfire, Grove.io, GChat, Skype). Heroku internally is comprised of many small teams, with a total of 50 engineers there exist nearly 20 teams. Each team interacts through their own preferred form of communication.
Despite their very different working styles, each team is able to and often do deploy on a daily basis without being blocked by other teams. We do this by building small sharp tools and letting systems communicate across well defined contracts and APIs. I'll cover how some of the teams use various tools, but more broadly how we use the platform and methodologies to grow our team without compromising ability to execute quickly or quality.
-
Flasky Goodness (or Why Django Sucks?)
This talk dives into the specifics of why Django isn't always the best tool for the job, general frustrations with the framework, and potential fixes.
It will balanced out with many Django praises too, of course.
Schedule incomplete?
Filter by Day
- Monday 4th 9
- Tuesday 5th 5
- Wednesday 6th 5
- Thursday 7th 0
- Friday 8th 0